diff --git a/.agents/skills/test-t3-app/SKILL.md b/.agents/skills/test-t3-app/SKILL.md index 0e11b50e1c83..80a7ac98cea5 100644 --- a/.agents/skills/test-t3-app/SKILL.md +++ b/.agents/skills/test-t3-app/SKILL.md @@ -26,6 +26,23 @@ Shared browser dev is single-origin: Vite proxies the backend paths, so never se The dev runner disables browser auto-open by default. Do not pass `--browser` during automated testing: an automatically opened page can consume the one-time bootstrap token before the controlled browser uses it. +### Previewing the dev server from a remote client + +When T3 itself is being driven from another machine — the app connected to this environment over a +tailnet or LAN address rather than `localhost` — a dev server bound to loopback is not reachable at +that address just because the hostname is. Opening it does **not** require `--share`: the +environment resolves the port on demand, reusing an existing `tailscale serve` route, using the +environment's own address when the port already answers there, and otherwise publishing a +tailnet-only HTTPS route for the port and withdrawing it when the dev server exits. + +Give the preview a `localhost:` URL and let it resolve. Never hand-write the environment's +hostname with the dev port appended — that is the shape that fails, because nothing promises the +dev port is published under the same number or scheme. + +If the port cannot be made reachable, the preview reports why and what to do (dev server not +running, tailscale not logged in, no permission to manage routes, tailnet port already taken). +Treat that message as the result; do not retry the same URL. + ### Verify a shared environment before human handoff When another person will use the printed pairing URL, first open the shared origin without the pairing path or fragment in the controlled browser and confirm the T3 Code app loads. This browser navigation is required even when curl succeeds because browsers block some otherwise reachable ports before making a network request. diff --git a/.agents/skills/test-t3-mobile/SKILL.md b/.agents/skills/test-t3-mobile/SKILL.md index 3fcf94334fd6..a447139fd969 100644 --- a/.agents/skills/test-t3-mobile/SKILL.md +++ b/.agents/skills/test-t3-mobile/SKILL.md @@ -66,7 +66,7 @@ Use these client origins: - Android Emulator: `http://10.0.2.2:` - Physical device: bind the backend to `0.0.0.0` and use the host's reachable LAN origin -Enter the complete `http://` origin to make the test transport explicit. Bare IP addresses default to HTTP, while bare hostnames default to HTTPS. When testing web and mobile together, run `vp run dev --home-dir --host 127.0.0.1` instead and do not launch a second backend over the same base directory. +Always enter the complete `http://` origin; the mobile host field otherwise assumes HTTPS. When testing web and mobile together, run `vp run dev --home-dir --host 127.0.0.1` instead and do not launch a second backend over the same base directory. ## Start or reuse Metro safely diff --git a/.easignore b/.easignore new file mode 100644 index 000000000000..277c13a5b7c9 --- /dev/null +++ b/.easignore @@ -0,0 +1,56 @@ +# Keep EAS project archives small. Mobile only needs the monorepo packages it +# resolves through pnpm — not vendored agent reference trees or desktop shells. + +# Vendored reference repos (agents only; never imported by app code) +.repos/ + +# Desktop / electron / native host tooling +apps/desktop/ +apps/vscode/ +apps/discord-bot/ +/native/ +release/ +release-mock/ +dist-electron/ +.electron-runtime/ + +# Infra, docs, agent metadata +docs/ +.agents/ +.grok/ +.github/ +.claude/ +.cursor/ +.vscode/ +infra/ +artifacts/ +.showcase/ +apps/mobile/.showcase/ + +# Tests and snapshots (not needed for EAS bundle) +**/__screenshots__/ +**/*.test.ts +**/*.test.tsx +**/*.spec.ts +**/*.spec.tsx +**/test-results/ +**/playwright-report/ +**/.vitest-*/ + +# Local / generated +node_modules/ +.t3/ +.turbo/ +.alchemy/ +.dir-deploy-n +.logs/ +*.log +.DS_Store +.env +.env.* +!.env.example + +# Git / IDE noise +.git/ +.idea/ +*.tsbuildinfo diff --git a/.env.example b/.env.example index fc67dcef9478..48573482cb93 100644 --- a/.env.example +++ b/.env.example @@ -21,6 +21,17 @@ T3CODE_CLERK_CLI_OAUTH_CLIENT_ID=hzxSgY2cH10sDU2r # automatically. T3CODE_RELAY_URL=https://relay.t3.codes +# Optional: GitHub App bridge for continuing an existing worktree-backed T3 thread +# from a pull-request comment. See docs/integrations/github-app-setup.md. +# The webhook route stays disabled unless all four required values are set. +# T3CODE_GITHUB_APP_ID=123456 +# T3CODE_GITHUB_APP_PRIVATE_KEY_PATH=/absolute/path/to/private-key.pem +# T3CODE_GITHUB_WEBHOOK_SECRET=replace-with-a-random-secret +# T3CODE_GITHUB_APP_MENTION=t3-code-dev +# T3CODE_GITHUB_ALLOWED_REPOSITORIES=patroza/*,macs-holding/*,effect-app/* +# T3CODE_GITHUB_MIN_PERMISSION=write +# T3CODE_GITHUB_TURN_TIMEOUT_MS=1800000 + # Optional: hosted app origin used by the CLI's out-of-band OAuth flow. # Defaults to https://app.t3.codes; override to test against a staging deployment. # T3CODE_HOSTED_APP_URL=https://nightly.app.t3.codes @@ -29,3 +40,13 @@ T3CODE_RELAY_URL=https://relay.t3.codes # T3CODE_MOBILE_OTLP_TRACES_URL=https://api.axiom.co/v1/traces # T3CODE_MOBILE_OTLP_TRACES_DATASET=t3-code-mobile-traces-dev # T3CODE_MOBILE_OTLP_TRACES_TOKEN=xaat-... + +# Optional: sign and publish the mobile app from your own Expo and Apple teams. +# Development and preview builds append .dev and .preview to the bundle identifier. +# T3CODE_MOBILE_IOS_TEAM_ID=ABC1234567 +# T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER=com.example.t3code +# Set to 1 only for free Xcode Personal Team builds. This disables paid-only +# widgets, push capabilities, App Groups, associated domains, and EAS updates. +# T3CODE_MOBILE_IOS_PERSONAL_TEAM=1 +# T3CODE_MOBILE_EAS_PROJECT_ID=00000000-0000-0000-0000-000000000000 +# T3CODE_MOBILE_EXPO_OWNER=your-expo-username diff --git a/.envrc b/.envrc new file mode 100644 index 000000000000..9416b3bc6759 --- /dev/null +++ b/.envrc @@ -0,0 +1,9 @@ +# Prefer the repo gh policy shim so coding agents cannot undraft with raw +# `gh pr ready` (use `pnpm pr:ready`). Installed by scripts/install-git-hooks.mjs. +PATH_add .tools/bin + +# Default bare `gh` commands to the fork, not gh's upstream-parent default +# (`pingdotgg/t3code`). Without this, `gh pr view`/`create`/`checks` resolve +# against upstream and miss the fork's PRs. Explicit `--repo` always overrides, +# so the stack tooling (which always passes `--repo`) is unaffected. +export GH_REPO="${T3CODE_FORK_REPOSITORY:-patroza/t3code}" diff --git a/.githooks/README.md b/.githooks/README.md new file mode 100644 index 000000000000..14997b488e3c --- /dev/null +++ b/.githooks/README.md @@ -0,0 +1,49 @@ +# Native Git hooks + +`pnpm install` configures `core.hooksPath=.githooks`. The tracked hooks exist +immediately in every linked worktree; `post-checkout` reconciles dependencies +after branch checkout and worktree creation before Git returns. T3 configures +the hook path and triggers that checkout once for a fresh clone, before exposing +the repository to the user. + +## `post-checkout` + +### 1. Clear TypeScript project emit (always on branch / worktree checkout) + +Composite packages and build outputs leave gitignored `dist/` and +`*.tsbuildinfo`. After a branch switch those artifacts can still belong to +another tree while sources follow HEAD. That produces phantom type errors (or +stale emit consumers) that disappear after a clean rebuild — same class of +failure as [scanner#1495](https://github.com/macs-holding/scanner/pull/1495) / +[scanner#2166](https://github.com/macs-holding/scanner/pull/2166) and upstream +typescript-go incremental gaps. + +On every **branch** checkout (flag `1`), this hook deletes: + +- `apps/*/dist` **except** `apps/server/dist` (live-served SPA + `bin.mjs`; wiping + it 503s any process still serving from this checkout), `apps/*/dist-electron`, + `packages/*/dist` +- any remaining `*.tsbuildinfo` outside `node_modules` / `.git` / `.vite-plus` + +File-only checkouts (flag `0`) are left alone. + +**This is a workaround.** Remove when TypeScript/tsgo incremental invalidation +is reliable ([typescript-go#2666](https://github.com/microsoft/typescript-go/issues/2666), +[#4664](https://github.com/microsoft/typescript-go/issues/4664), +[#4262](https://github.com/microsoft/typescript-go/issues/4262)). Do not +re-enable cross-tree dist reuse without an exact source-identity key. + +### 2. Seed copy + pnpm install + +Successful reconciliation records the package/lockfile state under +`node_modules`, so T3's explicit handoff invocation does not repeat an install +which Git already completed. Explicit invocation from the target is required +for bare or stale source repositories. + +When T3 will launch a configured worktree setup script, its VCS driver sets +`T3CODE_DEFER_DEPENDENCY_INSTALL=1`. The hook still clears stale emit and copies +seed files, but skips `pnpm install` so setup can perform it asynchronously in +the thread terminal. Raw Git worktree creation does not set this marker and +continues to return with dependencies prepared. + +Lefthook may later orchestrate parallel jobs, but is intentionally unused now. diff --git a/.githooks/post-checkout b/.githooks/post-checkout new file mode 100755 index 000000000000..e4f44aee69b1 --- /dev/null +++ b/.githooks/post-checkout @@ -0,0 +1,177 @@ +#!/bin/sh +# Reconcile packages after branch checkout and prepare linked git worktrees. +# +# Canonical hook: scripts/install-git-hooks.mjs installs this into the shared +# hooks dir (core.hooksPath) on EVERY host via `pnpm install`, so a raw +# `git worktree add` sets up node_modules identically on smart and the t3vm +# guest -- not only when a worktree is created through the T3 app / t3.json. +# +# Strategy (metadata-safe): +# 1. Drop TypeScript project emit (dist / tsbuildinfo) so composite/incremental +# builds never typecheck against foreign-tree .d.ts after a branch switch. +# 2. Copy *small* gitignored seeds from .worktreeinclude (CLAUDE.md, .nuxt, …) +# via reflink/hardlink when available. NEVER clone node_modules -- that +# creates millions of inodes per worktree on btrfs. +# 3. Populate node_modules with `pnpm install --frozen-lockfile --prefer-offline` +# against the shared store (hardlinks -> one inode per package file). +# +# Idempotent: never overwrites existing seed paths; pnpm is safe to re-run. + +# Host-agnostic: pick up pnpm/mise from the invoking user's home on either host. +PATH="$HOME/.local/bin:$HOME/.local/share/pnpm:$HOME/.local/share/mise/shims:/run/current-system/sw/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:$PATH" +export PATH + +# post-checkout also runs after file-only checkouts; those do not change packages. +[ "${3:-0}" = "1" ] || exit 0 + +main_wt=$(git worktree list --porcelain | sed -n '1s/^worktree //p') +wt_root=$(git rev-parse --show-toplevel 2>/dev/null) +[ -n "$wt_root" ] || exit 0 + +# --- TS build-cache wipe (every branch / worktree checkout) ----------------- +# +# Composite/incremental emit (and leftover dist from builds) can outlive a +# branch switch. Foreign .tsbuildinfo / .d.ts produce phantom type errors that +# vanish after clean rebuild — same class as macs-holding/scanner#1495 / #2166 +# and typescript-go incremental gaps (#2666, #4664, #4262). +# Workaround until upstream invalidation is solid; see .githooks/README.md. +# +clean_ts_project_emit() { + root=$1 + removed=0 + + for d in \ + "$root"/apps/*/dist \ + "$root"/apps/*/dist-electron \ + "$root"/packages/*/dist + do + [ -e "$d" ] || continue + # Deploy clones (and any long-running `t3 serve` from this checkout) read + # apps/server/dist/client from disk per request. Wiping that tree on every + # `git switch` immediately 503s the UI with "Web assets unavailable" until + # something rebuilds it — including Discord-only deploys that never rebuild + # the server. packages/*/dist + tsbuildinfo still clear below for the + # incremental-cache workaround. + case "$d" in + */apps/server/dist) continue ;; + esac + rm -rf "$d" + removed=1 + done + + if [ -d "$root" ]; then + # Prune by basename so nested apps/*/node_modules are skipped too. + tsbuild_files=$( + find "$root" \ + \( -name node_modules -o -name .git -o -name .vite-plus \) -prune -o \ + -type f -name '*.tsbuildinfo' -print 2>/dev/null || true + ) + if [ -n "$tsbuild_files" ]; then + printf '%s\n' "$tsbuild_files" | while IFS= read -r f; do + [ -n "$f" ] || continue + rm -f "$f" + done + removed=1 + fi + fi + + if [ "$removed" = 1 ]; then + echo "post-checkout: cleared TypeScript project emit (dist / tsbuildinfo) under $root" >&2 + echo "post-checkout: workaround for tsgo/tsc stale incremental cache after tree switch — see .githooks/README.md (remove when upstream fixed)" >&2 + fi +} + +clean_ts_project_emit "$wt_root" + +if [ -n "$main_wt" ] && [ "$main_wt" != "$wt_root" ]; then + # Effective include: repo .worktreeinclude if present, else nothing to seed-copy. + include="" + if [ -f "$main_wt/.worktreeinclude" ]; then + include="$main_wt/.worktreeinclude" + fi + +# Probe once: reflink (CoW fs) > hard link (same fs) > plain copy (cross-device). +probe="$main_wt/.git-hook-clone-probe.$$" +probe_dst="$wt_root/.clone-probe.$$" +: >"$probe" +if cp --reflink=always "$probe" "$probe_dst" 2>/dev/null; then + clone() { cp -a --reflink=always "$1" "$2"; } +elif ln "$probe" "$probe_dst" 2>/dev/null; then + clone() { cp -al "$1" "$2"; } +else + clone() { cp -a "$1" "$2"; } +fi +rm -f "$probe" "$probe_dst" + +# True if path is node_modules or under one (never clone these). +is_node_modules_path() { + case "/$1/" in + */node_modules/*) return 0 ;; + *) return 1 ;; + esac +} + +if [ -n "$include" ] && [ -f "$include" ]; then + git -C "$main_wt" ls-files --others --ignored --exclude-from="$include" --directory | + while IFS= read -r rel; do + rel=${rel%/} + [ -n "$rel" ] || continue + is_node_modules_path "$rel" && continue + src="$main_wt/$rel" + dst="$wt_root/$rel" + [ -e "$dst" ] && continue + [ -e "$src" ] || continue + mkdir -p "$(dirname "$dst")" + if [ -d "$src" ]; then + clone "$src" "$dst" + else + cp "$src" "$dst" + fi + done +fi +fi + +# T3 can hand dependency installation to its asynchronous worktree setup +# terminal. Keep the metadata cleanup and seed copy above synchronous so the +# checkout is structurally ready, but let the UI become responsive before a +# potentially slow package install finishes. +if [ "${T3CODE_DEFER_DEPENDENCY_INSTALL:-0}" = "1" ]; then + echo "post-checkout: dependency installation deferred to T3 workspace initialization" >&2 + exit 0 +fi + +# Shared-store hardlink install: fast when the store is warm, no inode clone storm. +[ -f "$wt_root/package.json" ] || exit 0 +[ -f "$wt_root/pnpm-lock.yaml" ] || { + echo "post-checkout: package.json without pnpm-lock.yaml; skip install" >&2 + exit 0 +} +state_file="$wt_root/node_modules/.pnpm-checkout-state" +state=$(cksum "$wt_root/package.json" "$wt_root/pnpm-lock.yaml" | cksum | awk '{print $1 ":" $2}') +if [ -f "$wt_root/node_modules/.modules.yaml" ] && [ "$(cat "$state_file" 2>/dev/null)" = "$state" ]; then + exit 0 +fi +command -v pnpm >/dev/null 2>&1 || { + echo "post-checkout: pnpm not on PATH; node_modules not installed" >&2 + exit 0 +} + +export CI=1 +echo "post-checkout: pnpm install (hardlink from store) in $wt_root" >&2 +cd "$wt_root" || exit 1 +if pnpm install \ + --frozen-lockfile \ + --prefer-offline \ + --config.package-import-method=hardlink \ + --config.confirmModulesPurge=false +then + printf '%s\n' "$state" >"$state_file" +else + status=$? + echo "post-checkout: dependency preparation failed (exit $status); worktree remains usable but degraded" >&2 + echo "post-checkout: fix the lockfile/configuration or rerun this hook after transient failures clear" >&2 + # Native Git invokes this hook inside `git worktree add`; dependency setup + # must not turn an already-created worktree into a structural Git failure. + [ "${T3CODE_WORKTREE_PREPARATION_STRICT:-0}" = "1" ] && exit "$status" + exit 0 +fi diff --git a/.githooks/pre-commit b/.githooks/pre-commit new file mode 100755 index 000000000000..6df0de9a4976 --- /dev/null +++ b/.githooks/pre-commit @@ -0,0 +1,8 @@ +#!/bin/sh +root=$(git rev-parse --show-toplevel 2>/dev/null) || exit 1 +if [ ! -x "$root/node_modules/.bin/lint-staged" ]; then + echo "pre-commit: worktree preparation is incomplete (lint-staged is missing)" >&2 + echo "pre-commit: T3/manual checkout must finish post-checkout before commit" >&2 + exit 1 +fi +exec pnpm lint-staged diff --git a/.githooks/pre-push b/.githooks/pre-push new file mode 100755 index 000000000000..c4b0918ba376 --- /dev/null +++ b/.githooks/pre-push @@ -0,0 +1,16 @@ +# Agent-only ship gate (humans: no-op). See scripts/agent-pre-push.mjs. +# Draft / no PR: static gate (vp check + typecheck). Ready PR: + unit tests. +# Publish: pnpm pr:ready, or raw `gh pr ready` — the shim runs the same full gate first. +# +# Humans: SKIP_AGENT_PREPUSH=1 git push +# Agents: never SKIP_AGENT_PREPUSH / never --no-verify +# Nested Git commands must discover their own repositories, not inherit this +# hook's GIT_DIR/GIT_WORK_TREE from the outer push. +for name in $(git rev-parse --local-env-vars); do + unset "$name" +done +# Plain `node`, not `pnpm exec node`: pnpm runs a dependency-status check first +# and will try to purge node_modules when the lockfile moved (a rebase does it), +# which aborts without a TTY — the hook then fails with a pnpm error instead of +# anything about the gate. The gate puts node_modules/.bin on PATH itself. +node scripts/agent-pre-push.mjs diff --git a/.github/VOUCHED.td b/.github/VOUCHED.td deleted file mode 100644 index 988e223d219f..000000000000 --- a/.github/VOUCHED.td +++ /dev/null @@ -1,81 +0,0 @@ -# Trust list for this repository. -# -# External contributors listed here are treated as trusted by the vouch -# workflow. Collaborators with write access are automatically trusted and -# do not need to be duplicated in this file. -# -# Syntax: -# github:username -# -github:username reason for denouncement -# -# Keep entries sorted alphabetically. -github:0x4bs3nt -github:Adamulek123 -github:adityavardhansharma -github:aoright -github:arhxam -github:bil0000 -github:binbandit -github:Brechard -github:btsouth -github:chrisdeeming -github:chuks-qua -github:cursoragent -github:D3OXY -github:dbalders -github:eggfriedrice24 -github:extoci -github:flamboh -github:FllipEis -github:gbarros-dev -github:gfsaaser24 -github:github-actions[bot] -github:gsimone -github:GuilhermeVieiraDev -github:hwanseoc -github:inayayousfi -github:ipanasenko -github:jakeleventhal -github:jamesx0416 -github:jappyjan -github:jasonLaster -github:JoeEverest -github:justsomelegs -github:kridaydave -github:lgwacker -github:lnieuwenhuis -github:Lucenx9 -github:mackinleysmith -github:maria-rcks -github:MatthewFeroz -github:maxwellyoung -github:mwolson -github:myacoub91 -github:naMqe-h -github:nateEc -github:naveed949 -github:nmggithub -github:Noojuno -github:notkainoa -github:PatrickBauer -github:pc-style -github:PixPMusic -github:PollyGlot -github:RakshithBhat03 -github:realAhmedRoach -github:Rishet11 -github:ryanrhughes -github:saphid -github:sethwebster -github:shiroyasha9 -github:shivamhwp -github:StiensWout -github:SunkenInTime -github:tarik02 -github:tris203 -github:tsouth89 -github:UtkarshUsername -github:vitalyiegorov -github:Yash-Singh1 -github:yashranaway -github:Ymit24 diff --git a/.github/pr-stack.json b/.github/pr-stack.json new file mode 100644 index 000000000000..f9cd6edeffb8 --- /dev/null +++ b/.github/pr-stack.json @@ -0,0 +1,18 @@ +{ + "_comment": "Allowlist for .github/workflows/managed-pr-draft-lock.yml only. The stack tooling that consumed the rest was removed; upstream is merged directly into fork/dev. These three PRs stay draft so the provenance layers can never be merged into the upstream mirror by accident.", + "pullRequests": [ + { + "number": 255, + "branch": "fork/base" + }, + { + "number": 1, + "branch": "fork/tim" + }, + { + "number": 27, + "branch": "fork/candidates" + } + ], + "integrationOverlays": [] +} diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 76aac7e4d850..dbb971f3bd0e 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -19,12 +19,30 @@ we may close it without merging it, or never review it. +## Downstream Fork Relationship + + + +## External-Fork Provenance + + + ## UI Changes +## Verification + + + ## Checklist - [ ] This PR is small and focused diff --git a/.github/scripts/check-upstream-lineage.sh b/.github/scripts/check-upstream-lineage.sh new file mode 100755 index 000000000000..e2847a9692f9 --- /dev/null +++ b/.github/scripts/check-upstream-lineage.sh @@ -0,0 +1,135 @@ +#!/usr/bin/env bash +# +# check-upstream-lineage.sh — fail when a commit that carried an upstream sync +# reached the deploy branch without its second parent. +# +# Squash- and rebase-merging a sync PR keeps the code and throws the lineage +# away: the upstream commits stop being ancestors, so `fork/dev..upstream/main` +# reports work as missing that is already merged, and the next sync re-merges +# and re-resolves all of it. #401 landed that way and nobody noticed until a +# deploy alert two merges later said "Commits (2)". +# +# Ordinary fork PRs are expected to squash. Only commits that carried an +# upstream sync are checked, identified by the head branch of the PR they came +# from rather than by their subject line, because subjects vary: +# +# Merge pull request #400 from patroza/sync/upstream-2026-08-12b +# Merge upstream/main into fork/dev (23 commits) (#401) +# merge: sync upstream through b73232bdd +# +# Usage: +# check-upstream-lineage.sh # $BEFORE..$AFTER from the push event +# check-upstream-lineage.sh ... # explicit, for local checks +# +# Env: +# GH_TOKEN authenticates the PR lookup for squash/rebase commits; +# without it those fall back to the subject line +# SYNC_BRANCH_PATTERN regex of sync head branches (default: ^sync/upstream) +set -euo pipefail + +SYNC_BRANCH_PATTERN="${SYNC_BRANCH_PATTERN:-^sync/upstream}" +REPOSITORY="${GITHUB_REPOSITORY:-patroza/t3code}" + +if [[ $# -gt 0 ]]; then + revisions=("$@") +else + before="${BEFORE:-}" + after="${AFTER:-}" + if [[ -z "${after}" ]]; then + echo "no commit range: set BEFORE/AFTER or pass a range" >&2 + exit 2 + fi + # A new branch (or a force push past the old tip) reports an all-zero or + # unreachable "before"; check just the tip rather than the repository. + if [[ -z "${before}" || "${before}" =~ ^0+$ ]] || ! git cat-file -e "${before}^{commit}" 2>/dev/null; then + revisions=("${after}" "--not" "${after}^@") + else + revisions=("${before}..${after}") + fi +fi + +# The PR a commit arrived through. Squash and rebase merges leave "(#123)" in +# the subject; merge commits say "Merge pull request #123". Falling back to the +# API keeps this working when a subject was rewritten by hand. +pull_request_number() { + local subject="$1" + if [[ "${subject}" =~ Merge\ pull\ request\ \#([0-9]+) ]]; then + printf '%s' "${BASH_REMATCH[1]}" + return + fi + if [[ "${subject}" =~ \(\#([0-9]+)\)[[:space:]]*$ ]]; then + printf '%s' "${BASH_REMATCH[1]}" + return + fi + printf '' +} + +# A merge-button commit already names the branch: "Merge pull request #400 from +# patroza/sync/upstream-2026-08-12b". Squash and rebase commits do not, so those +# fall back to the API. Never gated on a token being present in the environment: +# `gh` may be authenticated by other means, and a lookup that cannot run just +# leaves the commit to the subject-line fallback. +pull_request_head_branch() { + local number="$1" subject="$2" + if [[ "${subject}" =~ Merge\ pull\ request\ \#[0-9]+\ from\ [^/]+/(.+)$ ]]; then + printf '%s' "${BASH_REMATCH[1]}" + return + fi + [[ -n "${number}" ]] || return 0 + gh api "repos/${REPOSITORY}/pulls/${number}" --jq '.head.ref' 2>/dev/null || true +} + +violations=0 +checked=0 + +while read -r sha; do + parents="$(git log -1 --format='%p' "${sha}")" + subject="$(git log -1 --format='%s' "${sha}")" + parent_count=0 + [[ -n "${parents}" ]] && parent_count="$(wc -w <<<"${parents}")" + + number="$(pull_request_number "${subject}")" + head_branch="" + head_branch="$(pull_request_head_branch "${number}" "${subject}")" + + is_sync=0 + if [[ -n "${head_branch}" && "${head_branch}" =~ ${SYNC_BRANCH_PATTERN} ]]; then + is_sync=1 + elif [[ "${subject}" =~ ^([Mm]erge\ upstream|merge:\ sync\ upstream) ]]; then + # Direct pushes and hand-written sync merges never reach the PR lookup. + is_sync=1 + fi + + [[ "${is_sync}" -eq 1 ]] || continue + checked=$((checked + 1)) + + if [[ "${parent_count}" -lt 2 ]]; then + violations=$((violations + 1)) + echo "::error::${sha} carried an upstream sync but has ${parent_count} parent(s): ${subject}" + [[ -n "${head_branch}" ]] && echo " head branch: ${head_branch} (PR #${number})" + else + echo "ok ${sha} ${subject} — ${parent_count} parents" + fi +done < <(git rev-list "${revisions[@]}") + +if [[ "${violations}" -gt 0 ]]; then + cat >&2 <<'GUIDANCE' + +An upstream sync landed without its second parent — squash- or rebase-merged. +The code is there; the lineage is not. + +Repair it without changing the tree, naming the exact upstream tip that sync +merged (not upstream/main, which would falsely claim newer commits too): + + git checkout fork/dev && git pull --ff-only + git merge -s ours -m "chore(sync): record the upstream lineage" + git diff --stat HEAD^ HEAD # must be empty + git push origin fork/dev + +Merge sync PRs with `gh pr merge --merge`. The GitHub button remembers +"Squash and merge", which is right for every other PR here and wrong for these. +GUIDANCE + exit 1 +fi + +echo "checked ${checked} sync commit(s), all keep their upstream parent" diff --git a/.github/upstream-candidates.json b/.github/upstream-candidates.json new file mode 100644 index 000000000000..5b814d0c601f --- /dev/null +++ b/.github/upstream-candidates.json @@ -0,0 +1,51 @@ +{ + "version": 1, + "candidates": [ + { + "upstreamPr": 4018, + "sourceSha": "de8fd65934768173819b93adcd6b92af3e8c7fc3", + "status": "superseded", + "purpose": "Bound server thread history and lazily page older web activity", + "supersededBy": "upstream #5493 (6b73b3def): user-anchored turn-window pagination", + "note": "Client usage removed in the 6b73b3def sync merge. The server getThreadActivities RPC is retained only for deployed mobile clients; remove it once fleet mobile builds predate it no longer." + }, + { + "upstreamPr": 3510, + "sourceSha": "034f4936d7a1435887bb62ac3f2db61f08928cbf", + "status": "partially-superseded", + "purpose": "Page mobile history and bound stale subscription catch-up", + "supersededBy": "upstream #5493 (6b73b3def): mobile paging replaced by loadEarlier turn windows", + "note": "The mobile scroll-up paging half was removed in the 6b73b3def sync merge. The server bounded-replay half in OrchestrationEngine remains active." + }, + { + "upstreamPr": 4176, + "sourceSha": "56b6615afdfe3804a466e33cbab9056b8981f217", + "status": "active", + "purpose": "Bound long-lived orchestration, browser, preview, and VCS in-memory state" + }, + { + "upstreamPr": 4506, + "sourceSha": "f7eaa00b99e67a9c1caf09e2fe6ff1f536f66b91", + "status": "active", + "purpose": "Show answered provider questions in the web thread timeline" + }, + { + "upstreamPr": 4245, + "sourceSha": "6be48eb238cf310a60cc9571240601e774c7d381", + "status": "active", + "purpose": "Queue follow-up messages server-side during active turns with explicit steer controls" + }, + { + "upstreamPr": 4379, + "sourceSha": "a27510d060645809ae1472bba4dbb248dc624e25", + "status": "active", + "purpose": "Refresh open workspace file previews when disk contents change" + }, + { + "upstreamPr": 5344, + "sourceSha": "783fd023c69f7ebc9c0ae657ce124cce77d94587", + "status": "active", + "purpose": "Batch live thread stream items so large-thread sync publishes client state once per batch" + } + ] +} diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 19a28f205d86..5e0aa335d9e0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -16,7 +16,7 @@ concurrency: jobs: check: name: Check - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Checkout @@ -75,7 +75,7 @@ jobs: # limit stays at the default 4 so peak load per runner is unchanged. test: name: Test - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Checkout @@ -115,7 +115,7 @@ jobs: # isolation that flag buys is preserved exactly. test_server: name: Test Server ${{ matrix.shard }} - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 strategy: fail-fast: false @@ -182,7 +182,7 @@ jobs: # for checks that take under 3s, on the critical path of every PR. rust: name: Rust - runs-on: blacksmith-4vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Checkout @@ -216,7 +216,7 @@ jobs: # the diff cannot be resolved, the lint runs. mobile_native_changes: name: Mobile Native Changes - runs-on: blacksmith-2vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 5 permissions: contents: read @@ -294,7 +294,7 @@ jobs: # Skip only on an explicit "no": a gate job that failed or errored leaves the # output empty, and that must run the lint rather than silently skip it. if: ${{ !cancelled() && needs.mobile_native_changes.outputs.changed != 'false' }} - runs-on: blacksmith-6vcpu-macos-26 + runs-on: macos-15 timeout-minutes: 10 steps: - name: Checkout @@ -322,7 +322,7 @@ jobs: release_smoke: name: Release Smoke - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Checkout diff --git a/.github/workflows/deploy-relay.yml b/.github/workflows/deploy-relay.yml index 25e744a42968..a79d721c9bd2 100644 --- a/.github/workflows/deploy-relay.yml +++ b/.github/workflows/deploy-relay.yml @@ -17,7 +17,8 @@ concurrency: jobs: deploy_relay: name: Deploy production relay - runs-on: blacksmith-8vcpu-ubuntu-2404 + if: github.repository == 'pingdotgg/t3code' + runs-on: ubuntu-24.04 timeout-minutes: 15 environment: name: production diff --git a/.github/workflows/fork-ci.yml b/.github/workflows/fork-ci.yml new file mode 100644 index 000000000000..53da89f21b22 --- /dev/null +++ b/.github/workflows/fork-ci.yml @@ -0,0 +1,212 @@ +name: Fork CI + +env: + # Install dependencies without downloading Electron in every job. The desktop jobs + # fetch and verify the runtime explicitly below; mobile lint and release smoke do not need it. + ELECTRON_SKIP_BINARY_DOWNLOAD: "1" + +on: + workflow_dispatch: + inputs: + # Tim/candidates provenance tips do not carry fork-ci.yml (only upstream + # Blacksmith ci.yml). Dispatch against fork/changes (or any ref that has + # this workflow) and set checkout_ref to the tip under test so checks + # attach to that SHA / permanent draft PR. + checkout_ref: + description: "Git ref or SHA to check out and test (default: dispatch ref)" + required: false + type: string + default: "" + # Full PR CI for product layers. Job names match required checks (Check / Test / + # Mobile Native Static Analysis / Release Smoke) on protected bases. + # + # Permanent stack PRs (bases): + # - #255 base → main (dispatch only; do not list main here) + # - #1 tim → fork/base + # - #27 candidates → fork/tim + # - #2 changes → fork/candidates + # + # Upstream Blacksmith CI must stay disabled_manually. fork/base supplies + # GitHub-hosted runners + fork-ci.yml for all layers above it. + # + # integrationOverlays is empty: the overlays were drained into fork/dev at + # cutover. Re-add bases here if one is ever registered again. + pull_request: + # Explicit, to add ready_for_review: a PR marked ready without a new commit + # would otherwise sit forever on required checks that can never report. + # + # "edited" is deliberately absent. It was added to cover retargeting, but it + # also fires for title and body edits, and a job-level guard that skips those + # is worse than not triggering: a skipped job still publishes a check run, + # GitHub counts a skipped required check as satisfied, and the skipped run + # supersedes the real one. Editing the title of a red PR would clear its + # failures. Retarget without a push is rarer and recoverable -- close and + # reopen fires "reopened", which is watched. + types: [opened, synchronize, reopened, ready_for_review] + branches: + - fork/base + - fork/tim + - fork/candidates + - fork/changes + # Stable contributor and release branch (docs/stable-dev-release-branch-handover.md). + - fork/dev + # fork/dev is never rebased, so its merge commits are the release candidates. + # Deployment promotes an exact green SHA and keys on a successful run of this + # workflow for that SHA, so every merge must produce one — a green PR tip is + # not enough when the merge SHA differs. + push: + branches: + - fork/dev + +concurrency: + # Push runs are keyed by SHA and never cancelled: the conclusion of a push run + # is what approves that exact commit for deployment, so cancelling one as + # superseded would leave that merge SHA permanently unapprovable. + # + # The "v2-" generation exists to escape a wedged run. A run that GitHub will + # not cancel ("Cannot cancel a workflow re-run that has not yet queued") keeps + # holding its group indefinitely, and no later run in that group can start. + # Bumping the generation puts every new run in a fresh namespace. Bump it + # again if this recurs; nothing depends on the literal value. + group: ci-v2-${{ github.event.pull_request.number || inputs.checkout_ref || + (github.event_name == 'push' && github.sha) || github.ref }} + cancel-in-progress: ${{ github.event_name != 'push' }} + +jobs: + check: + name: Check + runs-on: ubuntu-24.04 + timeout-minutes: 10 + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + ref: ${{ inputs.checkout_ref != '' && inputs.checkout_ref || github.sha }} + + - name: Setup Vite+ + uses: voidzero-dev/setup-vp@v1 + with: + node-version-file: package.json + cache: true + run-install: true + + - name: Restore Vite Task check cache + id: vite-task-check-cache + uses: actions/cache/restore@v6 + with: + path: node_modules/.vite/task-cache + key: vite-task-check-${{ runner.os }}-${{ runner.arch }}-${{ github.run_id }}-${{ github.run_attempt }} + restore-keys: | + vite-task-check-${{ runner.os }}-${{ runner.arch }}- + + - name: Ensure Electron runtime is installed + run: vp run --filter @t3tools/desktop ensure:electron + + - name: Install browser secret helper build libraries + run: sudo apt-get update && sudo apt-get install -y libsecret-1-dev pkg-config + + - name: Check + run: vp check + + - name: Typecheck + run: vp run -r --cache --log labeled typecheck + + - name: Build desktop pipeline + run: vp run --cache build:desktop + + - name: Verify preload bundle output + run: | + test -f apps/desktop/dist-electron/preload.cjs + grep -nE "desktopBridge|getLocalEnvironmentBootstrap|PICK_FOLDER_CHANNEL|wsUrl" apps/desktop/dist-electron/preload.cjs + grep -n "__clerk_internal_electron_passkeys" apps/desktop/dist-electron/preload.cjs + + - name: Save Vite Task check cache + if: success() + uses: actions/cache/save@v6 + with: + path: node_modules/.vite/task-cache + key: ${{ steps.vite-task-check-cache.outputs.cache-primary-key }} + + test: + name: Test + runs-on: ubuntu-24.04 + timeout-minutes: 10 + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + ref: ${{ inputs.checkout_ref != '' && inputs.checkout_ref || github.sha }} + + - name: Setup Vite+ + uses: voidzero-dev/setup-vp@v1 + with: + node-version-file: package.json + cache: true + run-install: true + + - name: Ensure Electron runtime is installed + run: vp run --filter @t3tools/desktop ensure:electron + + - name: Install browser secret helper build libraries + run: sudo apt-get update && sudo apt-get install -y libsecret-1-dev pkg-config + + - name: Test + run: vp run test + + mobile_native_static_analysis: + name: Mobile Native Static Analysis + runs-on: macos-15 + timeout-minutes: 10 + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + ref: ${{ inputs.checkout_ref != '' && inputs.checkout_ref || github.sha }} + + - name: Setup Vite+ + uses: voidzero-dev/setup-vp@v1 + with: + node-version-file: package.json + # Saving the complete macOS node_modules cache takes ~95 seconds and + # loses the cache reservation whenever parallel PR runs overlap. + # A clean install is faster and has deterministic completion time. + cache: false + run-install: true + + - name: Ensure Electron runtime is installed + run: vp run --filter @t3tools/desktop ensure:electron + + - name: Test macOS Open With integration + # Present from Tim onward; fork/base is CI plumbing only and lacks this path. + run: | + if [[ -f apps/desktop/src/shell/DesktopOpenWith.test.ts ]]; then + vp test run apps/desktop/src/shell/DesktopOpenWith.test.ts + else + echo "DesktopOpenWith tests not on this tip; skipping." + fi + + - name: Install mobile native static analysis tools + run: brew bundle install --file apps/mobile/Brewfile + + - name: Lint mobile native sources + run: vp run lint:mobile + + release_smoke: + name: Release Smoke + runs-on: ubuntu-24.04 + timeout-minutes: 10 + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + ref: ${{ inputs.checkout_ref != '' && inputs.checkout_ref || github.sha }} + + - name: Setup Vite+ + uses: voidzero-dev/setup-vp@v1 + with: + node-version-file: package.json + cache: true + run-install: true + + - name: Exercise release-only workflow steps + run: node scripts/release-smoke.ts diff --git a/.github/workflows/fork-release.yml b/.github/workflows/fork-release.yml new file mode 100644 index 000000000000..b05c584ed460 --- /dev/null +++ b/.github/workflows/fork-release.yml @@ -0,0 +1,238 @@ +name: Fork Release + +# Release actions, split out of Fork CI on purpose. +# +# Fork CI answers exactly one question: "is this SHA valid?" Its conclusion is +# what the deploy poller on the smart host promotes on, so a release action must +# never be able to turn it red — a failed EAS dispatch would otherwise strand +# server, Discord, desktop and VS Code deployment of a perfectly good commit. +# +# workflow_run gives the ordering for free: this only starts after Fork CI has +# already concluded success for a push to fork/dev, so nothing is released from a +# SHA that is not green, and a failure here is recorded against this run alone. +# +# NOTE: workflow_run only fires for workflow files present on the repository +# default branch. Until fork/dev is the default branch this workflow will not +# trigger, and mobile releases must be dispatched manually below. +on: + workflow_run: + workflows: ["Fork CI"] + types: [completed] + workflow_dispatch: + inputs: + sha: + description: "Exact green fork/dev SHA to release" + required: true + type: string + release_branch: + description: "Branch that must contain the SHA" + required: false + type: string + default: fork/dev + +concurrency: + # Per branch, superseding: back-to-back merges should release once, for the + # tip, not once per commit. Coalescing here rather than in Fork CI keeps every + # commit individually validated, so a red build still names the commit that + # broke it. + # + # Cancelling can only ever over-scope a later release, never under-scope it: a + # cancelled run is not "successful", so the next release still measures from + # the last SHA that genuinely released. Releasing a superset is wasteful; + # missing a change is not recoverable. + group: fork-release-${{ github.event.workflow_run.head_branch || inputs.release_branch }} + cancel-in-progress: true + +jobs: + release: + name: Release + # Only a green push run on fork/dev. Pull-request and workflow_dispatch runs + # of Fork CI validate a tip that was never merged and must not release. + if: >- + github.event_name == 'workflow_dispatch' || + (github.event.workflow_run.conclusion == 'success' && + github.event.workflow_run.event == 'push' && + github.event.workflow_run.head_branch == 'fork/dev') + runs-on: ubuntu-24.04 + timeout-minutes: 10 + permissions: + actions: write + contents: read + env: + RELEASE_SHA: ${{ github.event.workflow_run.head_sha || inputs.sha }} + RELEASE_REF: ${{ github.event.workflow_run.head_branch || inputs.release_branch }} + steps: + - name: Checkout release source + uses: actions/checkout@v6 + with: + ref: ${{ github.event.workflow_run.head_sha || inputs.sha }} + fetch-depth: 0 + + - name: Cancel if superseded + # workflow_run ordering is not guaranteed, so an older release can still + # start after a newer one. Self-cancel rather than exit 0: a run that + # concludes success without dispatching would be picked up as the + # "previous released SHA" and silently shrink the next release's scope. + env: + GH_TOKEN: ${{ github.token }} + run: | + git fetch --quiet origin "${RELEASE_REF}" + tip="$(git rev-parse FETCH_HEAD)" + if [[ "${tip}" != "${RELEASE_SHA}" ]]; then + echo "Superseded: ${RELEASE_REF} is now at ${tip}, this run is for ${RELEASE_SHA}." + gh run cancel "${GITHUB_RUN_ID}" + # Cancellation is asynchronous. Block so nothing dispatches while it + # lands, and fail if it never does -- either conclusion keeps this + # run out of the successful-release history. + sleep 60 + exit 1 + fi + echo "${RELEASE_SHA} is the current ${RELEASE_REF} tip." + + - name: Confirm the SHA is green + # workflow_dispatch bypasses the workflow_run gate, so re-check it here. + # Releasing an unvalidated SHA by hand is the one thing this split must + # not make easier. + env: + GH_TOKEN: ${{ github.token }} + run: | + green="$( + gh api --method GET \ + "repos/${GITHUB_REPOSITORY}/actions/workflows/fork-ci.yml/runs" \ + -f branch="${RELEASE_REF}" -f event=push -f status=success -f per_page=30 \ + --jq "[.workflow_runs[] | select(.head_sha == \"${RELEASE_SHA}\")] | length" + )" + if [[ "${green}" -lt 1 ]]; then + echo "error: no successful Fork CI push run for ${RELEASE_SHA} on ${RELEASE_REF}" >&2 + exit 1 + fi + echo "Fork CI is green for ${RELEASE_SHA}." + + - id: previous + name: Find previous released SHA + env: + GH_TOKEN: ${{ github.token }} + run: | + # Compare against the last SHA this workflow released, not the last one + # that merely passed CI: a commit whose release was skipped must still + # be represented in the next release's scope. + previous_sha="$( + gh api --method GET \ + "repos/${GITHUB_REPOSITORY}/actions/workflows/fork-release.yml/runs" \ + -f branch="${RELEASE_REF}" -f status=success -f per_page=30 \ + --jq "[.workflow_runs[] | select(.head_sha != \"${RELEASE_SHA}\")] | first | .head_sha // \"\"" + )" + echo "sha=${previous_sha}" >>"${GITHUB_OUTPUT}" + + - id: classify + name: Classify release scope + env: + PREVIOUS_SHA: ${{ steps.previous.outputs.sha }} + run: | + # Same script the smart-host poller runs, so this report and the fleet + # promotion cannot disagree about what a diff means. + deploy=true server=true discord=true vscode=true mobile=true desktop=true + web_hot_swap=false + basis="no previous released SHA; assuming every target changed" + if [[ "${PREVIOUS_SHA}" =~ ^[0-9a-f]{40}$ ]]; then + if ! git cat-file -e "${PREVIOUS_SHA}^{commit}" 2>/dev/null; then + git fetch --quiet origin "${PREVIOUS_SHA}" || true + fi + if git cat-file -e "${PREVIOUS_SHA}^{commit}" 2>/dev/null; then + classification="$( + scripts/classify-deployment-diff.sh "${PREVIOUS_SHA}" "${RELEASE_SHA}" + )" + printf '%s\n' "${classification}" >&2 + for key in deploy server discord vscode mobile desktop web_hot_swap; do + value="$(sed -n "s/^${key}=//p" <<<"${classification}")" + [[ "${value}" =~ ^(true|false)$ ]] || continue + printf -v "${key}" '%s' "${value}" + done + basis="classified against the previous released SHA" + else + basis="previous released SHA unavailable; assuming every target changed" + fi + fi + # A non-runtime-only range promotes nothing, exactly as the poller + # decides, so report every target as held rather than as released. + if [[ "${deploy}" == "false" ]]; then + server=false; discord=false; vscode=false; desktop=false; mobile=false + fi + for key in deploy server discord vscode mobile desktop web_hot_swap; do + echo "${key}=${!key}" >>"${GITHUB_OUTPUT}" + done + echo "basis=${basis}" >>"${GITHUB_OUTPUT}" + { + echo "changed_files</dev/null; then + git diff --name-only "${PREVIOUS_SHA}" "${RELEASE_SHA}" | head -40 + fi + echo "EOF" + } >>"${GITHUB_OUTPUT}" + + - name: Dispatch mobile releases + if: steps.classify.outputs.mobile == 'true' + env: + GH_TOKEN: ${{ github.token }} + run: | + # mode=auto, not update: an OTA alone never reaches a phone when the + # native runtime changed, so the fingerprint decides between an update + # and a TestFlight build. iOS only, because Android has no keystore. + gh workflow run mobile-eas-production.yml \ + --repo "$GITHUB_REPOSITORY" \ + --ref "$RELEASE_REF" \ + -f mode=auto \ + -f platform=ios \ + -f sha="$RELEASE_SHA" \ + -f release_branch="$RELEASE_REF" \ + -f message="${RELEASE_REF} ${RELEASE_SHA}" + gh workflow run mobile-eas-development.yml \ + --repo "$GITHUB_REPOSITORY" \ + --ref "$RELEASE_REF" \ + -f platform=ios \ + -f sha="$RELEASE_SHA" \ + -f release_branch="$RELEASE_REF" + + - name: Report + if: always() + env: + PREVIOUS_SHA: ${{ steps.previous.outputs.sha }} + BASIS: ${{ steps.classify.outputs.basis }} + DEPLOY: ${{ steps.classify.outputs.deploy }} + SERVER: ${{ steps.classify.outputs.server }} + DISCORD: ${{ steps.classify.outputs.discord }} + VSCODE: ${{ steps.classify.outputs.vscode }} + MOBILE: ${{ steps.classify.outputs.mobile }} + DESKTOP: ${{ steps.classify.outputs.desktop }} + WEB_HOT_SWAP: ${{ steps.classify.outputs.web_hot_swap }} + CHANGED_FILES: ${{ steps.classify.outputs.changed_files }} + run: | + mark() { [[ "$1" == "true" ]] && echo "**yes**" || echo "no"; } + server_note="restart" + [[ "${WEB_HOT_SWAP}" == "true" ]] && server_note="web hot-swap, no restart" + { + printf '### Fork Release — `%s`\n\n' "${RELEASE_SHA:0:12}" + printf 'Range: `%s` → `%s` on `%s`\n\n' \ + "${PREVIOUS_SHA:0:12}" "${RELEASE_SHA:0:12}" "${RELEASE_REF}" + printf '_%s._\n\n' "${BASIS}" + if [[ "${DEPLOY}" == "false" ]]; then + printf '> Non-runtime-only range: the poller records it as evaluated and promotes nothing.\n\n' + fi + printf '| Target | Selected | Promoted by |\n' + printf '| --- | --- | --- |\n' + printf '| Server (%s) | %s | smart-host poller |\n' "${server_note}" "$(mark "${SERVER}")" + printf '| Discord bot | %s | smart-host poller |\n' "$(mark "${DISCORD}")" + printf '| Desktop | %s | smart-host poller |\n' "$(mark "${DESKTOP}")" + printf '| VS Code | %s | smart-host poller |\n' "$(mark "${VSCODE}")" + printf '| Mobile (EAS) | %s | this workflow |\n\n' "$(mark "${MOBILE}")" + printf 'Classified by `scripts/classify-deployment-diff.sh`, the same script the poller\n' + printf 'runs, so this report and the fleet cannot disagree about what a diff means.\n\n' + printf '**Caveat:** the poller diffs against the last SHA it actually *deployed*, which is\n' + printf 'not always the last released SHA — a promotion it skipped or that failed part-way\n' + printf 'leaves its baseline behind this one. When they diverge the poller selects a\n' + printf 'superset of the rows above, never a subset.\n' + if [[ -n "${CHANGED_FILES}" ]]; then + printf '\n
Changed files\n\n```text\n%s\n```\n\n
\n' \ + "${CHANGED_FILES}" + fi + } >>"${GITHUB_STEP_SUMMARY}" diff --git a/.github/workflows/managed-pr-draft-lock.yml b/.github/workflows/managed-pr-draft-lock.yml new file mode 100644 index 000000000000..1eba3d9421b9 --- /dev/null +++ b/.github/workflows/managed-pr-draft-lock.yml @@ -0,0 +1,43 @@ +name: Managed PR draft lock + +on: + pull_request_target: + types: [opened, reopened, ready_for_review, synchronize] + # Only the bases the managed provenance PRs target. Ordinary work targets + # fork/dev, so this no longer starts a run -- and shows a check -- on every + # unrelated PR just to look itself up in an allowlist and exit. + # + # Not folded into Fork CI: that workflow deliberately does not watch main, + # and #255 targets main. Merging it would push fork CI plumbing into the + # upstream mirror, which is the single worst outcome this guard prevents. + branches: [main, fork/base, fork/tim] + +permissions: + contents: read + pull-requests: write + +jobs: + keep-draft: + name: Keep managed PR draft + runs-on: ubuntu-24.04 + steps: + - name: Restore draft state without changing CI status + env: + GH_TOKEN: ${{ github.token }} + REPOSITORY: ${{ github.repository }} + PR_NUMBER: ${{ github.event.pull_request.number }} + IS_DRAFT: ${{ github.event.pull_request.draft }} + run: | + manifest="$( + gh api \ + -H 'Accept: application/vnd.github.raw+json' \ + "repos/${REPOSITORY}/contents/.github/pr-stack.json?ref=fork/dev" + )" + if ! jq -e --argjson number "${PR_NUMBER}" \ + '([.pullRequests[], .integrationOverlays[]] | any(.number == $number))' \ + <<<"${manifest}" >/dev/null; then + exit 0 + fi + if [[ "${IS_DRAFT}" != "true" ]]; then + gh pr ready "${PR_NUMBER}" --undo --repo "${REPOSITORY}" + fi diff --git a/.github/workflows/mobile-eas-development.yml b/.github/workflows/mobile-eas-development.yml new file mode 100644 index 000000000000..c9028599aeab --- /dev/null +++ b/.github/workflows/mobile-eas-development.yml @@ -0,0 +1,155 @@ +name: Mobile EAS Development + +# Keep the installable development client current without rebuilding it for +# JavaScript-only changes. Expo Fingerprint reuses a compatible native build +# and publishes an OTA update; native changes produce a new internal build. +# Free-plan build failures fall back to OTA against the latest finished binary. +on: + workflow_dispatch: + inputs: + platform: + description: "Target platform" + required: true + type: choice + default: ios + options: + - ios + - android + - all + runtime_version: + description: "Force OTA runtimeVersion (blank = fingerprint / fallback)" + required: false + type: string + sha: + description: "Exact release-branch SHA (blank uses that branch's current tip)" + required: false + type: string + release_branch: + description: "Release branch that must contain the SHA" + required: false + type: string + default: fork/integration + +concurrency: + group: mobile-eas-development + cancel-in-progress: false + +jobs: + development: + name: EAS Development + runs-on: ubuntu-24.04 + permissions: + contents: read + env: + APP_VARIANT: development + NODE_OPTIONS: --max-old-space-size=8192 + MOBILE_VERSION_POLICY: fingerprint + T3CODE_MOBILE_EAS_PROJECT_ID: ${{ vars.T3CODE_MOBILE_EAS_PROJECT_ID }} + T3CODE_MOBILE_EXPO_OWNER: ${{ vars.T3CODE_MOBILE_EXPO_OWNER }} + T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER: ${{ vars.T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER }} + T3CODE_MOBILE_IOS_TEAM_ID: ${{ vars.T3CODE_MOBILE_IOS_TEAM_ID }} + steps: + - id: expo-token + name: Check for EXPO_TOKEN + env: + EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} + run: | + if [ -n "$EXPO_TOKEN" ]; then + echo "present=true" >> "$GITHUB_OUTPUT" + else + echo "present=false" >> "$GITHUB_OUTPUT" + echo "EXPO_TOKEN is not available; skipping EAS development job." + fi + + - name: Checkout + if: steps.expo-token.outputs.present == 'true' + uses: actions/checkout@v6 + with: + ref: ${{ inputs.release_branch }} + fetch-depth: 0 + + - name: Resolve approved integration source + if: steps.expo-token.outputs.present == 'true' + env: + REQUESTED_SHA: ${{ inputs.sha }} + run: | + integration_sha="$(git rev-parse HEAD)" + target_sha="${REQUESTED_SHA:-$integration_sha}" + if [[ ! "$target_sha" =~ ^[0-9a-f]{40}$ ]]; then + echo "sha must be an exact 40-character commit SHA" >&2 + exit 1 + fi + git fetch origin "$target_sha" + git merge-base --is-ancestor "$target_sha" "$integration_sha" + git checkout --detach "$target_sha" + test "$(git rev-parse HEAD)" = "$target_sha" + echo "sha=$target_sha" >> "$GITHUB_OUTPUT" + + - name: Overlay deploy tooling from workflow ref + if: steps.expo-token.outputs.present == 'true' && github.ref_name != inputs.release_branch + env: + WORKFLOW_SHA: ${{ github.sha }} + run: | + git fetch origin "$WORKFLOW_SHA" + for path in \ + apps/mobile/scripts/eas-continuous-deploy.sh \ + apps/mobile/scripts/lib \ + apps/mobile/app.config.ts \ + .easignore; do + if git cat-file -e "${WORKFLOW_SHA}:${path}" 2>/dev/null; then + git checkout "$WORKFLOW_SHA" -- "$path" + echo "overlaid $path from $WORKFLOW_SHA" + fi + done + chmod +x apps/mobile/scripts/eas-continuous-deploy.sh + + - name: Setup Vite+ + if: steps.expo-token.outputs.present == 'true' + uses: voidzero-dev/setup-vp@v1 + with: + node-version-file: package.json + cache: true + run-install: true + + - name: Expose pnpm + if: steps.expo-token.outputs.present == 'true' + run: | + pnpm_version="$(node --print "require('./package.json').packageManager.split('@').pop()")" + vp_pnpm_bin="$HOME/.vite-plus/package_manager/pnpm/$pnpm_version/pnpm/bin" + echo "$vp_pnpm_bin" >> "$GITHUB_PATH" + "$vp_pnpm_bin/pnpm" --version + + - name: Setup EAS + if: steps.expo-token.outputs.present == 'true' + uses: expo/expo-github-action@v8 + with: + eas-version: latest + token: ${{ secrets.EXPO_TOKEN }} + packager: npm + + - name: Pull development environment variables + if: steps.expo-token.outputs.present == 'true' + working-directory: apps/mobile + env: + EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} + run: eas env:pull development --non-interactive + + - name: Publish compatible update or development build + if: steps.expo-token.outputs.present == 'true' + working-directory: apps/mobile + env: + EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} + GITHUB_SHA: ${{ github.sha }} + run: | + chmod +x scripts/eas-continuous-deploy.sh + args=( + --profile development + --channel development + --environment development + --platform "${{ inputs.platform }}" + --message "Development auto (${{ github.sha }})" + ) + if [ -n "${{ inputs.runtime_version }}" ]; then + args+=(--runtime-version "${{ inputs.runtime_version }}") + fi + ./scripts/eas-continuous-deploy.sh "${args[@]}" diff --git a/.github/workflows/mobile-eas-preview.yml b/.github/workflows/mobile-eas-preview.yml index d53602f8f5e8..0e6afb6c3e42 100644 --- a/.github/workflows/mobile-eas-preview.yml +++ b/.github/workflows/mobile-eas-preview.yml @@ -2,18 +2,17 @@ name: Mobile EAS Preview on: pull_request: - types: [opened, reopened, synchronize, labeled] + # Preview builds belong to feature PRs. The permanent fork stack PRs target + # lower provenance layers and must not create a preview run on every rebase. + branches: + - fork/changes + types: [opened, reopened, synchronize, labeled, unlabeled] jobs: preview: name: EAS Preview - if: | - contains(github.event.pull_request.labels.*.name, '🚀 Mobile Continuous Deployment') && - (github.event.action != 'labeled' || github.event.label.name == '🚀 Mobile Continuous Deployment') - runs-on: blacksmith-8vcpu-ubuntu-2404 - concurrency: - group: mobile-eas-preview-${{ github.event.pull_request.number }} - cancel-in-progress: true + if: contains(github.event.pull_request.labels.*.name, '🚀 Mobile Continuous Deployment') + runs-on: ubuntu-24.04 permissions: contents: read pull-requests: write @@ -39,10 +38,6 @@ jobs: uses: actions/checkout@v6 with: fetch-depth: 0 - # No sparse-checkout here: it makes actions/checkout fetch with - # --filter=blob:none, and eas-cli archives the project via - # `git clone --depth 1 file://`, which fails (exit 128) - # when the partial clone can't serve the unfetched blobs. - name: Setup Vite+ if: steps.expo-token.outputs.present == 'true' @@ -50,9 +45,7 @@ jobs: with: node-version-file: package.json cache: true - run-install: | - args: - - --filter=@t3tools/mobile... + run-install: true - name: Expose pnpm if: steps.expo-token.outputs.present == 'true' @@ -86,9 +79,14 @@ jobs: env: EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} with: - profile: preview:dev + # Release configuration, not `preview:dev`: PR builds must show + # production-grade performance and memory behaviour. The dev-client + # `preview:dev` profile stays available for local Metro attachment. + profile: preview branch: pr-${{ github.event.pull_request.number }} - platform: all + # iOS only: Android has no signing keystore configured, so including + # it fails the job before the iOS artifact is published. + platform: ios environment: preview working-directory: apps/mobile github-token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/mobile-eas-production.yml b/.github/workflows/mobile-eas-production.yml index 4ad9f4f7672b..cd19b5bcf25b 100644 --- a/.github/workflows/mobile-eas-production.yml +++ b/.github/workflows/mobile-eas-production.yml @@ -6,33 +6,20 @@ name: Mobile EAS Production # fingerprint (platform-specific deps + pnpm version) and errors. On this Linux # runner, with corepack pinning pnpm 10.24 in eas.json, local == build. # -# Every merge to main that touches the mobile app reconciles, per platform: -# 1. Store builds: if the latest production build's version differs from -# app.config.ts, cut a new build and submit it (TestFlight + Play internal -# track). Bumping `version` is therefore all it takes to -# start the next release train — the first build of a version enters -# external-TestFlight beta review immediately, and later builds of the -# same version auto-approve until that version is released. After App -# Store approval, Apple closes the release train and `version` must be -# bumped before another iOS build can be submitted. Releasing to the App -# Store stays a manual App Store Connect step. -# 2. OTA: publish a production-channel update for each platform where at -# least one finished production build matches the current native -# fingerprint. Old-version binaries with a matching fingerprint receive -# it too. When native drift means no binary could install the update, -# it is skipped and flagged in the job summary instead of published -# into the void. -# workflow_dispatch remains as a manual override for both modes (e.g. to -# retry an errored build or force an OTA). +# mode=auto uses apps/mobile/scripts/eas-continuous-deploy.sh (full logs). When a +# native rebuild is needed but blocked (e.g. Expo Free plan monthly iOS quota), +# it falls back to OTA against the latest finished production binary runtime so +# pure-JS fixes still reach installed TestFlight clients. on: workflow_dispatch: inputs: mode: - description: "build (+ auto-submit to TestFlight) or update (OTA)" + description: "auto (fingerprint decides), build (+ auto-submit to TestFlight), or update (OTA)" required: true type: choice - default: build + default: auto options: + - auto - build - update platform: @@ -49,39 +36,40 @@ on: required: false type: string message: - description: "OTA update message (mode=update only)" + description: "OTA update message (mode=update / auto)" required: false type: string - push: - branches: [main] - paths: - - apps/mobile/** - - packages/client-runtime/** - - packages/contracts/** - - packages/shared/** - - assets/** - - scripts/** - - patches/** - - pnpm-lock.yaml - - pnpm-workspace.yaml - - .github/workflows/mobile-eas-production.yml + runtime_version: + description: "Force OTA runtimeVersion (mode=update or auto). Blank = fingerprint / fallback" + required: false + type: string + sha: + description: "Exact release-branch SHA (blank uses that branch's current tip)" + required: false + type: string + release_branch: + description: "Release branch that must contain the SHA" + required: false + type: string + default: fork/integration -# Serialize runs so OTAs publish in merge order. GitHub keeps at most one -# queued run per group, so a burst of merges collapses into one run of the -# newest commit — intermediate commits don't need their own OTA. concurrency: group: mobile-eas-production cancel-in-progress: false jobs: production: - name: EAS Production ${{ github.event_name == 'push' && 'auto' || inputs.mode }} - runs-on: blacksmith-8vcpu-ubuntu-2404 + name: EAS Production ${{ inputs.mode }} + runs-on: ubuntu-24.04 permissions: contents: read env: APP_VARIANT: production NODE_OPTIONS: --max-old-space-size=8192 + T3CODE_MOBILE_EAS_PROJECT_ID: ${{ vars.T3CODE_MOBILE_EAS_PROJECT_ID }} + T3CODE_MOBILE_EXPO_OWNER: ${{ vars.T3CODE_MOBILE_EXPO_OWNER }} + T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER: ${{ vars.T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER }} + T3CODE_MOBILE_IOS_TEAM_ID: ${{ vars.T3CODE_MOBILE_IOS_TEAM_ID }} steps: - id: expo-token name: Check for EXPO_TOKEN @@ -108,6 +96,7 @@ jobs: if: steps.expo-token.outputs.present == 'true' uses: actions/checkout@v6 with: + ref: ${{ inputs.release_branch }} fetch-depth: 0 token: ${{ steps.version_app_token.outputs.token || github.token }} # No sparse-checkout here: it makes actions/checkout fetch with @@ -115,6 +104,46 @@ jobs: # `git clone --depth 1 file://`, which fails (exit 128) # when the partial clone can't serve the unfetched blobs. + - id: source + name: Resolve approved integration source + if: steps.expo-token.outputs.present == 'true' + env: + REQUESTED_SHA: ${{ inputs.sha }} + run: | + integration_sha="$(git rev-parse HEAD)" + target_sha="${REQUESTED_SHA:-$integration_sha}" + if [[ ! "$target_sha" =~ ^[0-9a-f]{40}$ ]]; then + echo "sha must be an exact 40-character commit SHA" >&2 + exit 1 + fi + git fetch origin "$target_sha" + git merge-base --is-ancestor "$target_sha" "$integration_sha" + git checkout --detach "$target_sha" + test "$(git rev-parse HEAD)" = "$target_sha" + echo "sha=$target_sha" >> "$GITHUB_OUTPUT" + + # Workflow file may come from a feature branch (workflow_dispatch --ref) + # while product code is always the approved integration SHA above. Overlay + # the deploy script + app.config runtime override from the workflow ref so + # we can ship fixes without waiting for a full compose. + - name: Overlay deploy tooling from workflow ref + if: steps.expo-token.outputs.present == 'true' && github.ref_name != inputs.release_branch + env: + WORKFLOW_SHA: ${{ github.sha }} + run: | + git fetch origin "$WORKFLOW_SHA" + for path in \ + apps/mobile/scripts/eas-continuous-deploy.sh \ + apps/mobile/scripts/lib \ + apps/mobile/app.config.ts \ + .easignore; do + if git cat-file -e "${WORKFLOW_SHA}:${path}" 2>/dev/null; then + git checkout "$WORKFLOW_SHA" -- "$path" + echo "overlaid $path from $WORKFLOW_SHA" + fi + done + chmod +x apps/mobile/scripts/eas-continuous-deploy.sh + - name: Setup Vite+ if: steps.expo-token.outputs.present == 'true' uses: voidzero-dev/setup-vp@v1 @@ -151,140 +180,70 @@ jobs: EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} run: eas env:pull production --non-interactive - - name: Apply manual version override - if: steps.version_app_token.outcome == 'success' - env: - GH_TOKEN: ${{ steps.version_app_token.outputs.token }} - APP_SLUG: ${{ steps.version_app_token.outputs.app-slug }} - RELEASE_VERSION: ${{ inputs.version }} - run: | - if [ "$GITHUB_REF_TYPE" != "branch" ]; then - echo "Version overrides require dispatching this workflow from a branch; received $GITHUB_REF_TYPE '$GITHUB_REF_NAME'." >&2 - exit 1 - fi - if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+){1,2}$ ]]; then - echo "Version override must contain two or three dot-separated integers; received '$RELEASE_VERSION'." >&2 - exit 1 - fi - - node --input-type=module -e ' - import fs from "node:fs"; - const path = "apps/mobile/app.config.ts"; - const source = fs.readFileSync(path, "utf8"); - const next = source.replace( - /^( version: ")[^"]+(".*)$/m, - `$1${process.env.RELEASE_VERSION}$2`, - ); - if (next === source && !source.includes(` version: "${process.env.RELEASE_VERSION}"`)) { - throw new Error("Could not update app version"); - } - fs.writeFileSync(path, next); - ' - vp fmt apps/mobile/app.config.ts - - if git diff --quiet -- apps/mobile/app.config.ts; then - echo "app.config.ts is already at $RELEASE_VERSION; no version commit needed." - exit 0 - fi - - user_id="$(gh api "/users/${APP_SLUG}[bot]" --jq .id)" - git config user.name "${APP_SLUG}[bot]" - git config user.email "${user_id}+${APP_SLUG}[bot]@users.noreply.github.com" - git add apps/mobile/app.config.ts - git commit \ - -m "chore(mobile): bump app version to $RELEASE_VERSION" \ - -m "Co-authored-by: codex " - git push origin "HEAD:refs/heads/${GITHUB_REF_NAME}" - - - name: Summarize manual build version - if: steps.expo-token.outputs.present == 'true' && github.event_name == 'workflow_dispatch' && inputs.mode == 'build' - working-directory: apps/mobile - run: | - version="$(npx expo config --json --type public | jq -r '.version')" - { - echo "## Manual production build" - echo - echo "- App version: \`$version\`" - echo "- Platform: \`${{ inputs.platform }}\`" - echo - echo "> Apple closes an iOS release train after App Store approval. Before building iOS, confirm \`$version\` is newer than the approved App Store version." - } >> "$GITHUB_STEP_SUMMARY" - - - name: Build and submit (manual) - if: steps.expo-token.outputs.present == 'true' && github.event_name == 'workflow_dispatch' && inputs.mode == 'build' - working-directory: apps/mobile - env: - EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} - run: eas build --platform ${{ inputs.platform }} --profile production --auto-submit --non-interactive --no-wait - - - name: Publish OTA update (manual) - if: steps.expo-token.outputs.present == 'true' && github.event_name == 'workflow_dispatch' && inputs.mode == 'update' + - name: Deploy with fingerprint check (auto) + if: steps.expo-token.outputs.present == 'true' && inputs.mode == 'auto' working-directory: apps/mobile env: EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} + GITHUB_SHA: ${{ steps.source.outputs.sha }} run: | - eas update \ - --channel production \ - --environment production \ - --platform ${{ inputs.platform }} \ - --message "${{ inputs.message || format('Production OTA ({0})', github.sha) }}" \ - --non-interactive + chmod +x scripts/eas-continuous-deploy.sh + args=( + --profile production + --channel production + --environment production + --platform "${{ inputs.platform }}" + --auto-submit + --message "${{ inputs.message || format('Production auto ({0})', steps.source.outputs.sha) }}" + ) + if [ -n "${{ inputs.runtime_version }}" ]; then + args+=(--runtime-version "${{ inputs.runtime_version }}") + fi + ./scripts/eas-continuous-deploy.sh "${args[@]}" - # No --status filter on build:list: an in-queue/in-progress build must - # count as existing, or every merge during the build window would cut a - # duplicate. After an errored build, retry via workflow_dispatch - # mode=build — pushes won't re-trigger it until the app version changes. - - id: store_builds - name: Ensure store builds exist for the current app version - if: steps.expo-token.outputs.present == 'true' && github.event_name == 'push' - continue-on-error: true + - name: Build and submit + if: steps.expo-token.outputs.present == 'true' && inputs.mode == 'build' working-directory: apps/mobile env: EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} run: | - failed=0 - version="$(npx expo config --json --type public | jq -r '.version')" - for platform in ios android; do - latest="$(eas build:list --platform "$platform" --build-profile production --limit 1 --json --non-interactive | jq -r '.[0].appVersion // "none"')" - if [ "$latest" = "$version" ]; then - echo "$platform: production build for $version already exists (or is in progress)" - continue - fi - echo "$platform: latest production build is $latest, app.config.ts says $version — building" - if eas build --platform "$platform" --profile production --auto-submit --non-interactive --no-wait; then - echo ":building_construction: $platform: scheduled production build and submission for $version" >> "$GITHUB_STEP_SUMMARY" - else - failed=1 - echo ":x: $platform: production build or submission failed for $version" >> "$GITHUB_STEP_SUMMARY" - fi - done - exit "$failed" + set -o pipefail + eas build --platform ${{ inputs.platform }} --profile production --auto-submit --non-interactive --no-wait 2>&1 | tee /tmp/eas-build.log + if grep -q 'used its iOS builds from the Free plan' /tmp/eas-build.log; then + echo "::error::Expo Free plan iOS build quota exhausted. Upgrade at https://expo.dev/accounts/patroza/settings/billing or wait for the monthly reset, then re-run mode=build. Pure-JS fixes can still ship via mode=auto (fallback OTA) or mode=update with runtime_version." + fi - - name: Publish fingerprint-gated OTA - if: steps.expo-token.outputs.present == 'true' && github.event_name == 'push' + - name: Publish OTA update (manual) + if: steps.expo-token.outputs.present == 'true' && github.event_name == 'workflow_dispatch' && inputs.mode == 'update' working-directory: apps/mobile env: EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }} + GITHUB_SHA: ${{ steps.source.outputs.sha }} + RUNTIME_VERSION: ${{ inputs.runtime_version }} run: | - message="$(git log -1 --pretty=%s | head -c 120) ($(git rev-parse --short=9 HEAD))" - for platform in ios android; do - # eas-cli prints an environment-loaded notice to stdout before the - # JSON even with --json, so discard everything before the document. - hash="$(eas fingerprint:generate --platform "$platform" --environment production --json --non-interactive | sed -n '/^{/,$p' | jq -er '.hash | select(type == "string" and length > 0)')" - matching="$(eas build:list --platform "$platform" --build-profile production --status finished --fingerprint-hash "$hash" --limit 1 --json --non-interactive | jq 'length')" - if [ "$matching" -gt 0 ]; then - eas update \ - --channel production \ - --environment production \ - --platform "$platform" \ - --message "$message" \ - --non-interactive - echo ":white_check_mark: $platform: OTA published to production (fingerprint \`$hash\`)" >> "$GITHUB_STEP_SUMMARY" - else - echo ":warning: $platform: no finished production build matches fingerprint \`$hash\` — OTA skipped; JS changes reach $platform only once a matching build ships" >> "$GITHUB_STEP_SUMMARY" - fi - done - - - name: Propagate store build failure - if: steps.store_builds.outcome == 'failure' - run: exit 1 + chmod +x scripts/eas-continuous-deploy.sh + args=( + --profile production + --channel production + --environment production + --platform "${{ inputs.platform }}" + --message "${{ inputs.message || format('Production OTA ({0})', steps.source.outputs.sha) }}" + ) + if [ -n "$RUNTIME_VERSION" ]; then + args+=(--runtime-version "$RUNTIME_VERSION") + else + # mode=update without runtime: publish under fingerprint policy only + # (no native rebuild attempt). Use --runtime-version to target an + # installed binary when fingerprints drifted. + : + fi + if [ -n "$RUNTIME_VERSION" ]; then + ./scripts/eas-continuous-deploy.sh "${args[@]}" + else + eas update \ + --channel production \ + --environment production \ + --platform ${{ inputs.platform }} \ + --message "${{ inputs.message || format('Production OTA ({0})', steps.source.outputs.sha) }}" \ + --non-interactive + fi diff --git a/.github/workflows/mobile-fingerprint-check.yml b/.github/workflows/mobile-fingerprint-check.yml index fd98817cd105..c84be53ba33f 100644 --- a/.github/workflows/mobile-fingerprint-check.yml +++ b/.github/workflows/mobile-fingerprint-check.yml @@ -32,7 +32,10 @@ concurrency: jobs: fingerprint: name: Native fingerprint diff - runs-on: blacksmith-8vcpu-ubuntu-2404 + # Upstream runs this on Blacksmith; the fork uses GitHub-hosted runners + # throughout, so a Blacksmith job here would queue forever on any PR + # touching apps/mobile and never report. + runs-on: ubuntu-24.04 permissions: contents: read issues: write diff --git a/.github/workflows/mobile-showcase-screenshots.yml b/.github/workflows/mobile-showcase-screenshots.yml index c64bccacdca8..c2f93f2e1394 100644 --- a/.github/workflows/mobile-showcase-screenshots.yml +++ b/.github/workflows/mobile-showcase-screenshots.yml @@ -45,7 +45,7 @@ jobs: ios: name: iPhone 6.9, iPhone 6.5, and iPad 13 if: inputs.platform == 'all' || inputs.platform == 'ios' - runs-on: blacksmith-12vcpu-macos-26 + runs-on: macos-15 # Capturing every palette multiplies the device matrix by six, and only the # one native build is shared between them. timeout-minutes: ${{ inputs.theme == 'all' && 300 || 60 }} @@ -94,7 +94,7 @@ jobs: android: name: Android phone, 7-inch tablet, and 10-inch tablet if: inputs.platform == 'all' || inputs.platform == 'android' - runs-on: blacksmith-16vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 # Capturing every palette multiplies the device matrix by six, and only the # one native build is shared between them. timeout-minutes: ${{ inputs.theme == 'all' && 300 || 60 }} diff --git a/.github/workflows/pr-size.yml b/.github/workflows/pr-size.yml deleted file mode 100644 index af557dff62df..000000000000 --- a/.github/workflows/pr-size.yml +++ /dev/null @@ -1,295 +0,0 @@ -name: PR Size - -on: - pull_request_target: - types: [opened, reopened, synchronize, ready_for_review, converted_to_draft] - -permissions: - contents: read - -jobs: - prepare-config: - name: Prepare PR size config - runs-on: ubuntu-24.04 - outputs: - labels_json: ${{ steps.config.outputs.labels_json }} - steps: - - id: config - name: Build PR size label config - uses: actions/github-script@v8 - with: - result-encoding: string - script: | - const managedLabels = [ - { - name: "size:XS", - color: "0e8a16", - description: "0-9 effective changed lines (test files excluded in mixed PRs).", - }, - { - name: "size:S", - color: "5ebd3e", - description: "10-29 effective changed lines (test files excluded in mixed PRs).", - }, - { - name: "size:M", - color: "fbca04", - description: "30-99 effective changed lines (test files excluded in mixed PRs).", - }, - { - name: "size:L", - color: "fe7d37", - description: "100-499 effective changed lines (test files excluded in mixed PRs).", - }, - { - name: "size:XL", - color: "d93f0b", - description: "500-999 effective changed lines (test files excluded in mixed PRs).", - }, - { - name: "size:XXL", - color: "b60205", - description: "1,000+ effective changed lines (test files excluded in mixed PRs).", - }, - ]; - - core.setOutput("labels_json", JSON.stringify(managedLabels)); - sync-label-definitions: - name: Sync PR size label definitions - needs: prepare-config - if: github.event_name != 'pull_request_target' - runs-on: ubuntu-24.04 - permissions: - contents: read - issues: write - steps: - - name: Ensure PR size labels exist - uses: actions/github-script@v8 - env: - PR_SIZE_LABELS_JSON: ${{ needs.prepare-config.outputs.labels_json }} - with: - script: | - const managedLabels = JSON.parse(process.env.PR_SIZE_LABELS_JSON ?? "[]"); - - for (const label of managedLabels) { - try { - const { data: existing } = await github.rest.issues.getLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - name: label.name, - }); - - if ( - existing.color !== label.color || - (existing.description ?? "") !== label.description - ) { - await github.rest.issues.updateLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - name: label.name, - color: label.color, - description: label.description, - }); - } - } catch (error) { - if (error.status !== 404) { - throw error; - } - - try { - await github.rest.issues.createLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - name: label.name, - color: label.color, - description: label.description, - }); - } catch (createError) { - if (createError.status !== 422) { - throw createError; - } - } - } - } - label: - name: Label PR size - needs: prepare-config - if: github.event_name == 'pull_request_target' - runs-on: ubuntu-24.04 - permissions: - contents: read - issues: read - pull-requests: write - concurrency: - group: pr-size-${{ github.event.pull_request.number }} - cancel-in-progress: true - steps: - # This pull_request_target job may fetch untrusted PR commits only as passive - # git data. Do not add dependency installs, build/test scripts, or cache - # actions here; use pull_request plus workflow_run for that pattern instead. - - name: Checkout base repository - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - name: Sync PR size label - uses: actions/github-script@v8 - env: - PR_SIZE_LABELS_JSON: ${{ needs.prepare-config.outputs.labels_json }} - with: - script: | - const { execFileSync } = require("node:child_process"); - - const issueNumber = context.payload.pull_request.number; - const baseSha = context.payload.pull_request.base.sha; - const headSha = context.payload.pull_request.head.sha; - const headTrackingRef = `refs/remotes/pr-size/${issueNumber}`; - const managedLabels = JSON.parse(process.env.PR_SIZE_LABELS_JSON ?? "[]"); - const managedLabelNames = new Set(managedLabels.map((label) => label.name)); - // Keep this aligned with the repo's test entrypoints and test-only support files. - const testExcludePathspecs = [ - ":(glob,exclude)**/__tests__/**", - ":(glob,exclude)**/test/**", - ":(glob,exclude)**/tests/**", - ":(glob,exclude)apps/server/integration/**", - ":(glob,exclude)**/*.test.*", - ":(glob,exclude)**/*.spec.*", - ":(glob,exclude)**/*.browser.*", - ":(glob,exclude)**/*.integration.*", - ]; - - const sumNumstat = (text) => - text - .split("\n") - .filter(Boolean) - .reduce((total, line) => { - const [insertionsRaw = "0", deletionsRaw = "0"] = line.split("\t"); - const additions = - insertionsRaw === "-" ? 0 : Number.parseInt(insertionsRaw, 10) || 0; - const deletions = - deletionsRaw === "-" ? 0 : Number.parseInt(deletionsRaw, 10) || 0; - - return total + additions + deletions; - }, 0); - - const resolveSizeLabel = (totalChangedLines) => { - if (totalChangedLines < 10) { - return "size:XS"; - } - - if (totalChangedLines < 30) { - return "size:S"; - } - - if (totalChangedLines < 100) { - return "size:M"; - } - - if (totalChangedLines < 500) { - return "size:L"; - } - - if (totalChangedLines < 1000) { - return "size:XL"; - } - - return "size:XXL"; - }; - - execFileSync("git", ["fetch", "--no-tags", "origin", baseSha], { - stdio: "inherit", - }); - - execFileSync( - "git", - ["fetch", "--no-tags", "origin", `+refs/pull/${issueNumber}/head:${headTrackingRef}`], - { - stdio: "inherit", - }, - ); - - const resolvedHeadSha = execFileSync("git", ["rev-parse", headTrackingRef], { - encoding: "utf8", - }).trim(); - - if (resolvedHeadSha !== headSha) { - core.warning( - `Fetched head SHA ${resolvedHeadSha} does not match pull request head SHA ${headSha}; using fetched ref for sizing.`, - ); - } - - execFileSync("git", ["cat-file", "-e", `${baseSha}^{commit}`], { - stdio: "inherit", - }); - - const diffArgs = [ - "diff", - "--numstat", - "--ignore-all-space", - "--ignore-blank-lines", - `${baseSha}...${resolvedHeadSha}`, - ]; - - const totalChangedLines = sumNumstat( - execFileSync( - "git", - diffArgs, - { encoding: "utf8" }, - ), - ); - const nonTestChangedLines = sumNumstat( - execFileSync("git", [...diffArgs, "--", ".", ...testExcludePathspecs], { - encoding: "utf8", - }), - ); - const testChangedLines = Math.max(0, totalChangedLines - nonTestChangedLines); - - const changedLines = nonTestChangedLines === 0 ? testChangedLines : nonTestChangedLines; - const nextLabelName = resolveSizeLabel(changedLines); - - const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: issueNumber, - per_page: 100, - }); - - for (const label of currentLabels) { - if (!managedLabelNames.has(label.name) || label.name === nextLabelName) { - continue; - } - - try { - await github.rest.issues.removeLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: issueNumber, - name: label.name, - }); - } catch (removeError) { - if (removeError.status !== 404) { - throw removeError; - } - } - } - - if (!currentLabels.some((label) => label.name === nextLabelName)) { - await github.rest.issues.addLabels({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: issueNumber, - labels: [nextLabelName], - }); - } - - const classification = - nonTestChangedLines === 0 - ? testChangedLines > 0 - ? "test-only PR" - : "no line changes" - : testChangedLines > 0 - ? "test lines excluded" - : "all non-test changes"; - - core.info( - `PR #${issueNumber}: ${nonTestChangedLines} non-test lines, ${testChangedLines} test lines, ${changedLines} effective lines -> ${nextLabelName} (${classification})`, - ); diff --git a/.github/workflows/pr-vouch.yml b/.github/workflows/pr-vouch.yml deleted file mode 100644 index c4abb08b727b..000000000000 --- a/.github/workflows/pr-vouch.yml +++ /dev/null @@ -1,199 +0,0 @@ -name: PR Vouch - -on: - pull_request_target: - types: [opened, reopened, synchronize, ready_for_review, converted_to_draft] - issue_comment: - types: [created] - push: - branches: - - main - paths: - - .github/VOUCHED.td - - .github/workflows/pr-vouch.yml - -permissions: - contents: read - issues: write - pull-requests: write - -jobs: - collect-targets: - name: Collect PR targets - runs-on: ubuntu-24.04 - outputs: - targets: ${{ steps.collect.outputs.targets }} - steps: - - id: collect - uses: actions/github-script@v8 - with: - script: | - if (context.eventName === "pull_request_target") { - const pr = context.payload.pull_request; - core.setOutput("targets", JSON.stringify([{ number: pr.number, user: pr.user.login }])); - return; - } - - if (context.eventName === "issue_comment") { - const issue = context.payload.issue; - const body = context.payload.comment?.body ?? ""; - if (!issue?.pull_request || !body.includes("/recheck-vouch")) { - core.setOutput("targets", "[]"); - return; - } - - core.setOutput( - "targets", - JSON.stringify([{ number: issue.number, user: issue.user.login }]), - ); - return; - } - - const pulls = await github.paginate(github.rest.pulls.list, { - owner: context.repo.owner, - repo: context.repo.repo, - state: "open", - per_page: 100, - }); - - const targets = pulls.map((pull) => ({ - number: pull.number, - user: pull.user.login, - })); - core.setOutput("targets", JSON.stringify(targets)); - - label: - name: Label PR ${{ matrix.target.number }} - needs: collect-targets - if: ${{ needs.collect-targets.outputs.targets != '[]' }} - runs-on: ubuntu-24.04 - concurrency: - group: pr-vouch-${{ matrix.target.number }} - cancel-in-progress: true - strategy: - fail-fast: false - matrix: - target: ${{ fromJson(needs.collect-targets.outputs.targets) }} - steps: - - id: vouch - name: Check PR author trust - uses: mitchellh/vouch/action/check-user@v1 - with: - user: ${{ matrix.target.user }} - allow-fail: true - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - - - name: Sync PR labels - uses: actions/github-script@v8 - env: - PR_NUMBER: ${{ matrix.target.number }} - VOUCH_STATUS: ${{ steps.vouch.outputs.status }} - with: - script: | - const issueNumber = Number(process.env.PR_NUMBER); - const status = process.env.VOUCH_STATUS; - const managedLabels = [ - { - name: "vouch:trusted", - color: "1f883d", - description: "PR author is trusted by repo permissions or the VOUCHED list.", - }, - { - name: "vouch:unvouched", - color: "fbca04", - description: "PR author is not yet trusted in the VOUCHED list.", - }, - { - name: "vouch:denounced", - color: "d1242f", - description: "PR author is explicitly blocked by the VOUCHED list.", - }, - ]; - - const managedLabelNames = new Set(managedLabels.map((label) => label.name)); - - for (const label of managedLabels) { - try { - const { data: existing } = await github.rest.issues.getLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - name: label.name, - }); - - if ( - existing.color !== label.color || - (existing.description ?? "") !== label.description - ) { - await github.rest.issues.updateLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - name: label.name, - color: label.color, - description: label.description, - }); - } - } catch (error) { - if (error.status !== 404) { - throw error; - } - - try { - await github.rest.issues.createLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - name: label.name, - color: label.color, - description: label.description, - }); - } catch (createError) { - if (createError.status !== 422) { - throw createError; - } - } - } - } - - const nextLabelName = - status === "denounced" - ? "vouch:denounced" - : ["bot", "collaborator", "vouched"].includes(status) - ? "vouch:trusted" - : "vouch:unvouched"; - - const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: issueNumber, - per_page: 100, - }); - - for (const label of currentLabels) { - if (!managedLabelNames.has(label.name) || label.name === nextLabelName) { - continue; - } - - try { - await github.rest.issues.removeLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: issueNumber, - name: label.name, - }); - } catch (removeError) { - if (removeError.status !== 404) { - throw removeError; - } - } - } - - if (!currentLabels.some((label) => label.name === nextLabelName)) { - await github.rest.issues.addLabels({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: issueNumber, - labels: [nextLabelName], - }); - } - - core.info(`PR #${issueNumber}: ${status} -> ${nextLabelName}`); diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 39e485d42a98..b6fa76cd5775 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -22,6 +22,11 @@ on: description: "Stable version override (for example 1.2.3). Defaults to the version the latest nightly previewed." required: false type: string + artifacts_only: + description: "Build downloadable desktop artifacts without publishing a release" + required: false + default: false + type: boolean # Serialize nightlies (scheduled and manual) so overlapping runs cannot build # the same commit twice or publish out of order. Stable tag releases get their @@ -45,7 +50,7 @@ jobs: # have already run. Scheduled runs also decide here whether a nightly is due. resolve_commit: name: Resolve release commit - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 5 outputs: ref: ${{ steps.resolve.outputs.ref }} @@ -87,7 +92,7 @@ jobs: if: | needs.resolve_commit.result == 'success' && (github.event_name != 'schedule' || needs.resolve_commit.outputs.has_changes == 'true') - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 outputs: release_channel: ${{ steps.release_meta.outputs.release_channel }} @@ -195,7 +200,7 @@ jobs: name: Release quality checks needs: [preflight] if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' }} - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Checkout @@ -239,7 +244,7 @@ jobs: if: | needs.resolve_commit.result == 'success' && (github.event_name != 'schedule' || needs.resolve_commit.outputs.has_changes == 'true') - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 5 environment: name: production @@ -339,7 +344,7 @@ jobs: if: | needs.resolve_commit.result == 'success' && (github.event_name != 'schedule' || needs.resolve_commit.outputs.has_changes == 'true') - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 15 steps: - name: Checkout @@ -404,28 +409,28 @@ jobs: matrix: include: - label: macOS arm64 - runner: blacksmith-12vcpu-macos-26 + runner: macos-15 platform: mac target: dmg arch: arm64 rust_target: aarch64-apple-darwin resource_key: darwin-arm64 - label: macOS x64 - runner: blacksmith-12vcpu-macos-26 + runner: macos-15 platform: mac target: dmg arch: x64 rust_target: x86_64-apple-darwin resource_key: darwin-x64 - label: Linux x64 - runner: blacksmith-32vcpu-ubuntu-2404 + runner: ubuntu-24.04 platform: linux target: AppImage arch: x64 rust_target: x86_64-unknown-linux-gnu resource_key: linux-x64 - label: Windows x64 - runner: blacksmith-32vcpu-windows-2025 + runner: windows-2025 platform: win target: nsis arch: x64 @@ -778,8 +783,8 @@ jobs: publish_cli: name: Publish CLI to npm needs: [preflight, relay_public_config, quality, build] - if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.relay_public_config.result == 'success' && needs.quality.result == 'success' && needs.build.result == 'success' }} - runs-on: ubuntu-24.04 # blacksmith-8vcpu-ubuntu-2404 + if: ${{ !failure() && !cancelled() && inputs.artifacts_only != true && needs.preflight.result == 'success' && needs.relay_public_config.result == 'success' && needs.quality.result == 'success' && needs.build.result == 'success' }} + runs-on: ubuntu-24.04 timeout-minutes: 10 permissions: contents: read @@ -857,7 +862,8 @@ jobs: name: Publish GitHub Release needs: [preflight, build, publish_cli] if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.build.result == 'success' && needs.publish_cli.result == 'success' }} - runs-on: blacksmith-8vcpu-ubuntu-2404 + # Blacksmith runners are not available to this fork. + runs-on: ubuntu-24.04 timeout-minutes: 30 permissions: contents: write @@ -953,7 +959,7 @@ jobs: name: Deploy hosted web app needs: [preflight, relay_public_config, release] if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.relay_public_config.result == 'success' && needs.release.result == 'success' }} - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 env: T3CODE_CLERK_PUBLISHABLE_KEY: ${{ needs.relay_public_config.outputs.clerk_publishable_key }} @@ -1072,7 +1078,7 @@ jobs: name: Deploy marketing site needs: [preflight, release] if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.release.result == 'success' && needs.preflight.outputs.release_channel == 'nightly' }} - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 env: VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }} @@ -1126,7 +1132,7 @@ jobs: name: Finalize release if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.release.result == 'success' && needs.preflight.outputs.release_channel == 'stable' }} needs: [preflight, release] - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - id: app_token @@ -1211,7 +1217,7 @@ jobs: needs.deploy_web.result == 'success' && (needs.finalize.result == 'success' || needs.finalize.result == 'skipped') needs: [preflight, relay_public_config, release, deploy_web, finalize] - runs-on: blacksmith-8vcpu-ubuntu-2404 + runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Checkout diff --git a/.github/workflows/upstream-lineage-guard.yml b/.github/workflows/upstream-lineage-guard.yml new file mode 100644 index 000000000000..8cce721566b8 --- /dev/null +++ b/.github/workflows/upstream-lineage-guard.yml @@ -0,0 +1,52 @@ +name: Upstream Lineage Guard + +# Fails when an upstream sync reaches fork/dev without its second parent. +# +# Squash- and rebase-merging a sync PR keeps the code and discards the lineage: +# the upstream commits stop being ancestors, so `fork/dev..upstream/main` reports +# already-merged work as missing and the next sync re-merges and re-resolves all +# of it. #401 landed that way; it surfaced two merges later, in a deploy alert +# that said "Commits (2)" for a range that had carried 23. +# +# This runs after the merge, not before it — GitHub has no per-PR merge-method +# control, and a repository-wide setting cannot allow squash for ordinary fork +# PRs while requiring a merge commit for syncs. So the button stays available +# and this turns a silent, weeks-later discovery into a red check within a +# minute, with the repair printed in the log. +# +# Prevention, rather than detection, is to merge sync PRs with +# `gh pr merge --merge` instead of the button. +on: + push: + branches: + - fork/dev + +concurrency: + group: upstream-lineage-guard-${{ github.sha }} + cancel-in-progress: true + +jobs: + lineage: + name: Upstream lineage + runs-on: ubuntu-24.04 + permissions: + contents: read + pull-requests: read + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + # Full history: the check walks the pushed range and counts parents, + # both of which a shallow clone hides. + fetch-depth: 0 + sparse-checkout: | + /.github + sparse-checkout-cone-mode: false + + - name: Check pushed commits + env: + GH_TOKEN: ${{ github.token }} + GITHUB_REPOSITORY: ${{ github.repository }} + BEFORE: ${{ github.event.before }} + AFTER: ${{ github.event.after }} + run: .github/scripts/check-upstream-lineage.sh diff --git a/.github/workflows/web-preview.yml b/.github/workflows/web-preview.yml index f9cc3b063fcd..ac3f58b4c55b 100644 --- a/.github/workflows/web-preview.yml +++ b/.github/workflows/web-preview.yml @@ -37,7 +37,10 @@ jobs: github.event.pull_request.head.repo.full_name == github.repository && contains(github.event.pull_request.labels.*.name, 'preview:web') && (github.event.action != 'labeled' || github.event.label.name == 'preview:web') - runs-on: blacksmith-8vcpu-ubuntu-2404 + # Upstream runs this on Blacksmith; every fork workflow uses GitHub-hosted + # runners, so a Blacksmith job here would queue forever if anyone ever + # applied the preview:web label. + runs-on: ubuntu-24.04 timeout-minutes: 10 env: VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }} diff --git a/.gitignore b/.gitignore index 57262578a786..cb88116550de 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ node_modules *.log *.tsbuildinfo apps/*/dist +apps/vscode/*.vsix infra/*/dist .astro packages/*/dist @@ -28,6 +29,9 @@ squashfs-root/ .plans/ dist-electron/ .electron-runtime/ + +# Local dir-deploy version counter (see scripts/build-and-deploy-dir.sh) +.dir-deploy-n .showcase/ apps/mobile/.showcase/ artifacts/app-store/screenshots/ @@ -38,3 +42,9 @@ node_modules/ *.log .env* !.env.example +!.envrc +# direnv +.direnv +# agent gh shim + local run state (ship-gate cache, etc.) +.tools/ +.run/ diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 000000000000..c48c043af4de --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,13 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Run T3 Code VS Code Extension", + "type": "extensionHost", + "request": "launch", + "args": ["--extensionDevelopmentPath=${workspaceFolder}/apps/vscode"], + "outFiles": ["${workspaceFolder}/apps/vscode/dist/**/*.cjs"], + "preLaunchTask": "build-vscode-extension" + } + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json index 564120b4aaff..0073ae2abfa0 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -13,5 +13,6 @@ }, "search.exclude": { ".repos/**": true - } + }, + "js/ts.experimental.useTsgo": true } diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 000000000000..28cfef1808be --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,12 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "build-vscode-extension", + "type": "shell", + "command": "pnpm --filter t3-code build", + "group": "build", + "problemMatcher": "$tsc" + } + ] +} diff --git a/AGENTS.md b/AGENTS.md index e3b5771d797c..17ed5e2f5f27 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,8 +1,52 @@ -# T3 Code +# AGENTS.md T3 Code is a minimal GUI for coding agents. A Node WebSocket server wraps provider CLIs and agents (Codex, Claude Code, Cursor, Grok, OpenCode, Antigravity) and serves web, desktop, and mobile clients. -You can think of T3 Code as an open source "bring-your-own-subscription" alternative to apps like Claude Desktop, Codex App, Cursor Glass and Conductor. +## Downstream fork branches and pull requests + +```text +pingdotgg/t3code:main + └── main exact upstream mirror, fast-forward only + └── fork/dev product: PR target, squash-merge, release source +``` + +- **Change PRs:** branch from `fork/dev`, open every implementation PR against `fork/dev`, and + squash-merge it. Never open implementation PRs against `main`. +- **Catching a published PR up:** once the PR is no longer draft, rebase onto latest `fork/dev` or + merge latest `fork/dev` into the PR branch if it is behind or conflicting. Either is fine — pick + one. Draft PRs skip this. After publish, watch required checks until they are green. +- **Updating from upstream:** fast-forward `main` to `upstream/main`, then classic-merge `main` into + `fork/dev`. Never merge downstream work into `main`, and never use GitHub's **Sync fork** button. + When the merge hits shared product paths, do a 3-way merge — never a blind whole-file + `ours`/`theirs`. **Land a sync PR with `gh pr merge --merge`, never the GitHub button:** + ordinary fork PRs squash, so the button remembers "Squash and merge", which drops the merge's + second parent. The code survives, but `fork/dev..upstream/main` then reports already-merged work + as missing and the next sync re-resolves every conflict. #401 landed that way and went unnoticed + for two merges; `.github/workflows/upstream-lineage-guard.yml` now catches it on the next push to + `fork/dev` and prints the repair. +- Independent features use parallel PRs based on `fork/dev`. Chain PRs only when one change + genuinely depends on another, and merge that chain bottom-up. +- All features land in `fork/dev`, including upstreamable work. To send something upstream, open a + PR from a branch cut against upstream `main` in the usual GitHub way. +- Opening or updating a PR runs Fork CI (`.github/workflows/fork-ci.yml`) but does not deploy. + Releases come from green `fork/dev` SHAs. Machine topology and deployment implementation belong + in a separate private operations repository, not this one. +- The inherited upstream **`.github/workflows/ci.yml` (Blacksmith runners)**, `deploy-relay.yml`, + and `release.yml` (T3 Connect nightly plus tag/desktop GitHub Releases) workflows are + **`disabled_manually` at repository level**. This fork has no Blacksmith runners and does not + deploy T3 Connect. Fork shipping uses Fork Release, not `release.yml`. **Do not re-enable** them. + After an accidental re-enable: `gh workflow disable CI --repo `, + `gh workflow disable "Deploy T3 Connect relay" --repo `, + `gh workflow disable Release --repo `. +- Persistence migrations: keep true upstream migrations in `Migrations.ts`; rewrite fork-local + migrations into `ForkMigrations.ts`. Never share a migration ledger between upstream and fork + histories. +- Fork product / UI changes must land with a test that fails if the surface disappears (pure + helpers alone are not enough). Prefer `aria-label`/`data-testid` existence, or markers in + `apps/web/src/forkSurfaceExistence.test.ts` for chrome. +- After a merge that touches dependencies, never leave `pnpm-lock.yaml` mismatched with + `package.json`. Regenerate the lockfile (`CI= pnpm install --no-frozen-lockfile`) rather than + taking `--ours`/`--theirs` on it. ## What makes T3 Code special? @@ -18,7 +62,7 @@ Lots of apps have gotten bogged down with bad tech decisions and "slop". We have ### 3. Remote ready -The architecture of T3 Code's websocket layer (npx t3) enables a lot of awesome remote features. These have become core to the product. Whether users are connecting directly over their local network, using Tailscale, or leaning in fully with T3 Connect (our tunnel solution, also in this repo), we need to make sure new features are properly supported. +The architecture of T3 Code's websocket layer (`npx t3`) enables a lot of awesome remote features. These have become core to the product. Whether users are connecting directly over their local network, using Tailscale, or leaning in fully with T3 Connect (our tunnel solution, also in this repo), we need to make sure new features are properly supported. ### 4. Multi-surface @@ -67,21 +111,197 @@ We need to be on the same page with terminology. When communicating, use this la The most common defect in this repo is a change that works on the path you tested and is missing everywhere else. Before calling frontend work done, walk this list and say which entries applied: - **Entry points.** A behavior reachable from the chat view is usually also reachable from Settings, the command palette, and a keybinding. Fixing one is not fixing the feature. -- **Clients.** Web, desktop (wraps web, adds Electron shell/IPC), and mobile (React Native, separate navigation). Shared logic lives in `packages/client-runtime` +- **Clients.** Web, desktop (wraps web, adds Electron shell/IPC), and mobile (React Native, separate navigation). Shared logic lives in `packages/client-runtime`. - **Providers.** Codex, Claude, Cursor, Grok, OpenCode, and Antigravity each have an adapter. Provider-shaped features need a decision per adapter, even if the decision is "not supported here". - **Contracts.** Anything crossing the wire is typed in `packages/contracts`. Change the schema and the server, web, mobile, and desktop all follow. - **Reverse states.** If you added a way in, add the way out and the way to see it. Snooze needs unsnooze. Close needs reopen. A one-way door is a bug. - **Connection modes.** Local, remote/relay, and tunnel behave differently. Multi-device and multi-environment cases are real. - **Docs.** Check whether the change makes existing guidance inaccurate. Apply the [documentation rules](#documentation) before adding anything. -## Dev servers +## Pull requests (when publishing) + +Do not commit, rebase, push, or open/update a PR merely because an edit is complete. Do those +things only when the user explicitly requests publication or the specific version-control action, +or when another workflow in this file explicitly requires it (for example, Discord-originated +work). A request to change code, docs, or config does not by itself authorize publication. + +When publication or a PR handoff is in scope: + +1. **Commit** the changes on a feature branch cut from `fork/dev`. +2. **Open or update a PR against `fork/dev`** before handing off. Never target `main`. +3. **Let the agent ship gate own validation** before saying “updated the PR” or finishing (see + _Task Completion Requirements → Agent ship gate_): + - **Draft / no-PR pushes** run `vp check` on files changed against `fork/dev`, plus workspace + `vpr typecheck`. Commits already pay lint-staged (fmt + lint of staged files). Do **not** + hand-run the unit suite while drafting. + - **Publishing** (`pnpm pr:ready`) requires HEAD to contain latest `fork/dev` (rebase or merge + — your choice), then the **full** ship gate (`vp check` → `vpr typecheck` → `vp run test`). + Only a failing gate stops it. Raw `gh pr ready` is not refused — the `.tools/bin/gh` shim + runs the same gate first. The husky `pre-push` hook fails closed when PR state can’t be + resolved. + - **Published (ready) PRs** pay the full ship gate on every agent push. After publish, **watch + the PR until required checks are green** (`gh pr checks` / `gh pr view`). Fix real failures + and re-push; dismiss false positives with a written reason. Stay quiet when nothing is new. + Stop when the bots are green on the latest commit. + - Confirm with `gh pr view --json baseRefName,mergeable,mergeStateStatus,url` + - `baseRefName` must be `fork/dev`. After publish, `mergeable` should be `MERGEABLE` (CI may + still be `UNSTABLE` while checks run — that is what you watch to green). +4. **Before pushing follow-ups**, verify PR state with `gh pr view` (or equivalent): + - If the PR is **open** → update that branch and push; the + gate re-runs for that HEAD (changed-file if draft, full if ready). + - If the PR is **merged** or **closed** → do **not** keep committing on that branch. + Start a new branch, re-apply unmerged work, and open a **new PR** against `fork/dev`. +5. Never assume an earlier PR in the session is still open. +6. **Never merge or request merge** (and never tell a bot to merge) a PR that has not passed the ship + gate and whose required checks are not green — publish through `pnpm pr:ready` first, then + watch CI. GitHub required checks on `fork/dev` are the backstop; the ship gate is what runs + first. + +## Discord-originated commits (REQUIRED) + +When the Discord turn includes an **Identity map** block with ready-to-paste `Co-authored-by` trailers, attribution is **mandatory**, not optional: + +1. Keep the environment default **author/committer** (usually the GitHub App bot). +2. **Every** `git commit` you create for that work MUST end with those exact trailers after a blank line. Do not invent emails for unmapped people. +3. Before `git push` / opening a PR, verify with `git log -1 --format=%B` that the trailers are present on each new commit. +4. A Discord-originated commit **without** the mapped trailers is incomplete — fix it (amend if not pushed, or a follow-up commit is not enough for GitHub multi-author on already-pushed SHAs; amend/rebase when safe). + +GitHub multi-author avatars (`bot & human`) come from commit trailers, not from PR body prose alone. + +## Discord-originated pull requests (REQUIRED) + +When Discord work produces commits (or is clearly intended to land): + +0. **Always open a PR — do not wait for perfect green.** Create the PR as a **draft** as soon as the first meaningful commit gives reviewers something to inspect, and push freely while it stays draft. A missing PR while work sits only on a remote branch is incomplete handoff. **Publish only when done, with `pnpm pr:ready`** — it runs the agent ship gate, then undrafts. **Draft is for tracking, not for merging:** do not squash-merge, rebase-merge, or instruct a bot to merge a draft or any tip that has not passed the ship gate. + +When opening or updating a PR from a Discord thread: + +1. **Discord footer (required in the PR description).** Append this exact footer form at the end of the PR body (use the **thread starter** when known, otherwise the current requester, and that thread’s real jump link): + +```md +opened by [](discord_user_id) in chat thread **Discord** · [Thread Title](https://discord.com/channels///) +``` + +Prefer the thread starter’s Discord id/display name from turn context. Do not skip this because the bot _might_ patch the body later — still write it when you create the PR so the first revision is correct. The bot may also hard-append the footer when a PR URL is linked; that is a safety net, not a reason to omit it. + +2. If Discord turn context lists **Linked work items** / Jira issues for the thread, include those Jira issue links in the PR description (and prefer the primary key in the title/branch when one is clear). + +3. Prefer opening the PR only after commits already include the Identity map `Co-authored-by` trailers (see above). + +## Task Completion Requirements + +### Agent ship gate (changed files on draft, full on ready / publish) + +Publish validation is **automated**. Agents do **not** hand-run the workspace +linter/typechecker/tests as a routine pre-handoff ritual — the ship gate runs them at the right +moment, and caches a passing full-gate SHA. + +**Mechanism** (`scripts/agent-pre-push.mjs`, `scripts/agent-pr-ready.mjs`, `scripts/lib/*.mjs`): + +- Husky `pre-push` is the agent ship gate. It is a **no-op for humans** and only fires for coding + agents (detected via `GROK_AGENT` / `T3_AGENT` / `AI_AGENT` / `CLAUDECODE` / Cursor / Codex env + markers). Humans opt out per push with `SKIP_AGENT_PREPUSH=1` — **agents never set that flag** and + never use `git push --no-verify`. +- When it runs: + 1. **Draft / no-PR:** `vp check` on files changed against `fork/dev` (fmt + lint), then + workspace **`vpr typecheck`**. + 2. **Ready / publish:** workspace **`vp check`** → **`vpr typecheck`** → **`vp run test`**. + Cargo, mobile native, desktop packaging, and Release Smoke stay **CI-only** — do not hand-run + them for ordinary PR handoff. +- The **full** gate **skips when the HEAD SHA is already cached** in `.run/agent-ship-gate.json`. + Force with `AGENT_SHIP_GATE_FORCE=1`. + +**When it runs:** + +| Branch PR state | Agent push | +| ---------------------- | --------------------------------------------- | +| No open PR | **changed-file** `vp check` + `vpr typecheck` | +| **Draft** PR | **changed-file** `vp check` + `vpr typecheck` | +| **Ready** PR | **full** ship gate on every push | +| PR state can’t resolve | **full** ship gate (**fail closed**) | + +The gate keys off the PR’s **ready state**, not its base. + +**Publish path:** `pnpm pr:ready` — HEAD must contain latest `fork/dev`, then the **full** ship +gate, then the open draft is marked ready. After that, **watch GitHub checks until they are +green**. Raw `gh pr ready` (and the ready-for-review APIs) reach the same place: the `.tools/bin/gh` +policy shim runs the ship gate first and passes the command through when it is green, so publishing +is gated rather than forbidden and a red gate is the only thing that stops it. `AGENT_PR_SHIP=1` +marks a gate already passed — `pr:ready` sets it for its own undraft call so the gate runs once, +not twice. `.envrc` puts `$REPO/.tools/bin` first on `PATH` so the shim wins over system `gh`, and +sets `GH_REPO` to the fork so bare `gh pr` commands target it instead of gh's upstream-parent +default (explicit `--repo` still overrides); `scripts/install-git-hooks.mjs` installs both the +hooks and the shim on `prepare`. + +**Agent workflow:** + +- **Open the draft immediately** once a PR is in scope (user asked, or Discord/turn rules require it) + and the first meaningful commit is useful to review. Keep committing and pushing while it is a + draft — each push pays **changed-file** `vp check` + `vpr typecheck`. +- **Publish when the work is done — do not leave a finished PR in draft.** Catch up to latest + `fork/dev` if needed, then `pnpm pr:ready`. That is the immediate next action, before handoff + notes, so full CI can start. Draft is only for work-in-progress. +- **After publish, monitor the PR to green.** Poll checks and comments newer than the last push. + Verify each bot finding against the source, fix real ones, dismiss false positives with a written + reason. Stay quiet when nothing is new. Stop when the bots are green on the latest commit. +- **Mid-loop feedback only:** while drafting, focused proof is fine — `vp test run ` for tests + you touched, targeted lint/typecheck for the scope you changed. That is edit-loop signal, not a + second gate. +- Fork product / UI changes still **must** ship an existence or behavior assertion that fails if the + surface is dropped (not only pure helpers) — see `apps/web/src/forkSurfaceExistence.test.ts`. + The gate’s `vp run test` then actually exercises it. +- Backend / contracts / runtime behavior changes **must** land with focused tests for the changed + behavior; the gate’s `vp run test` runs them. +- Test meaningful logic or observable behavior. Do not render components to static markup to assert props or attributes, or add tests that merely assert callback wiring or mirror the implementation. + +Pre-commit: husky runs `pnpm lint-staged` — `vp fmt` on all staged files plus `vp lint --fix` on +staged code files. Typecheck and unit tests stay in the full ship gate (ready / publish). If the +hook rewrites files, stage those rewrites, commit, and push again. + +**Explicitly forbidden:** + +- `git push --no-verify` / `git commit --no-verify`, or setting `SKIP_AGENT_PREPUSH` (human escape + hatch only). +- Raw `gh pr ready` / the ready-for-review API to undraft — always `pnpm pr:ready`. +- Merging or requesting merge (including telling a bot to merge) a draft or any tip that has not + passed the ship gate. +- Treating “CI will catch it” as a substitute for publishing through the gate. If a PR’s checks + panel shows **no** Check job, it has not been through the gate — publish with `pnpm pr:ready`. +- Leaving Discord/agent work with commits but **no** PR (open a draft; draft pushes pay changed-file + check + typecheck). +- Publishing a PR that is behind `fork/dev`, or walking away from a published PR before its required + checks are green. +- Leaving a **finished** PR in draft. Draft is for work-in-progress only; when the work is done, + publish it with `pnpm pr:ready` — a completed PR sitting in draft is an incomplete handoff. + +### Client-visible verification + +After frontend feature development or any user-visible frontend behavior change, the primary agent +must run one integrated verification pass for each affected client surface after integrating the +work: + +- Web: use the `test-t3-app` skill. Launch one isolated environment, authenticate through the printed + pairing URL, and verify the affected flow in the controlled browser. +- Mobile: use the `test-t3-mobile` skill. Connect one representative iOS Simulator or Android + Emulator available on the host to one isolated environment and verify the affected flow. On + compatible macOS hosts, prefer iOS for cross-platform changes and stream it through serve-sim in + the T3 Code in-app browser or another available agent browser; use Android when it is the affected + or viable platform. +- Subagents must not independently launch dev servers or repeat integrated client verification + unless their delegated task explicitly requires it. +- Stop dev servers, watchers, and other long-running verification processes when the focused + verification is complete. + +## Dev Servers - `vp i` installs. Worktrees get this from the t3.json setup script; if module resolution looks broken, it probably did not run. -- `vp run dev` starts server and web. In a worktree, state defaults to that worktree's gitignored `.t3`, which deliberately outranks an ambient `T3CODE_HOME` so you cannot land on shared state by accident. An explicit `--home-dir` still wins. -- Ports derive from the worktree path and are stable across restarts, but read the real ones from the `[dev-runner]` line since occupied ports shift. -- Sharing over the tailnet is three steps: run `vp run dev --share` in the background, wait for the `pairingUrl:` line in its output, paste that full URL (token included) in your reply. Do not wire up `tailscale serve` by hand for this, and do not open the URL yourself. +- In a linked git worktree, dev state defaults to that worktree's gitignored `.t3`. This deliberately outranks an ambient `T3CODE_HOME`, which could otherwise select the installed app's live `~/.t3/userdata` database. An explicit `--home-dir` still wins. +- Start the web stack with `vp run dev`. Sharing over the tailnet is three steps: run `vp run dev --share` in the background, wait for the `pairingUrl:` line in its output, paste that full URL (token included) in your reply. Do not wire up `tailscale serve` by hand for this, and do not open the URL yourself. - The web app requires pairing. Hand over the pairing URL, not the bare origin. A URL without its token is useless to whoever you gave it to. If the token got consumed, mint a fresh one with `node apps/server/src/bin.ts pair` — note it carries standard scopes, while the startup URL carries admin scopes (needed for Settings → Connections management). -- Stop what you started, by the PID you tracked. See rule 1. +- Browser dev is single-origin: Vite proxies `/api`, `/ws`, `/oauth`, and `/.well-known` to the backend. Do not set `VITE_HTTP_URL` or `VITE_WS_URL` for `dev`/`dev:web`. +- Worktree paths supply stable preferred port offsets. Read the actual server and web ports from the `[dev-runner]` line because occupied ports can still shift them. +- Before handing off a `--share` URL, open its **origin only** (no path, no token) in a controlled browser and confirm the app loads — never the full pairing URL, whose one-time token the check would consume. A successful curl is insufficient because browsers reject some otherwise reachable ports. +- Stop what you started, by the PID you tracked. See _The three ways to hurt yourself_. ## Test data @@ -101,24 +321,35 @@ An empty database is a bad test. Seed your worktree's `.t3` with a copy of real - Bring `secrets` and `settings.json` only if the flow under test needs them. - Copy in, never symlink. Data flows one way: into your sandbox, never back out. -## Verifying +## Package Roles -- Smallest proof that the change works. `vp test run ` for the tests you touched, targeted lint and typecheck for the scope you changed. -- Test meaningful logic or observable behavior. Do not render components to static markup to assert props or attributes, or add tests that merely assert callback wiring or mirror the implementation. -- **Do not run repo-wide checks.** No `vp check`, no `vp run -r test`, no `vp run -r typecheck` unless I ask. CI owns the full suite. -- Backend behavior changes ship with focused tests for that behavior. -- The server is event-sourced and its async flows emit typed receipts. Wait on receipts and worker drains, never on sleeps or polling. A test that needs a timeout to pass is wrong. -- Upon request, user-visible frontend changes should get one integrated pass in a real client: `test-t3-app` for web, `test-t3-mobile` for mobile. The primary agent does this once after integrating. Subagents do not launch their own dev servers. Ask permission before doing computer use or spinning up browsers. +- `apps/server`: Node.js WebSocket server. Wraps Codex app-server (JSON-RPC over stdio), serves the React web app, and manages provider sessions. +- `apps/web`: React/Vite UI. Owns session UX, conversation/event rendering, and client-side state. Connects to the server via WebSocket. +- `packages/contracts`: Shared effect/Schema schemas and TypeScript contracts for provider events, WebSocket protocol, and model/session types. Keep this package schema-only — no runtime logic. +- `packages/shared`: Shared runtime utilities consumed by both server and client applications. Uses explicit subpath exports (e.g. `@t3tools/shared/git`) — no barrel index. +- `packages/client-runtime`: Shared runtime package for sharing client code across web and mobile. -## Pull requests +## Reference Repos -- Never make a PR unless the developer explicitly asks you to do so. -- Conventional commit titles, plain language: `fix(web): new threads no longer spike CPU`. -- Body: the problem in a sentence or two, then how you fixed it. End with the model and harness that did the work. -- UI changes need before/after images. Motion or timing needs a short video. -- Upload PR evidence to GitHub. Never commit PR-only screenshots or assets such as `.github/pr-assets/`. -- One concern per PR. If the description says "also", split it. -- When babysitting: poll checks and comments newer than the last push, verify each bot finding against the source, fix real ones, dismiss false positives with a written reason. Stay quiet when nothing is new. Stop when the bots are green on the latest commit. +- Open-source Codex repo: https://github.com/openai/codex + +Use these as implementation references when designing protocol handling, UX flows, and operational safeguards. + +## Vendored Repositories + +This project vendors external repositories under `.repos/` as read-only reference material for coding +agents. + +- Prefer examples and patterns from the vendored source code over generated guesses or web search results. +- Do not edit files under `.repos/` unless explicitly asked. +- Do not import from `.repos/`; application code must continue importing from normal package dependencies. +- Manage vendored subtrees with `vpr sync:repos`; use `vpr sync:repos --repo ` to sync one configured repository. +- When updating a dependency with a configured vendored subtree, sync that subtree in the same change so + `.repos/` matches the installed dependency version. +- When writing Effect code, read `.repos/effect-smol/LLMS.md` first and inspect `.repos/effect-smol/` for + examples of idiomatic usage, tests, module structure, and API design. +- When writing relay infrastructure code with Alchemy, inspect `.repos/alchemy-effect/` for examples of + idiomatic usage, tests, module structure, and API design. ## Documentation @@ -165,3 +396,6 @@ Full glossary with file links: `docs/internals/glossary.md` - Don't verify with browsers or computer use unless the user explicitly agrees or requests it. - Security is important, but should not be over-indexed on, especially for dev mode/maintainer-only features. +- The server is event-sourced and its async flows emit typed receipts. Wait on receipts and worker drains, never on sleeps or polling. A test that needs a timeout to pass is wrong. +- Conventional commit titles, plain language: `fix(web): new threads no longer spike CPU`. Body: the problem in a sentence or two, then how you fixed it. End with the model and harness that did the work. One concern per PR — if the description says "also", split it. +- UI changes need before/after images. Motion or timing needs a short video. Upload PR evidence to GitHub. Never commit PR-only screenshots or assets such as `.github/pr-assets/`. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index caa8f8309bb9..e7461dfe721e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -17,7 +17,7 @@ If that sounds annoying, that is because it is. This project is still early and PRs are automatically labeled with a `vouch:*` trust status and a `size:*` diff size based on changed lines. -If you are an external contributor, expect `vouch:unvouched` until we explicitly add you to [.github/VOUCHED.td](.github/VOUCHED.td). +If you are an external contributor, expect `vouch:unvouched` until a maintainer vouches for you. This fork does not carry upstream's `.github/VOUCHED.td` roster. ## What We Are Most Likely To Accept diff --git a/apps/desktop/scripts/ensure-electron-runtime.mjs b/apps/desktop/scripts/ensure-electron-runtime.mjs index b8b8254c9b3c..072ad55651d8 100644 --- a/apps/desktop/scripts/ensure-electron-runtime.mjs +++ b/apps/desktop/scripts/ensure-electron-runtime.mjs @@ -123,6 +123,11 @@ function installElectronRuntime(electronDir, version) { try { runChecked("curl", [ "-fsSL", + "--retry", + "4", + "--retry-all-errors", + "--connect-timeout", + "15", `https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-${hostPlatform}-${hostArch}.zip`, "-o", zipPath, diff --git a/apps/desktop/src/app/DesktopApp.test.ts b/apps/desktop/src/app/DesktopApp.test.ts new file mode 100644 index 000000000000..9e46b137b0b0 --- /dev/null +++ b/apps/desktop/src/app/DesktopApp.test.ts @@ -0,0 +1,22 @@ +import { describe, expect, it } from "vite-plus/test"; +import * as Option from "effect/Option"; + +import { resolveDesktopBackendPortHint } from "./DesktopApp.ts"; + +describe("resolveDesktopBackendPortHint", () => { + it("keeps the renderer protocol aligned with a reused live backend", () => { + expect(resolveDesktopBackendPortHint("http://127.0.0.1:8080/", Option.some(3773))).toEqual( + Option.some(8080), + ); + }); + + it("uses the configured port when no live backend exists", () => { + expect(resolveDesktopBackendPortHint(undefined, Option.some(4949))).toEqual(Option.some(4949)); + }); + + it("ignores a malformed live backend marker", () => { + expect(resolveDesktopBackendPortHint("not a URL", Option.some(4949))).toEqual( + Option.some(4949), + ); + }); +}); diff --git a/apps/desktop/src/app/DesktopApp.ts b/apps/desktop/src/app/DesktopApp.ts index e84e6d5c730d..9ee6d402b318 100644 --- a/apps/desktop/src/app/DesktopApp.ts +++ b/apps/desktop/src/app/DesktopApp.ts @@ -14,6 +14,7 @@ import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts"; import * as DesktopAppActivation from "./DesktopAppActivation.ts"; import * as DesktopAppIdentity from "./DesktopAppIdentity.ts"; import * as DesktopClerk from "./DesktopClerk.ts"; +import * as DesktopDeepLinks from "./DesktopDeepLinks.ts"; import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts"; import * as DesktopWindow from "../window/DesktopWindow.ts"; import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts"; @@ -24,6 +25,7 @@ import * as DesktopObservability from "./DesktopObservability.ts"; import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts"; import * as DesktopShutdown from "./DesktopShutdown.ts"; import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts"; +import { readLiveExistingBackend } from "../backend/DesktopExistingBackend.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts"; import * as DesktopState from "./DesktopState.ts"; @@ -69,6 +71,24 @@ const { logInfo: logBootstrapInfo, logWarning: logBootstrapWarning } = const { logInfo: logStartupInfo, logError: logStartupError } = DesktopObservability.makeComponentLogger("desktop-startup"); +export function resolveDesktopBackendPortHint( + existingBackendHttpBaseUrl: string | undefined, + configuredPort: Option.Option, +): Option.Option { + if (existingBackendHttpBaseUrl !== undefined) { + try { + const port = Number.parseInt(new URL(existingBackendHttpBaseUrl).port, 10); + if (Number.isSafeInteger(port) && port > 0 && port <= MAX_TCP_PORT) { + return Option.some(port); + } + } catch { + // Fall through to the configured port when the live marker is malformed. + } + } + + return configuredPort; +} + const resolveDesktopBackendPort = Effect.fn("resolveDesktopBackendPort")(function* ( configuredPort: Option.Option, ) { @@ -159,7 +179,10 @@ const bootstrap = Effect.gen(function* () { return yield* new DesktopDevelopmentBackendPortRequiredError(); } - const backendPortSelection = yield* resolveDesktopBackendPort(environment.configuredBackendPort); + const existingBackend = readLiveExistingBackend(environment.stateDir); + const backendPortSelection = yield* resolveDesktopBackendPort( + resolveDesktopBackendPortHint(existingBackend?.httpBaseUrl, environment.configuredBackendPort), + ); const backendPort = backendPortSelection.port; yield* logBootstrapInfo( backendPortSelection.selectedByScan @@ -170,6 +193,13 @@ const bootstrap = Effect.gen(function* () { ...(backendPortSelection.selectedByScan ? { startPort: DEFAULT_DESKTOP_BACKEND_PORT } : {}), }, ); + if (existingBackend) { + yield* logBootstrapInfo("reusing existing backend for shared T3 home", { + pid: existingBackend.pid, + httpBaseUrl: existingBackend.httpBaseUrl, + stateDir: existingBackend.stateDir, + }); + } const settings = yield* desktopSettings.get; if (settings.serverExposureMode !== environment.defaultDesktopSettings.serverExposureMode) { @@ -229,6 +259,12 @@ const bootstrap = Effect.gen(function* () { // slow first wsl.exe spawn. yield* Effect.forkScoped(wslBackend.reconcile); } + + // Catalog + window services are usable; flush any deep link captured from + // initial argv / open-url during single-instance setup. + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + yield* deepLinks.start; + yield* logBootstrapInfo("bootstrap deep links ready"); }).pipe(Effect.withSpan("desktop.bootstrap")); const startup = Effect.gen(function* () { diff --git a/apps/desktop/src/app/DesktopAppIdentity.test.ts b/apps/desktop/src/app/DesktopAppIdentity.test.ts index 71bcf5f7aef1..07d8147b2822 100644 --- a/apps/desktop/src/app/DesktopAppIdentity.test.ts +++ b/apps/desktop/src/app/DesktopAppIdentity.test.ts @@ -56,6 +56,7 @@ const makeElectronAppLayer = (calls: ElectronAppCalls) => calls.setAboutPanelOptions.push(options); }), setAppUserModelId: () => Effect.void, + requestSingleInstanceLock: Effect.succeed(true), getAppMetrics: Effect.succeed([]), isDefaultProtocolClient: () => Effect.succeed(false), setAsDefaultProtocolClient: () => Effect.succeed(true), diff --git a/apps/desktop/src/app/DesktopClerk.test.ts b/apps/desktop/src/app/DesktopClerk.test.ts index 1641149e9e35..a33ad6f9d795 100644 --- a/apps/desktop/src/app/DesktopClerk.test.ts +++ b/apps/desktop/src/app/DesktopClerk.test.ts @@ -2,6 +2,7 @@ import { assert, describe, it } from "@effect/vitest"; import * as Cause from "effect/Cause"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; import { beforeEach, vi } from "vite-plus/test"; const { createClerkBridgeMock, storageAdapter, storageMock } = vi.hoisted(() => ({ @@ -22,38 +23,20 @@ vi.mock("@clerk/electron/storage", () => ({ storage: storageMock, })); -import * as Exit from "effect/Exit"; -import * as FileSystem from "effect/FileSystem"; import * as ElectronApp from "../electron/ElectronApp.ts"; -import * as ElectronWindow from "../electron/ElectronWindow.ts"; import * as DesktopClerk from "./DesktopClerk.ts"; +import * as DesktopDeepLinks from "./DesktopDeepLinks.ts"; import * as DesktopEnvironment from "./DesktopEnvironment.ts"; -const makeDesktopClerkLayer = (isDevelopment = true, events: string[] = []) => { +const makeDesktopClerkLayer = (isDevelopment = true, isPackaged = false) => { const environment = DesktopEnvironment.DesktopEnvironment.of({ stateDir: "/tmp/t3-state", isDevelopment, - appDataDirectory: "/tmp/app-data", - userDataDirName: isDevelopment ? "t3code-dev" : "t3code", - legacyUserDataDirName: isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)", - path: { join: (...parts: ReadonlyArray) => parts.join("/") }, + isPackaged, } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]); - const electronApp = { - setPath: (name: string, value: string) => - Effect.sync(() => { - events.push(`setPath:${name}:${value}`); - }), - } as unknown as ElectronApp.ElectronApp["Service"]; - return DesktopClerk.layer.pipe( - Layer.provide( - Layer.mergeAll( - Layer.succeed(DesktopEnvironment.DesktopEnvironment, environment), - Layer.succeed(ElectronApp.ElectronApp, electronApp), - FileSystem.layerNoop({ exists: () => Effect.succeed(false) }), - ), - ), + Layer.provide(Layer.succeed(DesktopEnvironment.DesktopEnvironment, environment)), ); }; @@ -63,17 +46,24 @@ describe("DesktopClerk", () => { storageMock.mockReset(); }); + it("derives the Clerk Frontend API hostname used by the desktop CSP", () => { + const publishableKey = `pk_test_${btoa("clerk.t3.codes$")}`; + + assert.equal( + DesktopClerk.resolveDesktopClerkFrontendApiHostname(publishableKey), + "clerk.t3.codes", + ); + assert.equal(DesktopClerk.resolveDesktopClerkFrontendApiHostname(""), undefined); + assert.equal(DesktopClerk.resolveDesktopClerkFrontendApiHostname("invalid"), undefined); + }); + it.effect("acquires and releases the SDK bridge with the layer", () => { const cleanup = vi.fn(); - const events: string[] = []; storageMock.mockReturnValue(storageAdapter); - createClerkBridgeMock.mockImplementation(() => { - events.push("createClerkBridge"); - return { cleanup, isPrimaryInstance: true }; - }); + createClerkBridgeMock.mockReturnValue({ cleanup, isPrimaryInstance: true }); return Effect.gen(function* () { - yield* Effect.scoped(Layer.build(makeDesktopClerkLayer(true, events))); + yield* Effect.scoped(Layer.build(makeDesktopClerkLayer())); assert.deepEqual(createClerkBridgeMock.mock.calls, [ [ @@ -85,10 +75,6 @@ describe("DesktopClerk", () => { ], ]); assert.equal(cleanup.mock.calls.length, 1); - // The bridge acquires Electron's single-instance lock at creation, and - // the lock both lives in and creates the userData directory — so the - // real path must be set before the bridge exists. - assert.deepEqual(events, ["setPath:userData:/tmp/app-data/t3code-dev", "createClerkBridge"]); storageMock.mockClear(); createClerkBridgeMock.mockClear(); }); @@ -122,6 +108,7 @@ describe("DesktopClerk", () => { cleanup: () => { throw cause; }, + isPrimaryInstance: true, }); return Effect.gen(function* () { @@ -142,59 +129,176 @@ describe("DesktopClerk", () => { }); }); - it.effect("registers the second-instance handler in the primary instance", () => { + for (const { isDevelopment, scheme } of [ + { isDevelopment: true, scheme: "t3code-dev" }, + { isDevelopment: false, scheme: "t3code" }, + ] as const) { + it.effect(`configures the SDK with the ${scheme} renderer origin`, () => { + const bridge = { cleanup: vi.fn(), isPrimaryInstance: true }; + storageMock.mockReturnValue(storageAdapter); + createClerkBridgeMock.mockReturnValue(bridge); + + return Effect.gen(function* () { + yield* Effect.scoped(Layer.build(makeDesktopClerkLayer(isDevelopment))); + assert.deepEqual(storageMock.mock.calls, [[{ path: "/tmp/t3-state" }]]); + assert.deepEqual(createClerkBridgeMock.mock.calls, [ + [ + { + storage: storageAdapter, + passkeys: true, + renderer: { scheme, host: "app" }, + }, + ], + ]); + storageMock.mockClear(); + createClerkBridgeMock.mockClear(); + }); + }); + } + + it.effect( + "wires second-instance argv into deep links and registers the protocol when packaged", + () => { + storageMock.mockReturnValue(storageAdapter); + createClerkBridgeMock.mockReturnValue({ cleanup: vi.fn(), isPrimaryInstance: true }); + + return Effect.gen(function* () { + const handledArgv = yield* Ref.make>([]); + const handledUrls = yield* Ref.make([]); + const listeners = new Map void>(); + let protocolClientRegistered = false; + + const deepLinksLayer = Layer.succeed(DesktopDeepLinks.DesktopDeepLinks, { + handleArgv: (argv) => + Ref.update(handledArgv, (items) => [...items, argv]).pipe(Effect.asVoid), + handleUrl: (url) => + Ref.update(handledUrls, (items) => [...items, url]).pipe(Effect.asVoid), + start: Effect.void, + } satisfies DesktopDeepLinks.DesktopDeepLinks["Service"]); + + const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, { + metadata: Effect.die("unexpected metadata"), + name: Effect.succeed("T3 Code"), + whenReady: Effect.void, + quit: Effect.void, + exit: () => Effect.void, + relaunch: () => Effect.void, + setPath: () => Effect.void, + setName: () => Effect.void, + setAboutPanelOptions: () => Effect.void, + setAppUserModelId: () => Effect.void, + requestSingleInstanceLock: Effect.succeed(true), + isDefaultProtocolClient: () => Effect.succeed(false), + setAsDefaultProtocolClient: (protocol: string) => + Effect.sync(() => { + protocolClientRegistered = protocol === "t3code"; + return true; + }), + setDesktopName: () => Effect.void, + setDockIcon: () => Effect.void, + appendCommandLineSwitch: () => Effect.void, + on: >( + eventName: string, + listener: (...args: Args) => void, + ) => + Effect.sync(() => { + listeners.set(eventName, listener as (...args: readonly unknown[]) => void); + }).pipe(Effect.asVoid), + } as unknown as ElectronApp.ElectronApp["Service"]); + + const runtimeLayer = Layer.mergeAll( + makeDesktopClerkLayer(false, true), + deepLinksLayer, + electronAppLayer, + ); + + yield* Effect.scoped( + Effect.gen(function* () { + const clerk = yield* DesktopClerk.DesktopClerk; + yield* clerk.configure; + + assert.isTrue(protocolClientRegistered); + assert.isTrue(listeners.has("second-instance")); + assert.isTrue(listeners.has("open-url")); + + // Initial process.argv is captured during configure. + const initialHandled = yield* Ref.get(handledArgv); + assert.isTrue(initialHandled.length >= 1); + + const secondInstance = listeners.get("second-instance"); + assert.isDefined(secondInstance); + secondInstance?.({}, [ + "t3code", + "t3code://open/thread?connection=t3vm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + ]); + // Allow the fire-and-forget runPromise callback to settle. + yield* Effect.yieldNow; + yield* Effect.yieldNow; + + const afterSecond = yield* Ref.get(handledArgv); + assert.isTrue( + afterSecond.some((argv) => + argv.some((entry) => entry.startsWith("t3code://open/thread")), + ), + ); + + const openUrl = listeners.get("open-url"); + assert.isDefined(openUrl); + const preventDefault = vi.fn(); + openUrl?.( + { preventDefault }, + "t3code://open/thread?connection=t3vm&thread=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", + ); + yield* Effect.yieldNow; + yield* Effect.yieldNow; + assert.equal(preventDefault.mock.calls.length, 1); + const urls = yield* Ref.get(handledUrls); + assert.deepEqual(urls, [ + "t3code://open/thread?connection=t3vm&thread=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", + ]); + }).pipe(Effect.provide(runtimeLayer)), + ); + }); + }, + ); + + it.effect("does not register the OS protocol client in development", () => { storageMock.mockReturnValue(storageAdapter); createClerkBridgeMock.mockReturnValue({ cleanup: vi.fn(), isPrimaryInstance: true }); - const quit = vi.fn(); - const registeredEvents: string[] = []; - const electronApp = { - quit: Effect.sync(quit), - on: (eventName: string) => - Effect.sync(() => { - registeredEvents.push(eventName); - }), - } as unknown as ElectronApp.ElectronApp["Service"]; - const electronWindow = {} as ElectronWindow.ElectronWindow["Service"]; return Effect.gen(function* () { - const clerk = yield* DesktopClerk.DesktopClerk; - const exit = yield* Effect.exit(Effect.scoped(clerk.configure)); - - assert.isTrue(Exit.isSuccess(exit)); - assert.equal(quit.mock.calls.length, 0); - assert.deepEqual(registeredEvents, ["second-instance"]); - }).pipe( - Effect.provide(makeDesktopClerkLayer()), - Effect.provideService(ElectronApp.ElectronApp, electronApp), - Effect.provideService(ElectronWindow.ElectronWindow, electronWindow), - ); - }); + let protocolClientRegistered = false; - it.effect("quits and interrupts startup in a secondary instance", () => { - storageMock.mockReturnValue(storageAdapter); - createClerkBridgeMock.mockReturnValue({ cleanup: vi.fn(), isPrimaryInstance: false }); - const quit = vi.fn(); - const registeredEvents: string[] = []; - const electronApp = { - quit: Effect.sync(quit), - on: (eventName: string) => - Effect.sync(() => { - registeredEvents.push(eventName); - }), - } as unknown as ElectronApp.ElectronApp["Service"]; - const electronWindow = {} as ElectronWindow.ElectronWindow["Service"]; + const deepLinksLayer = Layer.succeed(DesktopDeepLinks.DesktopDeepLinks, { + handleArgv: () => Effect.void, + handleUrl: () => Effect.void, + start: Effect.void, + } satisfies DesktopDeepLinks.DesktopDeepLinks["Service"]); - return Effect.gen(function* () { - const clerk = yield* DesktopClerk.DesktopClerk; - const exit = yield* Effect.exit(Effect.scoped(clerk.configure)); - - assert.isTrue(Exit.hasInterrupts(exit)); - assert.equal(quit.mock.calls.length, 1); - assert.deepEqual(registeredEvents, []); - }).pipe( - Effect.provide(makeDesktopClerkLayer()), - Effect.provideService(ElectronApp.ElectronApp, electronApp), - Effect.provideService(ElectronWindow.ElectronWindow, electronWindow), - ); + const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, { + requestSingleInstanceLock: Effect.succeed(true), + setAsDefaultProtocolClient: () => + Effect.sync(() => { + protocolClientRegistered = true; + return true; + }), + on: () => Effect.void, + quit: Effect.void, + } as unknown as ElectronApp.ElectronApp["Service"]); + + const runtimeLayer = Layer.mergeAll( + makeDesktopClerkLayer(true, false), + deepLinksLayer, + electronAppLayer, + ); + + yield* Effect.scoped( + Effect.gen(function* () { + const clerk = yield* DesktopClerk.DesktopClerk; + yield* clerk.configure; + assert.isFalse(protocolClientRegistered); + }).pipe(Effect.provide(runtimeLayer)), + ); + }); }); }); diff --git a/apps/desktop/src/app/DesktopClerk.ts b/apps/desktop/src/app/DesktopClerk.ts index 072a1871d986..a7cbb014ea7a 100644 --- a/apps/desktop/src/app/DesktopClerk.ts +++ b/apps/desktop/src/app/DesktopClerk.ts @@ -3,15 +3,13 @@ import { storage } from "@clerk/electron/storage"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; -import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import * as Scope from "effect/Scope"; import { clerkFrontendApiHostnameFromPublishableKey } from "@t3tools/shared/relayAuth"; import * as ElectronApp from "../electron/ElectronApp.ts"; import * as ElectronProtocol from "../electron/ElectronProtocol.ts"; -import * as ElectronWindow from "../electron/ElectronWindow.ts"; -import * as DesktopAppIdentity from "./DesktopAppIdentity.ts"; +import * as DesktopDeepLinks from "./DesktopDeepLinks.ts"; import * as DesktopEnvironment from "./DesktopEnvironment.ts"; declare const __T3CODE_BUILD_CLERK_PUBLISHABLE_KEY__: string | undefined; @@ -48,12 +46,12 @@ export class DesktopClerk extends Context.Service< readonly configure: Effect.Effect< void, never, - ElectronApp.ElectronApp | ElectronWindow.ElectronWindow | Scope.Scope + DesktopDeepLinks.DesktopDeepLinks | ElectronApp.ElectronApp | Scope.Scope >; } >()("@t3tools/desktop/app/DesktopClerk") {} -function resolveDesktopClerkFrontendApiHostname( +export function resolveDesktopClerkFrontendApiHostname( publishableKey: string | undefined, ): string | undefined { const normalizedKey = publishableKey?.trim(); @@ -86,17 +84,6 @@ function createDesktopClerkBridge(stateDir: string, isDevelopment: boolean) { /** @public Service construction is part of the canonical Effect module API. */ export const make = Effect.gen(function* () { const environment = yield* DesktopEnvironment.DesktopEnvironment; - const electronApp = yield* ElectronApp.ElectronApp; - - // Electron scopes the single-instance lock to the userData directory and - // creates that directory when the lock is acquired. The SDK bridge takes - // the lock at creation, so userData must already point at the real - // directory here — under the default productName-derived path, acquiring - // the lock would create "T3 Code (Alpha)" and make the legacy-install - // detection in resolveUserDataPath match on fresh installs. - const userDataPath = yield* DesktopAppIdentity.resolveUserDataPath; - yield* electronApp.setPath("userData", userDataPath); - const bridge = yield* Effect.acquireRelease( Effect.try({ try: () => createDesktopClerkBridge(environment.stateDir, environment.isDevelopment), @@ -122,8 +109,9 @@ export const make = Effect.gen(function* () { return DesktopClerk.of({ configure: Effect.gen(function* () { const electronApp = yield* ElectronApp.ElectronApp; - const electronWindow = yield* ElectronWindow.ElectronWindow; - const context = yield* Effect.context(); + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + // Capture ambient services for Electron event callbacks, which cannot yield. + const context = yield* Effect.context(); const runPromise = Effect.runPromiseWith(context); // The SDK bridge holds Electron's single-instance lock (acquired at @@ -131,21 +119,32 @@ export const make = Effect.gen(function* () { // forwarded to the running app. In a secondary instance the bridge has // already begun quitting the app; app.quit() is asynchronous, so stop // bootstrap here before whenReady can fire. - if (!bridge.isPrimaryInstance) { + if (!(bridge as { readonly isPrimaryInstance?: boolean }).isPrimaryInstance) { yield* electronApp.quit; return yield* Effect.interrupt; } - yield* electronApp.on("second-instance", () => { - void runPromise( - Effect.gen(function* () { - const mainWindow = yield* electronWindow.currentMainOrFirst; - if (Option.isSome(mainWindow)) { - yield* electronWindow.reveal(mainWindow.value); - } - }), - ); + // Register before readiness so cold-start and second-instance deep links + // are not dropped. Deep-link processing itself queues until start(). + yield* electronApp.on("second-instance", (_event: unknown, argv: readonly string[] = []) => { + void runPromise(deepLinks.handleArgv(argv)); + }); + + // macOS delivers custom URL scheme activations through open-url. + yield* electronApp.on("open-url", (event: { preventDefault?: () => void }, url: string) => { + event.preventDefault?.(); + void runPromise(deepLinks.handleUrl(url)); }); + + // Packaged builds own the OS protocol handler. Skip in development so a + // local electron binary does not replace the installed t3code handler. + if (environment.isPackaged && !environment.isDevelopment) { + yield* electronApp.setAsDefaultProtocolClient(DesktopDeepLinks.DESKTOP_EXTERNAL_PROTOCOL); + } + + // Initial argv may already contain a deep link (direct CLI invocation or + // protocol launch on Linux/Windows). + yield* deepLinks.handleArgv(process.argv); }).pipe(Effect.withSpan("desktop.clerk.configure")), }); }); diff --git a/apps/desktop/src/app/DesktopDeepLinks.test.ts b/apps/desktop/src/app/DesktopDeepLinks.test.ts new file mode 100644 index 000000000000..d96d3b4619c0 --- /dev/null +++ b/apps/desktop/src/app/DesktopDeepLinks.test.ts @@ -0,0 +1,363 @@ +import { assert, describe, it } from "@effect/vitest"; +import { EnvironmentId, ThreadId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; + +import * as DesktopWindow from "../window/DesktopWindow.ts"; +import * as DesktopConnectionCatalogStore from "./DesktopConnectionCatalogStore.ts"; +import * as DesktopDeepLinks from "./DesktopDeepLinks.ts"; + +const THREAD_ID = ThreadId.make("ebf3a84d-7f60-4809-a5e0-bbd574275463"); +const ENVIRONMENT_ID = EnvironmentId.make("db6d1813-ace4-42bd-9bce-e04ee27e97ff"); +const VALID_DEEP_LINK = + "t3code://open/thread?connection=t3vm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463"; + +function catalogJson(targets: readonly { label: string; environmentId: string }[]): string { + return JSON.stringify({ + schemaVersion: 1, + targets: targets.map((target) => ({ + _tag: "BearerConnectionTarget", + environmentId: target.environmentId, + label: target.label, + connectionId: `bearer:${target.environmentId}`, + })), + profiles: [], + credentials: [], + remoteDpopTokens: [], + }); +} + +describe("DesktopDeepLinks parsing", () => { + it("parses a valid thread deep link from mixed argv", () => { + const parsed = DesktopDeepLinks.findDesktopThreadDeepLinkInArgv([ + "/usr/bin/t3code", + "--enable-features=Foo", + VALID_DEEP_LINK, + "--some-flag", + ]); + assert.isTrue(Option.isSome(parsed)); + assert.equal(parsed._tag === "Some" ? parsed.value.connectionLabel : null, "t3vm"); + assert.equal( + parsed._tag === "Some" ? parsed.value.threadId : null, + "ebf3a84d-7f60-4809-a5e0-bbd574275463", + ); + }); + + it("percent-decodes the connection label exactly once", () => { + const parsed = DesktopDeepLinks.parseDesktopThreadDeepLink( + "t3code://open/thread?connection=t3%2Fvm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + ); + assert.isTrue(Option.isSome(parsed)); + assert.equal(parsed._tag === "Some" ? parsed.value.connectionLabel : null, "t3/vm"); + }); + + it("parses project jumps with short or full repository names", () => { + const latest = DesktopDeepLinks.parseDesktopProjectDeepLink( + "t3code://open/project?project=macs-holding%2Fscanner&action=latest", + ); + assert.deepEqual(Option.getOrNull(latest), { + project: "macs-holding/scanner", + action: "latest", + }); + const reveal = DesktopDeepLinks.parseDesktopProjectDeepLink( + "t3code://open/project?project=scanner", + ); + assert.deepEqual(Option.getOrNull(reveal), { project: "scanner", action: "reveal" }); + }); + + it("rejects invalid project jump actions and duplicate project values", () => { + assert.isTrue( + Option.isNone( + DesktopDeepLinks.parseDesktopProjectDeepLink( + "t3code://open/project?project=scanner&action=remove", + ), + ), + ); + assert.isTrue( + Option.isNone( + DesktopDeepLinks.parseDesktopProjectDeepLink( + "t3code://open/project?project=scanner&project=configurator", + ), + ), + ); + }); + + it("parses URL-like environment hosts in short and FQDN forms", () => { + for (const [raw, expectedLabel] of [ + ["t3code://t3vm?thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", "t3vm"], + ["t3code://t3vm.long.host?thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", "t3vm.long.host"], + ] as const) { + const parsed = DesktopDeepLinks.parseDesktopThreadDeepLink(raw); + assert.isTrue(Option.isSome(parsed)); + assert.equal(parsed._tag === "Some" ? parsed.value.connectionLabel : null, expectedLabel); + } + }); + + it("rejects wrong schemes, hosts, paths, missing/duplicate values, controls, and oversized values", () => { + const rejects = [ + "https://open/thread?connection=t3vm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://close/thread?connection=t3vm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://open/settings?connection=t3vm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://open/thread?thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://open/thread?connection=t3vm", + "t3code://open/thread?connection=t3vm&connection=other&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://open/thread?connection=t3vm&thread=a&thread=b", + "t3code://t3vm?connection=other&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://t3vm/path?thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + "t3code://open/thread?connection=t3vm&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463\u0000", + `t3code://open/thread?connection=${"x".repeat(300)}&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463`, + "not-a-url", + "t3code://app/", + ]; + for (const raw of rejects) { + assert.isTrue( + Option.isNone(DesktopDeepLinks.parseDesktopThreadDeepLink(raw)), + `expected rejection for ${JSON.stringify(raw)}`, + ); + } + }); + + it("builds a hash-history navigation URL on the desktop origin", () => { + assert.equal( + DesktopDeepLinks.buildDesktopThreadNavigationUrl({ + isDevelopment: false, + environmentId: ENVIRONMENT_ID, + threadId: THREAD_ID, + }), + "t3code://app/#/db6d1813-ace4-42bd-9bce-e04ee27e97ff/ebf3a84d-7f60-4809-a5e0-bbd574275463", + ); + assert.equal( + DesktopDeepLinks.buildDesktopThreadNavigationUrl({ + isDevelopment: true, + environmentId: ENVIRONMENT_ID, + threadId: THREAD_ID, + }), + "t3code-dev://app/#/db6d1813-ace4-42bd-9bce-e04ee27e97ff/ebf3a84d-7f60-4809-a5e0-bbd574275463", + ); + }); +}); + +describe("DesktopDeepLinks catalog resolution", () => { + it("resolves a unique connection label to its environment id", () => { + const resolution = DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel( + catalogJson([ + { label: "t3vm", environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff" }, + { label: "other", environmentId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }, + ]), + "t3vm", + ); + assert.equal(resolution._tag, "resolved"); + if (resolution._tag === "resolved") { + assert.equal(resolution.environmentId, "db6d1813-ace4-42bd-9bce-e04ee27e97ff"); + } + }); + + it("resolves short and fully qualified host labels in either direction", () => { + const fqdnTarget = DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel( + catalogJson([ + { label: "t3vm.long.host", environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff" }, + ]), + "t3vm", + ); + assert.equal(fqdnTarget._tag, "resolved"); + + const shortTarget = DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel( + catalogJson([{ label: "t3vm", environmentId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }]), + "t3vm.long.host", + ); + assert.equal(shortTarget._tag, "resolved"); + }); + + it("prefers an exact configured label over a short-host fallback", () => { + const resolution = DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel( + catalogJson([ + { label: "t3vm.long.host", environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff" }, + { label: "t3vm", environmentId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }, + ]), + "t3vm", + ); + assert.equal(resolution._tag, "resolved"); + if (resolution._tag === "resolved") { + assert.equal(resolution.environmentId, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"); + } + }); + + it("keeps ambiguous short matches ambiguous and does not equate distinct FQDNs", () => { + const catalog = catalogJson([ + { label: "t3vm.one.host", environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff" }, + { label: "t3vm.two.host", environmentId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }, + ]); + assert.equal( + DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel(catalog, "t3vm")._tag, + "ambiguous", + ); + assert.equal( + DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel(catalog, "t3vm.three.host")._tag, + "missing", + ); + }); + + it("refuses missing and duplicate labels", () => { + assert.equal( + DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel( + catalogJson([{ label: "other", environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff" }]), + "t3vm", + )._tag, + "missing", + ); + assert.equal( + DesktopDeepLinks.resolveEnvironmentIdForConnectionLabel( + catalogJson([ + { label: "t3vm", environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff" }, + { label: "t3vm", environmentId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }, + ]), + "t3vm", + )._tag, + "ambiguous", + ); + }); +}); + +describe("DesktopDeepLinks service delivery", () => { + const makeHarness = Effect.gen(function* () { + const navigations = yield* Ref.make>([]); + const projectNavigations = yield* Ref.make< + Array<{ project: string; action: "reveal" | "latest" | "new" }> + >([]); + const activations = yield* Ref.make(0); + const catalogJsonRef = yield* Ref.make( + Option.some( + catalogJson([ + { + label: "t3vm", + environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff", + }, + ]), + ), + ); + + const windowLayer = Layer.succeed(DesktopWindow.DesktopWindow, { + createMain: Effect.die("unexpected createMain"), + ensureMain: Effect.die("unexpected ensureMain"), + revealOrCreateMain: Effect.die("unexpected revealOrCreateMain"), + activate: Ref.update(activations, (count) => count + 1), + createMainIfBackendReady: Effect.void, + showConnectingSplash: Effect.void, + handleBackendReady: () => Effect.void, + handleBackendNotReady: Effect.void, + flushMainWindowBounds: Effect.void, + dispatchMenuAction: () => Effect.void, + syncAppearance: Effect.void, + navigateToThread: (input: { readonly environmentId: string; readonly threadId: string }) => + Ref.update(navigations, (items) => [ + ...items, + { environmentId: input.environmentId, threadId: input.threadId }, + ]), + navigateToProject: (input: { + readonly project: string; + readonly action: "reveal" | "latest" | "new"; + }) => Ref.update(projectNavigations, (items) => [...items, input]), + } as unknown as DesktopWindow.DesktopWindow["Service"]); + + const catalogLayer = Layer.succeed( + DesktopConnectionCatalogStore.DesktopConnectionCatalogStore, + { + get: Ref.get(catalogJsonRef), + set: () => Effect.succeed(true), + clear: Effect.void, + } satisfies DesktopConnectionCatalogStore.DesktopConnectionCatalogStore["Service"], + ); + + const layer = DesktopDeepLinks.layer.pipe( + Layer.provide(windowLayer), + Layer.provide(catalogLayer), + ); + + return { layer, navigations, projectNavigations, activations, catalogJsonRef } as const; + }); + + it.effect("queues initial-launch delivery until start, then opens the thread", () => + Effect.gen(function* () { + const harness = yield* makeHarness; + yield* Effect.gen(function* () { + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + yield* deepLinks.handleArgv(["t3code", VALID_DEEP_LINK]); + assert.deepEqual(yield* Ref.get(harness.navigations), []); + yield* deepLinks.start; + assert.deepEqual(yield* Ref.get(harness.navigations), [ + { + environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff", + threadId: "ebf3a84d-7f60-4809-a5e0-bbd574275463", + }, + ]); + }).pipe(Effect.provide(harness.layer)); + }), + ); + + it.effect("delivers running-instance deep links through handleArgv after start", () => + Effect.gen(function* () { + const harness = yield* makeHarness; + yield* Effect.gen(function* () { + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + yield* deepLinks.start; + yield* deepLinks.handleArgv([ + "t3code", + "t3code://open/thread?connection=t3vm&thread=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", + ]); + assert.deepEqual(yield* Ref.get(harness.navigations), [ + { + environmentId: "db6d1813-ace4-42bd-9bce-e04ee27e97ff", + threadId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", + }, + ]); + }).pipe(Effect.provide(harness.layer)); + }), + ); + + it.effect("delivers a project jump without resolving an environment in Desktop", () => + Effect.gen(function* () { + const harness = yield* makeHarness; + yield* Effect.gen(function* () { + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + yield* deepLinks.start; + yield* deepLinks.handleUrl( + "t3code://open/project?project=macs-holding%2Fscanner&action=new", + ); + assert.deepEqual(yield* Ref.get(harness.projectNavigations), [ + { project: "macs-holding/scanner", action: "new" }, + ]); + }).pipe(Effect.provide(harness.layer)); + }), + ); + + it.effect("preserves reveal-only behavior for ordinary second launches", () => + Effect.gen(function* () { + const harness = yield* makeHarness; + yield* Effect.gen(function* () { + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + yield* deepLinks.start; + yield* deepLinks.handleArgv(["t3code"]); + assert.equal(yield* Ref.get(harness.activations), 1); + assert.deepEqual(yield* Ref.get(harness.navigations), []); + }).pipe(Effect.provide(harness.layer)); + }), + ); + + it.effect("reveals without navigating when the connection label is missing", () => + Effect.gen(function* () { + const harness = yield* makeHarness; + yield* Effect.gen(function* () { + const deepLinks = yield* DesktopDeepLinks.DesktopDeepLinks; + yield* deepLinks.start; + yield* deepLinks.handleArgv([ + "t3code", + "t3code://open/thread?connection=missing&thread=ebf3a84d-7f60-4809-a5e0-bbd574275463", + ]); + assert.equal(yield* Ref.get(harness.activations), 1); + assert.deepEqual(yield* Ref.get(harness.navigations), []); + }).pipe(Effect.provide(harness.layer)); + }), + ); +}); diff --git a/apps/desktop/src/app/DesktopDeepLinks.ts b/apps/desktop/src/app/DesktopDeepLinks.ts new file mode 100644 index 000000000000..924ec93c355a --- /dev/null +++ b/apps/desktop/src/app/DesktopDeepLinks.ts @@ -0,0 +1,422 @@ +import { + ConnectionCatalogDocument, + type ConnectionCatalogDocument as ConnectionCatalogDocumentType, +} from "@t3tools/client-runtime/platform"; +import { EnvironmentId, ThreadId } from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; + +import { buildDesktopThreadNavigationUrl } from "../electron/ElectronProtocol.ts"; +import * as DesktopWindow from "../window/DesktopWindow.ts"; +import * as DesktopConnectionCatalogStore from "./DesktopConnectionCatalogStore.ts"; +import { makeComponentLogger } from "./DesktopObservability.ts"; + +export { buildDesktopThreadNavigationUrl }; + +export const DESKTOP_EXTERNAL_PROTOCOL = "t3code"; +export const DESKTOP_THREAD_DEEP_LINK_HOST = "open"; +export const DESKTOP_THREAD_DEEP_LINK_PATH = "/thread"; +export const DESKTOP_PROJECT_DEEP_LINK_PATH = "/project"; + +/** Reject oversized query values (connection labels and thread ids). */ +const MAX_DEEP_LINK_VALUE_LENGTH = 256; + +const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/; + +export type DesktopThreadDeepLink = { + readonly connectionLabel: string; + readonly threadId: ThreadId; +}; + +export type DesktopProjectDeepLink = { + readonly project: string; + readonly action: "reveal" | "latest" | "new"; +}; + +export type DesktopConnectionLabelResolution = + | { readonly _tag: "resolved"; readonly environmentId: EnvironmentId } + | { readonly _tag: "missing" } + | { readonly _tag: "ambiguous" } + | { readonly _tag: "invalidCatalog"; readonly cause: unknown }; + +type PendingDeepLinkAction = + | { readonly _tag: "reveal" } + | { readonly _tag: "openThread"; readonly deepLink: DesktopThreadDeepLink } + | { readonly _tag: "openProject"; readonly deepLink: DesktopProjectDeepLink }; + +const { logInfo: logDeepLinkInfo, logWarning: logDeepLinkWarning } = + makeComponentLogger("desktop-deep-links"); + +/** + * Parses a desktop thread deep link in either explicit or host shorthand form: + * + * - `t3code://open/thread?connection=&thread=` + * - `t3code://?thread=` + */ +export function parseDesktopThreadDeepLink(raw: string): Option.Option { + if (typeof raw !== "string" || raw.length === 0 || raw.length > 2_048) { + return Option.none(); + } + if (CONTROL_CHARACTER_PATTERN.test(raw)) { + return Option.none(); + } + + let url: URL; + try { + url = new URL(raw); + } catch { + return Option.none(); + } + + if (url.protocol !== `${DESKTOP_EXTERNAL_PROTOCOL}:`) { + return Option.none(); + } + // Normalize trailing slashes so `/thread` and `/thread/` both work. + const pathname = + url.pathname.length > 1 && url.pathname.endsWith("/") + ? url.pathname.slice(0, -1) + : url.pathname; + + const connectionValues = url.searchParams.getAll("connection"); + const threadValues = url.searchParams.getAll("thread"); + if (threadValues.length !== 1) { + return Option.none(); + } + + const isExplicitForm = + url.hostname === DESKTOP_THREAD_DEEP_LINK_HOST && pathname === DESKTOP_THREAD_DEEP_LINK_PATH; + const isHostShorthand = (pathname === "" || pathname === "/") && url.hostname.length > 0; + if ( + (!isExplicitForm && !isHostShorthand) || + (isExplicitForm && connectionValues.length !== 1) || + (isHostShorthand && connectionValues.length !== 0) + ) { + return Option.none(); + } + + // URLSearchParams percent-decodes once; reject empties, controls, and oversized values. + const connectionLabel = isExplicitForm ? (connectionValues[0] ?? "") : url.hostname; + const threadRaw = threadValues[0] ?? ""; + if ( + connectionLabel.length === 0 || + threadRaw.length === 0 || + connectionLabel.length > MAX_DEEP_LINK_VALUE_LENGTH || + threadRaw.length > MAX_DEEP_LINK_VALUE_LENGTH || + CONTROL_CHARACTER_PATTERN.test(connectionLabel) || + CONTROL_CHARACTER_PATTERN.test(threadRaw) + ) { + return Option.none(); + } + + let threadId: ThreadId; + try { + threadId = Schema.decodeUnknownSync(ThreadId)(threadRaw); + } catch { + return Option.none(); + } + + return Option.some({ + connectionLabel, + threadId, + }); +} + +export function parseDesktopProjectDeepLink(raw: string): Option.Option { + if (typeof raw !== "string" || raw.length === 0 || raw.length > 2_048) { + return Option.none(); + } + if (CONTROL_CHARACTER_PATTERN.test(raw)) { + return Option.none(); + } + + let url: URL; + try { + url = new URL(raw); + } catch { + return Option.none(); + } + + const pathname = + url.pathname.length > 1 && url.pathname.endsWith("/") + ? url.pathname.slice(0, -1) + : url.pathname; + if ( + url.protocol !== `${DESKTOP_EXTERNAL_PROTOCOL}:` || + url.hostname !== DESKTOP_THREAD_DEEP_LINK_HOST || + pathname !== DESKTOP_PROJECT_DEEP_LINK_PATH + ) { + return Option.none(); + } + + const projectValues = url.searchParams.getAll("project"); + const actionValues = url.searchParams.getAll("action"); + const project = projectValues[0]?.trim() ?? ""; + if ( + projectValues.length !== 1 || + actionValues.length > 1 || + project.length === 0 || + project.length > MAX_DEEP_LINK_VALUE_LENGTH || + CONTROL_CHARACTER_PATTERN.test(project) + ) { + return Option.none(); + } + + const action = actionValues[0] ?? "reveal"; + if (action !== "reveal" && action !== "latest" && action !== "new") { + return Option.none(); + } + return Option.some({ project, action }); +} + +/** + * Scans argv for the first valid thread deep link. Electron may inject + * platform-specific flags, so the URL is not assumed to be at a fixed index. + */ +export function findDesktopThreadDeepLinkInArgv( + argv: readonly string[], +): Option.Option { + for (const entry of argv) { + const parsed = parseDesktopThreadDeepLink(entry); + if (Option.isSome(parsed)) { + return parsed; + } + } + return Option.none(); +} + +function isShortAndFqdnMatch(left: string, right: string): boolean { + const leftIsFqdn = left.includes("."); + const rightIsFqdn = right.includes("."); + if (leftIsFqdn === rightIsFqdn) { + return false; + } + const shortLabel = leftIsFqdn ? right : left; + const fqdnLabel = leftIsFqdn ? left : right; + return fqdnLabel.slice(0, fqdnLabel.indexOf(".")) === shortLabel; +} + +/** + * Resolves a configured deep-link connection label to a unique environment id. + * + * The link producer's configured override is already represented by + * `connectionLabel`. Exact catalog labels win; only a missing exact match may + * fall back to matching a short host label with its FQDN form. + */ +export function resolveEnvironmentIdForConnectionLabel( + catalogJson: string, + connectionLabel: string, +): DesktopConnectionLabelResolution { + let document: ConnectionCatalogDocumentType; + try { + document = Schema.decodeUnknownSync(Schema.fromJsonString(ConnectionCatalogDocument))( + catalogJson, + ); + } catch (cause) { + return { _tag: "invalidCatalog", cause }; + } + + const exactMatches = document.targets.filter((target) => target.label === connectionLabel); + const matches = + exactMatches.length > 0 + ? exactMatches + : document.targets.filter((target) => isShortAndFqdnMatch(target.label, connectionLabel)); + if (matches.length === 0) { + return { _tag: "missing" }; + } + if (matches.length > 1) { + return { _tag: "ambiguous" }; + } + return { + _tag: "resolved", + environmentId: matches[0]!.environmentId, + }; +} + +export class DesktopDeepLinks extends Context.Service< + DesktopDeepLinks, + { + /** + * Handle a launch argv (initial process.argv or second-instance commandLine). + * Queues until `start` if the navigation services are not ready yet. + */ + readonly handleArgv: (argv: readonly string[]) => Effect.Effect; + /** + * Handle a macOS `open-url` deep link. + */ + readonly handleUrl: (url: string) => Effect.Effect; + /** + * Begin processing deep links. Flushes any action queued before readiness. + * Newest queued action wins. + */ + readonly start: Effect.Effect; + } +>()("@t3tools/desktop/app/DesktopDeepLinks") {} + +export const make = Effect.gen(function* () { + const desktopWindow = yield* DesktopWindow.DesktopWindow; + const catalogStore = yield* DesktopConnectionCatalogStore.DesktopConnectionCatalogStore; + const startedRef = yield* Ref.make(false); + const pendingActionRef = yield* Ref.make>(Option.none()); + + const revealOnly = desktopWindow.activate.pipe( + Effect.catch((error) => + logDeepLinkWarning("failed to reveal desktop window for deep link", { + message: error.message, + }), + ), + Effect.asVoid, + ); + + const resolveDeepLinkFromCatalog = ( + deepLink: DesktopThreadDeepLink, + ): Effect.Effect => + catalogStore.get.pipe( + Effect.catch((cause) => + logDeepLinkWarning("connection catalog unavailable for deep link resolution", { + reason: cause._tag, + }).pipe(Effect.as(Option.none())), + ), + Effect.map((catalog) => { + if (Option.isNone(catalog)) { + return { _tag: "missing" } as const; + } + return resolveEnvironmentIdForConnectionLabel(catalog.value, deepLink.connectionLabel); + }), + ); + + const openResolvedThread = (deepLink: DesktopThreadDeepLink): Effect.Effect => + Effect.gen(function* () { + const resolution = yield* resolveDeepLinkFromCatalog(deepLink); + switch (resolution._tag) { + case "resolved": { + yield* logDeepLinkInfo("opening thread from deep link", { + connectionLabel: deepLink.connectionLabel, + // Log only that an environment was resolved — never catalog contents. + resolved: true, + }); + yield* desktopWindow + .navigateToThread({ + environmentId: resolution.environmentId, + threadId: deepLink.threadId, + }) + .pipe( + Effect.catch((error) => + logDeepLinkWarning("failed to navigate to deep-linked thread", { + message: error.message, + }), + ), + ); + return; + } + case "missing": { + yield* logDeepLinkWarning("deep link connection label not found", { + connectionLabel: deepLink.connectionLabel, + }); + yield* revealOnly; + return; + } + case "ambiguous": { + yield* logDeepLinkWarning("deep link connection label is ambiguous", { + connectionLabel: deepLink.connectionLabel, + }); + yield* revealOnly; + return; + } + case "invalidCatalog": { + yield* logDeepLinkWarning("deep link connection catalog could not be decoded", { + reason: "invalidCatalog", + }); + yield* revealOnly; + return; + } + } + }).pipe(Effect.withSpan("desktop.deepLinks.openResolvedThread")); + + const processAction = (action: PendingDeepLinkAction): Effect.Effect => + Effect.gen(function* () { + switch (action._tag) { + case "reveal": + yield* revealOnly; + return; + case "openThread": + yield* openResolvedThread(action.deepLink); + return; + case "openProject": + yield* desktopWindow.navigateToProject(action.deepLink).pipe( + Effect.catch((error) => + logDeepLinkWarning("failed to navigate to deep-linked project", { + message: error.message, + }), + ), + ); + return; + } + }).pipe(Effect.withSpan("desktop.deepLinks.processAction")); + + const enqueueOrProcess = (action: PendingDeepLinkAction): Effect.Effect => + Effect.gen(function* () { + const started = yield* Ref.get(startedRef); + if (!started) { + // Newest action wins while startup is still settling. + yield* Ref.set(pendingActionRef, Option.some(action)); + return; + } + yield* processAction(action); + }); + + const handleArgv = (argv: readonly string[]): Effect.Effect => + Effect.gen(function* () { + for (const entry of argv) { + const projectDeepLink = parseDesktopProjectDeepLink(entry); + if (Option.isSome(projectDeepLink)) { + yield* enqueueOrProcess({ _tag: "openProject", deepLink: projectDeepLink.value }); + return; + } + } + const deepLink = findDesktopThreadDeepLinkInArgv(argv); + if (Option.isSome(deepLink)) { + yield* enqueueOrProcess({ _tag: "openThread", deepLink: deepLink.value }); + return; + } + yield* enqueueOrProcess({ _tag: "reveal" }); + }).pipe(Effect.withSpan("desktop.deepLinks.handleArgv")); + + const handleUrl = (url: string): Effect.Effect => + Effect.gen(function* () { + const projectDeepLink = parseDesktopProjectDeepLink(url); + if (Option.isSome(projectDeepLink)) { + yield* enqueueOrProcess({ _tag: "openProject", deepLink: projectDeepLink.value }); + return; + } + const deepLink = parseDesktopThreadDeepLink(url); + if (Option.isSome(deepLink)) { + yield* enqueueOrProcess({ _tag: "openThread", deepLink: deepLink.value }); + return; + } + yield* logDeepLinkWarning("ignored unsupported open-url payload"); + yield* enqueueOrProcess({ _tag: "reveal" }); + }).pipe(Effect.withSpan("desktop.deepLinks.handleUrl")); + + const start = Effect.gen(function* () { + const alreadyStarted = yield* Ref.getAndSet(startedRef, true); + if (alreadyStarted) { + return; + } + const pending = yield* Ref.getAndSet(pendingActionRef, Option.none()); + if (Option.isSome(pending)) { + yield* processAction(pending.value); + } + }).pipe(Effect.withSpan("desktop.deepLinks.start")); + + return DesktopDeepLinks.of({ + handleArgv, + handleUrl, + start, + }); +}); + +export const layer = Layer.effect(DesktopDeepLinks, make); diff --git a/apps/desktop/src/app/DesktopLifecycle.test.ts b/apps/desktop/src/app/DesktopLifecycle.test.ts index 515be6726c94..f266ae14a3a4 100644 --- a/apps/desktop/src/app/DesktopLifecycle.test.ts +++ b/apps/desktop/src/app/DesktopLifecycle.test.ts @@ -42,6 +42,7 @@ function makeElectronAppLayer( setName: () => Effect.void, setAboutPanelOptions: () => Effect.void, setAppUserModelId: () => Effect.void, + requestSingleInstanceLock: Effect.succeed(true), getAppMetrics: Effect.succeed([]), isDefaultProtocolClient: () => Effect.succeed(false), setAsDefaultProtocolClient: () => Effect.succeed(true), @@ -98,6 +99,8 @@ function makeDesktopWindowLayer( dispatchSnapShotEvent: () => Effect.void, zoomMain: () => Effect.void, syncAppearance: Effect.void, + navigateToThread: () => Effect.void, + navigateToProject: () => Effect.void, }); } diff --git a/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts b/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts index f0b88101587c..55f07351ba68 100644 --- a/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts +++ b/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts @@ -127,6 +127,16 @@ describe("DesktopLinuxUrlHandler", () => { assert.include(entry, "MimeType=x-scheme-handler/t3code;"); }); + it("leaves safe executable paths unquoted for generic xdg-open compatibility", () => { + const entry = DesktopLinuxUrlHandler.renderUrlHandlerDesktopEntry({ + displayName: "T3 Code (Alpha)", + execTarget: "/home/alice/Applications/T3-Code.AppImage", + scheme: "t3code", + }); + + assert.include(entry, "Exec=/home/alice/Applications/T3-Code.AppImage %U"); + }); + it("carries structured context on registration errors", () => { const writeError = new DesktopLinuxUrlHandler.DesktopLinuxUrlHandlerRegistrationError({ step: "write-desktop-entry", @@ -168,7 +178,7 @@ describe("DesktopLinuxUrlHandler", () => { ); assert.include( recorded.files[0]?.content, - 'Exec="/home/alice/Applications/T3-Code.AppImage" %U', + "Exec=/home/alice/Applications/T3-Code.AppImage %U", ); assert.include(recorded.files[0]?.content, "MimeType=x-scheme-handler/t3code;"); assert.deepEqual(recorded.commands, [ @@ -188,7 +198,7 @@ describe("DesktopLinuxUrlHandler", () => { assert.include( recorded.files[0]?.content, - `Exec=${DesktopLinuxUrlHandler.escapeDesktopEntryExecArgument(process.execPath)} %U`, + `Exec=${DesktopLinuxUrlHandler.renderDesktopEntryExecArgument(process.execPath)} %U`, ); }); }); diff --git a/apps/desktop/src/app/DesktopLinuxUrlHandler.ts b/apps/desktop/src/app/DesktopLinuxUrlHandler.ts index 404aff34c6bf..539daab2aed3 100644 --- a/apps/desktop/src/app/DesktopLinuxUrlHandler.ts +++ b/apps/desktop/src/app/DesktopLinuxUrlHandler.ts @@ -63,6 +63,15 @@ export function escapeDesktopEntryExecArgument(value: string): string { return escapeDesktopEntryString(`"${quoted}"`); } +// xdg-utils' generic desktop backend extracts the first Exec word and passes it +// directly to `command -v`, without removing freedesktop quotes first. Prefer an +// unquoted executable when its path needs no escaping so custom schemes work on +// wlroots compositors such as niri. Keep spec-compliant quoting for paths that +// contain spaces or reserved characters. +export function renderDesktopEntryExecArgument(value: string): string { + return /^[A-Za-z0-9_@+=:,./-]+$/.test(value) ? value : escapeDesktopEntryExecArgument(value); +} + // The AppImage integration entry owns the window identity and icon. This // hidden URL-only entry must not compete with it for StartupWMClass matching. export function renderUrlHandlerDesktopEntry(input: { @@ -74,7 +83,7 @@ export function renderUrlHandlerDesktopEntry(input: { "[Desktop Entry]", "Type=Application", `Name=${escapeDesktopEntryString(input.displayName)}`, - `Exec=${escapeDesktopEntryExecArgument(input.execTarget)} %U`, + `Exec=${renderDesktopEntryExecArgument(input.execTarget)} %U`, "Terminal=false", "NoDisplay=true", "StartupNotify=false", diff --git a/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts b/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts index 9ddaf40caa0a..679ac7c7e1a1 100644 --- a/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts +++ b/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts @@ -102,7 +102,7 @@ describe("DesktopPreReadyPlatform", () => { ); const identity = yield* Effect.promise(() => portalIdentity); assert.equal(identity.desktopName, "com.t3tools.T3Code.desktop"); - assert.include(identity.desktopEntry ?? "", 'Exec="/Applications/current.AppImage" %U'); + assert.include(identity.desktopEntry ?? "", "Exec=/Applications/current.AppImage %U"); assert.include(identity.desktopEntry ?? "", "Name=T3 Code (Alpha)"); assert.include(identity.desktopEntry ?? "", "MimeType=x-scheme-handler/t3code;"); }), diff --git a/apps/desktop/src/backend/DesktopBackendConfiguration.ts b/apps/desktop/src/backend/DesktopBackendConfiguration.ts index d7c524d16815..5efb7bf7172c 100644 --- a/apps/desktop/src/backend/DesktopBackendConfiguration.ts +++ b/apps/desktop/src/backend/DesktopBackendConfiguration.ts @@ -1,6 +1,10 @@ +// @effect-diagnostics nodeBuiltinImport:off import * as NodeOS from "node:os"; import { parsePersistedServerObservabilitySettings } from "@t3tools/shared/serverSettings"; +import { LOCAL_BOOTSTRAP_CREDENTIAL_FILE } from "@t3tools/shared/serverRuntime"; +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; import * as Context from "effect/Context"; import * as Crypto from "effect/Crypto"; import * as Effect from "effect/Effect"; @@ -19,6 +23,7 @@ import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import * as DesktopServerExposure from "./DesktopServerExposure.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; import * as DesktopWslEnvironment from "../wsl/DesktopWslEnvironment.ts"; +import { readLiveExistingBackend } from "./DesktopExistingBackend.ts"; import * as DesktopWslServerTree from "../wsl/DesktopWslServerTree.ts"; export class DesktopBackendObservabilitySettingsReadError extends Schema.TaggedError()( @@ -210,6 +215,25 @@ interface SharedBootstrapInput { readonly observabilitySettings: BackendObservabilitySettings; } +function readLocalBootstrapCredential(path: string): string | undefined { + try { + const token = NodeFS.readFileSync(path, "utf8").trim(); + return token.length > 0 ? token : undefined; + } catch { + return undefined; + } +} + +function installLocalBootstrapCredential(path: string, token: string): string { + NodeFS.mkdirSync(NodePath.dirname(path), { recursive: true }); + try { + NodeFS.writeFileSync(path, `${token}\n`, { mode: 0o600, flag: "wx" }); + return token; + } catch { + return NodeFS.readFileSync(path, "utf8").trim(); + } +} + interface WslPreflightSuccess { readonly _tag: "Ready"; readonly runningDistro: string; @@ -480,6 +504,7 @@ const resolvePrimaryStartConfig = Effect.fn("desktop.backendConfiguration.resolv const environment = yield* DesktopEnvironment.DesktopEnvironment; const serverExposure = yield* DesktopServerExposure.DesktopServerExposure; const backendExposure = yield* serverExposure.backendConfig; + const existingBackend = readLiveExistingBackend(environment.stateDir); const bootstrap = { mode: "desktop" as const, @@ -512,9 +537,12 @@ const resolvePrimaryStartConfig = Effect.fn("desktop.backendConfiguration.resolv extendEnv: true, bootstrap, bootstrapDelivery: "fd3", - httpBaseUrl: backendExposure.httpBaseUrl, + httpBaseUrl: existingBackend + ? new URL(existingBackend.httpBaseUrl) + : backendExposure.httpBaseUrl, captureOutput: true, preflightFailure: Option.none(), + ...(existingBackend ? { reuseExisting: true } : {}), } satisfies DesktopBackendManager.DesktopBackendStartConfig; }, ); @@ -758,12 +786,17 @@ export const make = Effect.gen(function* () { Option.match(current, { onSome: (token) => Effect.succeed([token, current] as const), onNone: () => - crypto.randomBytes(24).pipe( - Effect.map((bytes) => { - const token = Encoding.encodeHex(bytes); - return [token, Option.some(token)] as const; - }), - ), + Effect.gen(function* () { + const credentialPath = NodePath.join( + environment.stateDir, + LOCAL_BOOTSTRAP_CREDENTIAL_FILE, + ); + const persisted = readLocalBootstrapCredential(credentialPath); + if (persisted !== undefined) return [persisted, Option.some(persisted)] as const; + const token = Encoding.encodeHex(yield* crypto.randomBytes(24)); + const installed = installLocalBootstrapCredential(credentialPath, token); + return [installed, Option.some(installed)] as const; + }), }), ); diff --git a/apps/desktop/src/backend/DesktopBackendManager.test.ts b/apps/desktop/src/backend/DesktopBackendManager.test.ts index 53ccf5a756eb..6d5a85227a08 100644 --- a/apps/desktop/src/backend/DesktopBackendManager.test.ts +++ b/apps/desktop/src/backend/DesktopBackendManager.test.ts @@ -729,6 +729,35 @@ describe("DesktopBackendManager", () => { ), ); + it.effect("reuses a healthy existing backend without spawning or owning it", () => + Effect.scoped( + Effect.gen(function* () { + let spawnCount = 0; + const ready = yield* Deferred.make(); + const spawnerLayer = Layer.succeed( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make(() => { + spawnCount += 1; + return Effect.never; + }), + ); + const instance = yield* makeTestInstance({ + config: { ...baseConfig, reuseExisting: true }, + spawnerLayer, + onReady: Deferred.succeed(ready, undefined).pipe(Effect.asVoid), + }); + + yield* instance.start; + yield* Deferred.await(ready); + assert.equal(spawnCount, 0); + assert.equal((yield* instance.snapshot).ready, true); + + yield* instance.stop(); + assert.equal(spawnCount, 0); + }), + ), + ); + it.effect( "re-probes readiness after the first budget expires while the backend is still alive", () => diff --git a/apps/desktop/src/backend/DesktopBackendManager.ts b/apps/desktop/src/backend/DesktopBackendManager.ts index 6f1ea139bdca..e61719bbc4d3 100644 --- a/apps/desktop/src/backend/DesktopBackendManager.ts +++ b/apps/desktop/src/backend/DesktopBackendManager.ts @@ -25,6 +25,7 @@ import * as Brand from "effect/Brand"; import * as Cause from "effect/Cause"; +import * as Deferred from "effect/Deferred"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; @@ -97,6 +98,8 @@ export interface DesktopBackendStartConfig extends BackendProcessContext { readonly httpBaseUrl: URL; readonly captureOutput: boolean; readonly preflightFailure: Option.Option; + /** Connect to this already-running backend without owning or terminating its process. */ + readonly reuseExisting?: boolean; // Present for a WSL run after the configured/default distro has been // resolved to the concrete distro passed to wsl.exe. readonly runningDistro?: string; @@ -441,6 +444,32 @@ export const runBackendProcess = Effect.fn("runBackendProcess")(function* ( options: RunBackendProcessOptions, ): Effect.fn.Return { const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + if (options.reuseExisting) { + yield* waitForHttpReady({ + executablePath: options.executablePath, + entryPath: options.entryPath, + cwd: options.cwd, + httpBaseUrl: options.httpBaseUrl, + timeout: options.readinessTimeout ?? DEFAULT_BACKEND_READINESS_TIMEOUT, + }).pipe( + Effect.matchEffect({ + onFailure: (error) => options.onReadinessFailure?.(error) ?? Effect.void, + onSuccess: () => options.onReady?.() ?? Effect.void, + }), + ); + + // We do not own the reused backend process, so there is no child exit to + // await. Park until stop()/quit closes this run scope. Keeping the run + // active also prevents a later config resolve from falling back to the + // embedded backend if the external process disappears. + const released = yield* Deferred.make(); + yield* Effect.addFinalizer(() => Deferred.succeed(released, undefined)); + yield* Deferred.await(released); + return { + code: Option.none(), + reason: "reused backend released", + }; + } const bootstrapJson = yield* encodeBootstrapJson(options.bootstrap).pipe( Effect.mapError( (cause) => diff --git a/apps/desktop/src/backend/DesktopBackendPool.test.ts b/apps/desktop/src/backend/DesktopBackendPool.test.ts index b9a96d72a77a..b1a68326c68f 100644 --- a/apps/desktop/src/backend/DesktopBackendPool.test.ts +++ b/apps/desktop/src/backend/DesktopBackendPool.test.ts @@ -13,6 +13,7 @@ import * as DesktopObservability from "../app/DesktopObservability.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts"; import * as ElectronDialog from "../electron/ElectronDialog.ts"; +import * as MacApplicationIcon from "../electron/MacApplicationIcon.ts"; import * as DesktopWindow from "../window/DesktopWindow.ts"; import * as DesktopWslEnvironment from "../wsl/DesktopWslEnvironment.ts"; import * as DesktopBackendConfiguration from "./DesktopBackendConfiguration.ts"; @@ -85,7 +86,13 @@ function makePoolLayer( } satisfies DesktopBackendConfiguration.DesktopBackendConfiguration["Service"]), DesktopAppSettings.layerTest(), DesktopWslEnvironment.layerTest(), - ElectronDialog.layer, + ElectronDialog.layer.pipe( + Layer.provide( + Layer.succeed(MacApplicationIcon.MacApplicationIcon, { + resolveDataUrl: () => Effect.die("unexpected application icon resolution"), + } satisfies MacApplicationIcon.MacApplicationIcon["Service"]), + ), + ), Layer.succeed(DesktopWindow.DesktopWindow, { createMain: Effect.die("unexpected window create"), ensureMain: Effect.die("unexpected window ensure"), @@ -101,6 +108,8 @@ function makePoolLayer( dispatchSnapShotEvent: () => Effect.void, zoomMain: () => Effect.die("unexpected zoom"), syncAppearance: Effect.void, + navigateToThread: () => Effect.void, + navigateToProject: () => Effect.void, } satisfies DesktopWindow.DesktopWindow["Service"]), ), ), diff --git a/apps/desktop/src/backend/DesktopExistingBackend.ts b/apps/desktop/src/backend/DesktopExistingBackend.ts new file mode 100644 index 000000000000..2f479d653955 --- /dev/null +++ b/apps/desktop/src/backend/DesktopExistingBackend.ts @@ -0,0 +1,38 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; + +import { + SERVER_RUNTIME_DESCRIPTOR_FILE, + ServerRuntimeDescriptor, + type ServerRuntimeDescriptor as ServerRuntimeDescriptorValue, +} from "@t3tools/shared/serverRuntime"; +import * as Schema from "effect/Schema"; + +const decodeDescriptor = Schema.decodeUnknownExit(ServerRuntimeDescriptor); + +function processIsAlive(pid: number): boolean { + try { + process.kill(pid, 0); + return true; + } catch { + return false; + } +} + +export function readLiveExistingBackend( + stateDir: string, +): ServerRuntimeDescriptorValue | undefined { + try { + const path = NodePath.join(stateDir, SERVER_RUNTIME_DESCRIPTOR_FILE); + const decoded = decodeDescriptor(JSON.parse(NodeFS.readFileSync(path, "utf8"))); + if (decoded._tag === "Failure") return undefined; + if (NodePath.resolve(decoded.value.stateDir) !== NodePath.resolve(stateDir)) return undefined; + if (!processIsAlive(decoded.value.pid)) return undefined; + const url = new URL(decoded.value.httpBaseUrl); + if (url.protocol !== "http:" && url.protocol !== "https:") return undefined; + return decoded.value; + } catch { + return undefined; + } +} diff --git a/apps/desktop/src/electron/DesktopEarlyStartup.test.ts b/apps/desktop/src/electron/DesktopEarlyStartup.test.ts new file mode 100644 index 000000000000..56ccc2116f0a --- /dev/null +++ b/apps/desktop/src/electron/DesktopEarlyStartup.test.ts @@ -0,0 +1,53 @@ +import { assert, describe, it } from "@effect/vitest"; +import { vi } from "vite-plus/test"; + +import { + type DesktopEarlyStartupApp, + configureDesktopEarlyStartup, +} from "./DesktopEarlyStartup.ts"; + +function makeApp() { + const exit = vi.fn(); + const getVersion = vi.fn(() => "1.2.3"); + const app: DesktopEarlyStartupApp = { + exit, + getVersion, + }; + + return { app, exit, getVersion }; +} + +describe("configureDesktopEarlyStartup", () => { + it.each(["--version", "-v"] as const)( + "prints the packaged version for %s", + (flag: "--version" | "-v") => { + const { app, exit, getVersion } = makeApp(); + const writeStdout = vi.fn(); + + configureDesktopEarlyStartup({ + app, + argv: ["t3code", flag], + writeStdout, + }); + + assert.strictEqual(getVersion.mock.calls.length, 1); + assert.deepStrictEqual(writeStdout.mock.calls, [["1.2.3\n"]]); + assert.deepStrictEqual(exit.mock.calls, [[0]]); + }, + ); + + it("does nothing for an ordinary launch", () => { + const { app, exit, getVersion } = makeApp(); + const writeStdout = vi.fn(); + + configureDesktopEarlyStartup({ + app, + argv: ["t3code"], + writeStdout, + }); + + assert.strictEqual(getVersion.mock.calls.length, 0); + assert.strictEqual(writeStdout.mock.calls.length, 0); + assert.strictEqual(exit.mock.calls.length, 0); + }); +}); diff --git a/apps/desktop/src/electron/DesktopEarlyStartup.ts b/apps/desktop/src/electron/DesktopEarlyStartup.ts new file mode 100644 index 000000000000..b56ad1a91ea1 --- /dev/null +++ b/apps/desktop/src/electron/DesktopEarlyStartup.ts @@ -0,0 +1,27 @@ +export interface DesktopEarlyStartupApp { + readonly exit: (exitCode?: number) => void; + readonly getVersion: () => string; +} + +export interface ConfigureDesktopEarlyStartupOptions { + readonly app: DesktopEarlyStartupApp; + readonly argv: ReadonlyArray; + readonly writeStdout: (value: string) => unknown; +} + +/** + * Applies command-line behavior that Electron must receive before `app.whenReady()`. + */ +export function configureDesktopEarlyStartup({ + app, + argv, + writeStdout, +}: ConfigureDesktopEarlyStartupOptions): void { + if (argv.includes("--version") || argv.includes("-v")) { + try { + writeStdout(`${app.getVersion()}\n`); + } finally { + app.exit(0); + } + } +} diff --git a/apps/desktop/src/electron/ElectronApp.test.ts b/apps/desktop/src/electron/ElectronApp.test.ts index 4189ea793e2d..5d7f7458551f 100644 --- a/apps/desktop/src/electron/ElectronApp.test.ts +++ b/apps/desktop/src/electron/ElectronApp.test.ts @@ -16,6 +16,7 @@ const { relaunchMock, removeListenerMock, removeSwitchMock, + requestSingleInstanceLockMock, setAboutPanelOptionsMock, setAppUserModelIdMock, setAsDefaultProtocolClientMock, @@ -38,6 +39,7 @@ const { relaunchMock: vi.fn(), removeListenerMock: vi.fn(), removeSwitchMock: vi.fn(), + requestSingleInstanceLockMock: vi.fn(() => true), setAboutPanelOptionsMock: vi.fn(), setAppUserModelIdMock: vi.fn(), setAsDefaultProtocolClientMock: vi.fn(() => true), @@ -71,6 +73,7 @@ vi.mock("electron", () => ({ quit: quitMock, relaunch: relaunchMock, removeListener: removeListenerMock, + requestSingleInstanceLock: requestSingleInstanceLockMock, runningUnderARM64Translation: false, setAboutPanelOptions: setAboutPanelOptionsMock, setAsDefaultProtocolClient: setAsDefaultProtocolClientMock, @@ -96,6 +99,7 @@ describe("ElectronApp", () => { relaunchMock.mockClear(); removeListenerMock.mockClear(); removeSwitchMock.mockClear(); + requestSingleInstanceLockMock.mockClear(); setPathMock.mockClear(); }); diff --git a/apps/desktop/src/electron/ElectronApp.ts b/apps/desktop/src/electron/ElectronApp.ts index b54da535add0..a01a57c65867 100644 --- a/apps/desktop/src/electron/ElectronApp.ts +++ b/apps/desktop/src/electron/ElectronApp.ts @@ -63,6 +63,7 @@ export class ElectronApp extends Context.Service< options: Electron.AboutPanelOptionsOptions, ) => Effect.Effect; readonly setAppUserModelId: (id: string) => Effect.Effect; + readonly requestSingleInstanceLock: Effect.Effect; readonly getAppMetrics: Effect.Effect>; readonly isDefaultProtocolClient: (protocol: string) => Effect.Effect; readonly setAsDefaultProtocolClient: ( @@ -165,6 +166,7 @@ export const make = ElectronApp.of({ Effect.sync(() => { Electron.app.setAppUserModelId(id); }), + requestSingleInstanceLock: Effect.sync(() => Electron.app.requestSingleInstanceLock()), getAppMetrics: Effect.sync(() => Electron.app.getAppMetrics()), isDefaultProtocolClient: (protocol) => Effect.sync(() => Electron.app.isDefaultProtocolClient(protocol)), diff --git a/apps/desktop/src/electron/ElectronDialog.test.ts b/apps/desktop/src/electron/ElectronDialog.test.ts index 2ed5a1f2f913..8d27553dc9a8 100644 --- a/apps/desktop/src/electron/ElectronDialog.test.ts +++ b/apps/desktop/src/electron/ElectronDialog.test.ts @@ -1,17 +1,22 @@ import { assert, describe, it } from "@effect/vitest"; import * as Cause from "effect/Cause"; import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import type { BrowserWindow } from "electron"; import { beforeEach, vi } from "vite-plus/test"; import * as ElectronDialog from "./ElectronDialog.ts"; +import * as MacApplicationIcon from "./MacApplicationIcon.ts"; -const { showMessageBoxMock, showOpenDialogMock, showErrorBoxMock } = vi.hoisted(() => ({ - showMessageBoxMock: vi.fn(), - showOpenDialogMock: vi.fn(), - showErrorBoxMock: vi.fn(), -})); +const { showMessageBoxMock, showOpenDialogMock, showErrorBoxMock, resolveDataUrlMock } = vi.hoisted( + () => ({ + showMessageBoxMock: vi.fn(), + showOpenDialogMock: vi.fn(), + showErrorBoxMock: vi.fn(), + resolveDataUrlMock: vi.fn(), + }), +); vi.mock("electron", () => ({ dialog: { @@ -21,13 +26,79 @@ vi.mock("electron", () => ({ }, })); +const applicationIconLayer = Layer.succeed(MacApplicationIcon.MacApplicationIcon, { + resolveDataUrl: (applicationPath) => + Effect.tryPromise({ + try: () => resolveDataUrlMock(applicationPath), + catch: (cause) => + new MacApplicationIcon.MacApplicationIconResolutionError({ applicationPath, cause }), + }), +} satisfies MacApplicationIcon.MacApplicationIcon["Service"]); +const dialogLayer = ElectronDialog.layer.pipe(Layer.provide(applicationIconLayer)); + describe("ElectronDialog", () => { beforeEach(() => { showMessageBoxMock.mockReset(); showOpenDialogMock.mockReset(); showErrorBoxMock.mockReset(); + resolveDataUrlMock.mockReset(); }); + it.effect("selects a macOS application and resolves its system icon", () => + Effect.gen(function* () { + const owner = { id: 12 } as BrowserWindow; + showOpenDialogMock.mockResolvedValue({ + canceled: false, + filePaths: ["/Applications/Terminal.app"], + }); + resolveDataUrlMock.mockResolvedValue("data:image/png;base64,icon"); + const dialog = yield* ElectronDialog.ElectronDialog; + + const result = yield* dialog.pickApplication({ owner: Option.some(owner) }); + + assert.deepEqual(Option.getOrNull(result), { + applicationPath: "/Applications/Terminal.app", + suggestedName: "Terminal", + iconDataUrl: "data:image/png;base64,icon", + }); + assert.deepEqual(showOpenDialogMock.mock.calls[0], [ + owner, + { + defaultPath: "/Applications", + properties: ["openFile"], + filters: [{ name: "Applications", extensions: ["app"] }], + }, + ]); + assert.deepEqual(resolveDataUrlMock.mock.calls[0], ["/Applications/Terminal.app"]); + }).pipe(Effect.provide(dialogLayer)), + ); + + it.effect("returns none when application selection is cancelled", () => + Effect.gen(function* () { + showOpenDialogMock.mockResolvedValue({ canceled: true, filePaths: [] }); + const dialog = yield* ElectronDialog.ElectronDialog; + assert.isTrue(Option.isNone(yield* dialog.pickApplication({ owner: Option.none() }))); + assert.equal(resolveDataUrlMock.mock.calls.length, 0); + }).pipe(Effect.provide(dialogLayer)), + ); + + it.effect("keeps a valid selection when icon extraction fails", () => + Effect.gen(function* () { + showOpenDialogMock.mockResolvedValue({ + canceled: false, + filePaths: ["/Users/test/Applications/My Tool.app"], + }); + resolveDataUrlMock.mockRejectedValue(new Error("icon unavailable")); + const dialog = yield* ElectronDialog.ElectronDialog; + + assert.deepEqual(Option.getOrNull(yield* dialog.pickApplication({ owner: Option.none() })), { + applicationPath: "/Users/test/Applications/My Tool.app", + suggestedName: "My Tool", + iconDataUrl: null, + }); + }).pipe(Effect.provide(dialogLayer)), + ); + it.effect("preserves folder picker request context and cause", () => Effect.gen(function* () { const cause = new Error("folder picker failed"); @@ -49,7 +120,7 @@ describe("ElectronDialog", () => { assert.include(error.message, "window 7"); assert.include(error.message, "/workspace"); assert.notInclude(error.message, cause.message); - }).pipe(Effect.provide(ElectronDialog.layer)), + }).pipe(Effect.provide(dialogLayer)), ); it.effect("opens a single-file picker when multiple selections are disabled", () => @@ -77,7 +148,7 @@ describe("ElectronDialog", () => { }, ], ]); - }).pipe(Effect.provide(ElectronDialog.layer)), + }).pipe(Effect.provide(dialogLayer)), ); it.effect("preserves message box request context and cause", () => @@ -114,7 +185,7 @@ describe("ElectronDialog", () => { assert.notInclude(error.message, "Cancel"); assert.notInclude(error.message, "Discard"); assert.notInclude(error.message, cause.message); - }).pipe(Effect.provide(ElectronDialog.layer)), + }).pipe(Effect.provide(dialogLayer)), ); it.effect("preserves error box request context and cause in the defect", () => @@ -139,6 +210,6 @@ describe("ElectronDialog", () => { assert.notInclude(error.message, "Startup failed"); assert.notInclude(error.message, "Could not start."); assert.notInclude(error.message, cause.message); - }).pipe(Effect.provide(ElectronDialog.layer)), + }).pipe(Effect.provide(dialogLayer)), ); }); diff --git a/apps/desktop/src/electron/ElectronDialog.ts b/apps/desktop/src/electron/ElectronDialog.ts index 18280333754c..9349c2e0ac9d 100644 --- a/apps/desktop/src/electron/ElectronDialog.ts +++ b/apps/desktop/src/electron/ElectronDialog.ts @@ -1,10 +1,15 @@ +// @effect-diagnostics nodeBuiltinImport:off - Electron's native picker returns host paths. import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; +import * as NodePath from "node:path"; import * as Electron from "electron"; +import type { DesktopApplicationSelection } from "@t3tools/contracts"; + +import * as MacApplicationIcon from "./MacApplicationIcon.ts"; export class ElectronDialogPickFolderError extends Schema.TaggedError()( "ElectronDialogPickFolderError", @@ -21,6 +26,19 @@ export class ElectronDialogPickFolderError extends Schema.TaggedError()( + "ElectronDialogPickApplicationError", + { + ownerWindowId: Schema.NullOr(Schema.Number), + selectedPath: Schema.NullOr(Schema.String), + cause: Schema.Defect(), + }, +) { + override get message(): string { + return "Failed to select a macOS application."; + } +} + export class ElectronDialogPickFilesError extends Schema.TaggedError()( "ElectronDialogPickFilesError", { @@ -68,6 +86,7 @@ export class ElectronDialogShowErrorBoxError extends Schema.TaggedError; } +export interface ElectronDialogPickApplicationInput { + readonly owner: Option.Option; +} + export interface ElectronDialogPickFilesInput { readonly owner: Option.Option; readonly defaultPath: Option.Option; @@ -92,6 +115,12 @@ export class ElectronDialog extends Context.Service< readonly pickFolder: ( input: ElectronDialogPickFolderInput, ) => Effect.Effect, ElectronDialogPickFolderError>; + readonly pickApplication: ( + input: ElectronDialogPickApplicationInput, + ) => Effect.Effect< + Option.Option, + ElectronDialogPickApplicationError + >; readonly pickFiles: ( input: ElectronDialogPickFilesInput, ) => Effect.Effect; @@ -103,90 +132,141 @@ export class ElectronDialog extends Context.Service< >()("@t3tools/desktop/electron/ElectronDialog") {} /** @public Service construction is part of the canonical Effect module API. */ -export const make = ElectronDialog.of({ - pickFolder: Effect.fn("desktop.electron.dialog.pickFolder")(function* (input) { - const ownerWindowId = Option.match(input.owner, { - onNone: () => null, - onSome: (owner) => owner.id, - }); - const defaultPath = Option.getOrNull(input.defaultPath); - const openDialogOptions: Electron.OpenDialogOptions = Option.match(input.defaultPath, { - onNone: () => ({ - properties: ["openDirectory", "createDirectory"], - }), - onSome: (defaultPath) => ({ - properties: ["openDirectory", "createDirectory"], - defaultPath, - }), - }); - const result = yield* Effect.tryPromise({ - try: () => - Option.match(input.owner, { - onNone: () => Electron.dialog.showOpenDialog(openDialogOptions), - onSome: (owner) => Electron.dialog.showOpenDialog(owner, openDialogOptions), +export const make = Effect.gen(function* () { + const applicationIcon = yield* MacApplicationIcon.MacApplicationIcon; + + return ElectronDialog.of({ + pickFolder: Effect.fn("desktop.electron.dialog.pickFolder")(function* (input) { + const ownerWindowId = Option.match(input.owner, { + onNone: () => null, + onSome: (owner) => owner.id, + }); + const defaultPath = Option.getOrNull(input.defaultPath); + const openDialogOptions: Electron.OpenDialogOptions = Option.match(input.defaultPath, { + onNone: () => ({ + properties: ["openDirectory", "createDirectory"], }), - catch: (cause) => - new ElectronDialogPickFolderError({ - ownerWindowId, + onSome: (defaultPath) => ({ + properties: ["openDirectory", "createDirectory"], defaultPath, - cause, - }), - }); - - if (result.canceled) { - return Option.none(); - } - return Option.fromNullishOr(result.filePaths[0]); - }), - pickFiles: Effect.fn("desktop.electron.dialog.pickFiles")(function* (input) { - const ownerWindowId = Option.match(input.owner, { - onNone: () => null, - onSome: (owner) => owner.id, - }); - const defaultPath = Option.getOrNull(input.defaultPath); - const openDialogOptions: Electron.OpenDialogOptions = { - properties: input.multiple ? ["openFile", "multiSelections"] : ["openFile"], - filters: [...input.filters], - ...(defaultPath === null ? {} : { defaultPath }), - }; - const result = yield* Effect.tryPromise({ - try: () => - Option.match(input.owner, { - onNone: () => Electron.dialog.showOpenDialog(openDialogOptions), - onSome: (owner) => Electron.dialog.showOpenDialog(owner, openDialogOptions), }), - catch: (cause) => - new ElectronDialogPickFilesError({ + }); + const result = yield* Effect.tryPromise({ + try: () => + Option.match(input.owner, { + onNone: () => Electron.dialog.showOpenDialog(openDialogOptions), + onSome: (owner) => Electron.dialog.showOpenDialog(owner, openDialogOptions), + }), + catch: (cause) => + new ElectronDialogPickFolderError({ + ownerWindowId, + defaultPath, + cause, + }), + }); + + if (result.canceled) { + return Option.none(); + } + return Option.fromNullishOr(result.filePaths[0]); + }), + pickFiles: Effect.fn("desktop.electron.dialog.pickFiles")(function* (input) { + const ownerWindowId = Option.match(input.owner, { + onNone: () => null, + onSome: (owner) => owner.id, + }); + const defaultPath = Option.getOrNull(input.defaultPath); + const openDialogOptions: Electron.OpenDialogOptions = { + properties: input.multiple ? ["openFile", "multiSelections"] : ["openFile"], + filters: [...input.filters], + ...(defaultPath === null ? {} : { defaultPath }), + }; + const result = yield* Effect.tryPromise({ + try: () => + Option.match(input.owner, { + onNone: () => Electron.dialog.showOpenDialog(openDialogOptions), + onSome: (owner) => Electron.dialog.showOpenDialog(owner, openDialogOptions), + }), + catch: (cause) => + new ElectronDialogPickFilesError({ + ownerWindowId, + defaultPath, + cause, + }), + }); + return result.canceled ? [] : result.filePaths; + }), + pickApplication: Effect.fn("desktop.electron.dialog.pickApplication")(function* (input) { + const ownerWindowId = Option.match(input.owner, { + onNone: () => null, + onSome: (owner) => owner.id, + }); + const options: Electron.OpenDialogOptions = { + defaultPath: "/Applications", + properties: ["openFile"], + filters: [{ name: "Applications", extensions: ["app"] }], + }; + const result = yield* Effect.tryPromise({ + try: () => + Option.match(input.owner, { + onNone: () => Electron.dialog.showOpenDialog(options), + onSome: (owner) => Electron.dialog.showOpenDialog(owner, options), + }), + catch: (cause) => + new ElectronDialogPickApplicationError({ + ownerWindowId, + selectedPath: null, + cause, + }), + }); + if (result.canceled) return Option.none(); + + const applicationPath = result.filePaths[0]; + if ( + applicationPath === undefined || + !NodePath.isAbsolute(applicationPath) || + !applicationPath.toLowerCase().endsWith(".app") + ) { + return yield* new ElectronDialogPickApplicationError({ ownerWindowId, - defaultPath, - cause, - }), - }); - return result.canceled ? [] : result.filePaths; - }), - showMessageBox: (options) => - Effect.tryPromise({ - try: () => Electron.dialog.showMessageBox(options), - catch: (cause) => - new ElectronDialogShowMessageBoxError({ - type: options.type ?? null, - titleLength: options.title?.length ?? null, - messageLength: options.message.length, - detailLength: options.detail?.length ?? null, - buttonCount: options.buttons?.length ?? 0, - cause, - }), + selectedPath: applicationPath ?? null, + cause: new Error("The selected path is not an absolute .app bundle."), + }); + } + + const iconDataUrl = yield* applicationIcon + .resolveDataUrl(applicationPath) + .pipe(Effect.orElseSucceed(() => null)); + return Option.some({ + applicationPath, + suggestedName: NodePath.basename(applicationPath, NodePath.extname(applicationPath)), + iconDataUrl, + }); }), - showErrorBox: (title, content) => - Effect.try({ - try: () => Electron.dialog.showErrorBox(title, content), - catch: (cause) => - new ElectronDialogShowErrorBoxError({ - titleLength: title.length, - contentLength: content.length, - cause, - }), - }).pipe(Effect.orDie), + showMessageBox: (options) => + Effect.tryPromise({ + try: () => Electron.dialog.showMessageBox(options), + catch: (cause) => + new ElectronDialogShowMessageBoxError({ + type: options.type ?? null, + titleLength: options.title?.length ?? null, + messageLength: options.message.length, + detailLength: options.detail?.length ?? null, + buttonCount: options.buttons?.length ?? 0, + cause, + }), + }), + showErrorBox: (title, content) => + Effect.try({ + try: () => Electron.dialog.showErrorBox(title, content), + catch: (cause) => + new ElectronDialogShowErrorBoxError({ + titleLength: title.length, + contentLength: content.length, + cause, + }), + }).pipe(Effect.orDie), + }); }); -export const layer = Layer.succeed(ElectronDialog, make); +export const layer = Layer.effect(ElectronDialog, make); diff --git a/apps/desktop/src/electron/ElectronProtocol.test.ts b/apps/desktop/src/electron/ElectronProtocol.test.ts index a5c03e0b9336..2a917ce7fd2a 100644 --- a/apps/desktop/src/electron/ElectronProtocol.test.ts +++ b/apps/desktop/src/electron/ElectronProtocol.test.ts @@ -141,6 +141,35 @@ describe("ElectronProtocol", () => { }).pipe(Effect.provide(ElectronProtocol.layer)), ); + it.effect("retries empty-web 503/404 on the document shell", () => + Effect.gen(function* () { + let handler: ((request: Request) => Promise) | undefined; + handleMock.mockImplementation((_scheme, nextHandler) => { + handler = nextHandler; + }); + netFetchMock + .mockResolvedValueOnce(new Response("Web assets unavailable", { status: 503 })) + .mockResolvedValueOnce(new Response("ready", { status: 200 })); + + const response = yield* Effect.scoped( + Effect.gen(function* () { + const protocol = yield* ElectronProtocol.ElectronProtocol; + yield* protocol.registerDesktopProtocol({ + scheme: "t3code", + targetOrigin: new URL("http://127.0.0.1:3773/"), + backendOrigin: new URL("http://127.0.0.1:3773/"), + clerkFrontendApiHostname: undefined, + }); + return yield* Effect.promise(() => handler!(new Request("t3code://app/"))); + }), + ); + + assert.equal(response.status, 200); + assert.equal(yield* Effect.promise(() => response.text()), "ready"); + assert.equal(netFetchMock.mock.calls.length, 2); + }).pipe(Effect.provide(ElectronProtocol.layer)), + ); + it.effect("preserves protocol registration failures", () => Effect.gen(function* () { const cause = new Error("protocol registration failed"); diff --git a/apps/desktop/src/electron/ElectronProtocol.ts b/apps/desktop/src/electron/ElectronProtocol.ts index da8fcd3a2e4b..af352410c0f9 100644 --- a/apps/desktop/src/electron/ElectronProtocol.ts +++ b/apps/desktop/src/electron/ElectronProtocol.ts @@ -24,6 +24,34 @@ export function getDesktopUrl(isDevelopment: boolean): string { return `${getDesktopOrigin(isDevelopment)}/`; } +/** + * Builds the desktop renderer URL for a canonical thread route. + * + * The Electron client uses hash history, so the path is carried after `#/`. + */ +export function buildDesktopThreadNavigationUrl(input: { + readonly isDevelopment: boolean; + readonly environmentId: string; + readonly threadId: string; +}): string { + const origin = getDesktopOrigin(input.isDevelopment); + const environmentSegment = encodeURIComponent(input.environmentId); + const threadSegment = encodeURIComponent(input.threadId); + return `${origin}/#/${environmentSegment}/${threadSegment}`; +} + +export function buildDesktopProjectNavigationUrl(input: { + readonly isDevelopment: boolean; + readonly project: string; + readonly action: "reveal" | "latest" | "new"; +}): string { + const search = new URLSearchParams({ project: input.project }); + if (input.action !== "reveal") { + search.set("action", input.action); + } + return `${getDesktopOrigin(input.isDevelopment)}/#/jump?${search.toString()}`; +} + export class ElectronProtocolRegistrationError extends Schema.TaggedError()( "ElectronProtocolRegistrationError", { @@ -185,10 +213,21 @@ async function proxyRequest( return withContentSecurityPolicy(response, contentSecurityPolicy); } -const TRANSIENT_FETCH_RETRY_DELAYS_MS = [0, 50, 150] as const; +const TRANSIENT_FETCH_RETRY_DELAYS_MS = [0, 50, 150, 400] as const; + +function isRetryableDocumentResponse(url: string, response: Response): boolean { + if (response.status !== 503 && response.status !== 404) { + return false; + } + // Only the app shell / SPA document — hashed assets should fail fast so + // preload recovery can run instead of masking a torn swap. + const pathname = new URL(url).pathname; + return pathname === "/" || pathname === "/index.html" || !pathname.includes("."); +} async function fetchWithTransientRetry(url: string, init: RequestInit): Promise { let lastError: unknown; + let lastResponse: Response | null = null; for (const delayMs of TRANSIENT_FETCH_RETRY_DELAYS_MS) { if (delayMs > 0) { @@ -196,12 +235,20 @@ async function fetchWithTransientRetry(url: string, init: RequestInit): Promise< } try { - return await Electron.net.fetch(url, init); + const response = await Electron.net.fetch(url, init); + if (!isRetryableDocumentResponse(url, response)) { + return response; + } + lastResponse = response; } catch (error) { lastError = error; } } + if (lastResponse !== null) { + return lastResponse; + } + throw lastError; } diff --git a/apps/desktop/src/electron/ElectronShell.test.ts b/apps/desktop/src/electron/ElectronShell.test.ts index 8ba8082f0e57..db7a63ef04ff 100644 --- a/apps/desktop/src/electron/ElectronShell.test.ts +++ b/apps/desktop/src/electron/ElectronShell.test.ts @@ -58,6 +58,20 @@ describe("ElectronShell", () => { }).pipe(Effect.provide(ElectronShell.layer)), ); + it.effect("opens VS Code Remote SSH URLs", () => + Effect.gen(function* () { + openExternalMock.mockResolvedValue(undefined); + const url = + "vscode://vscode-remote/ssh-remote+tester%40remote.example.test/home/tester/project"; + + const electronShell = yield* ElectronShell.ElectronShell; + const result = yield* electronShell.openExternal(url); + + assert.equal(result, true); + assert.deepEqual(openExternalMock.mock.calls, [[url]]); + }).pipe(Effect.provide(ElectronShell.layer)), + ); + it.effect("opens the Full Disk Access settings anchor", () => Effect.gen(function* () { openExternalMock.mockResolvedValue(undefined); @@ -88,6 +102,32 @@ describe("ElectronShell", () => { }).pipe(Effect.provide(ElectronShell.layer)), ); + it.effect("opens local editor file/folder URLs", () => + Effect.gen(function* () { + openExternalMock.mockResolvedValue(undefined); + const url = "vscode://file/home/tester/projects/example"; + + const electronShell = yield* ElectronShell.ElectronShell; + const result = yield* electronShell.openExternal(url); + + assert.equal(result, true); + assert.deepEqual(openExternalMock.mock.calls, [[url]]); + }).pipe(Effect.provide(ElectronShell.layer)), + ); + + it.effect("opens Cursor local file/folder URLs", () => + Effect.gen(function* () { + openExternalMock.mockResolvedValue(undefined); + const url = "cursor://file/home/tester/projects/example"; + + const electronShell = yield* ElectronShell.ElectronShell; + const result = yield* electronShell.openExternal(url); + + assert.equal(result, true); + assert.deepEqual(openExternalMock.mock.calls, [[url]]); + }).pipe(Effect.provide(ElectronShell.layer)), + ); + it.effect("opens Zed's ssh deep link", () => Effect.gen(function* () { openExternalMock.mockResolvedValue(undefined); @@ -141,6 +181,16 @@ describe("ElectronShell", () => { }).pipe(Effect.provide(ElectronShell.layer)), ); + it.effect("does not open arbitrary VS Code URLs", () => + Effect.gen(function* () { + const electronShell = yield* ElectronShell.ElectronShell; + const result = yield* electronShell.openExternal("vscode://evil.example/command"); + + assert.equal(result, false); + assert.equal(openExternalMock.mock.calls.length, 0); + }).pipe(Effect.provide(ElectronShell.layer)), + ); + it.effect("does not open unsafe external URLs", () => Effect.gen(function* () { const electronShell = yield* ElectronShell.ElectronShell; diff --git a/apps/desktop/src/electron/ElectronShell.ts b/apps/desktop/src/electron/ElectronShell.ts index aa97c018bd21..8e55a46c5bfc 100644 --- a/apps/desktop/src/electron/ElectronShell.ts +++ b/apps/desktop/src/electron/ElectronShell.ts @@ -28,6 +28,23 @@ const SYSTEM_SETTINGS_URLS: Record = { // `zed://ssh//`) must reach the OS handler; every other non-web // scheme stays blocked. const SAFE_WEB_PROTOCOLS = new Set(["http:", "https:"]); +// Editor URL schemes whose handler runs in the user's graphical session, so the desktop can open a +// file/folder or a Remote-SSH target even when the t3 server runs headless (e.g. a lingered systemd +// user service with no display env). +// +// Upstream (#6572) added these schemes to SAFE_EXTERNAL_PROTOCOLS instead, which allows any URL +// carrying one. They stay here so the hostname/path check below still applies — that check already +// permits upstream's `://vscode-remote/ssh-remote+…` deep links. The remote-capable schemes +// are derived rather than listed, so an editor added upstream is covered without another edit. +const SAFE_EDITOR_PROTOCOLS = new Set([ + "vscode:", + "vscode-insiders:", + "cursor:", + ...REMOTE_CAPABLE_EDITOR_IDS.flatMap((id) => { + const scheme = remoteSchemeForEditor(id); + return scheme === undefined ? [] : [`${scheme}:`]; + }), +]); const REMOTE_EDITOR_PROTOCOLS = new Set( REMOTE_CAPABLE_EDITOR_IDS.flatMap((id) => { const scheme = remoteSchemeForEditor(id); @@ -48,6 +65,12 @@ const isRemoteEditorUrl = (url: URL) => url.pathname.startsWith("/ssh-remote+") && url.pathname.length > "/ssh-remote+".length); +const isLocalEditorFileUrl = (url: URL) => + SAFE_EDITOR_PROTOCOLS.has(url.protocol) && + url.username.length === 0 && + url.password.length === 0 && + url.hostname === "file"; + export function parseSafeExternalUrl(rawUrl: unknown): Option.Option { if (typeof rawUrl !== "string") { return Option.none(); @@ -55,7 +78,9 @@ export function parseSafeExternalUrl(rawUrl: unknown): Option.Option { try { const url = new URL(rawUrl); - return SAFE_WEB_PROTOCOLS.has(url.protocol) || isRemoteEditorUrl(url) + return SAFE_WEB_PROTOCOLS.has(url.protocol) || + isRemoteEditorUrl(url) || + isLocalEditorFileUrl(url) ? Option.some(url.href) : Option.none(); } catch { diff --git a/apps/desktop/src/electron/MacApplicationIcon.test.ts b/apps/desktop/src/electron/MacApplicationIcon.test.ts new file mode 100644 index 000000000000..85f168b0e62d --- /dev/null +++ b/apps/desktop/src/electron/MacApplicationIcon.test.ts @@ -0,0 +1,60 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, describe, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import { beforeEach, vi } from "vite-plus/test"; + +import * as MacApplicationIcon from "./MacApplicationIcon.ts"; + +const { createFromBufferMock, getFileIconMock } = vi.hoisted(() => ({ + createFromBufferMock: vi.fn(), + getFileIconMock: vi.fn(), +})); + +vi.mock("electron", () => ({ + app: { getFileIcon: getFileIconMock }, + nativeImage: { createFromBuffer: createFromBufferMock }, +})); + +const applicationIconLayer = MacApplicationIcon.layer.pipe(Layer.provide(NodeServices.layer)); + +const provideLayer = (effect: Effect.Effect) => + effect.pipe(Effect.provide(applicationIconLayer)); + +describe("MacApplicationIcon", () => { + beforeEach(() => { + createFromBufferMock.mockReset(); + getFileIconMock.mockReset(); + }); + + it.effect("falls back to Electron's system icon lookup", () => + provideLayer( + Effect.gen(function* () { + getFileIconMock.mockResolvedValue({ toDataURL: () => "data:image/png;base64,icon" }); + const applicationIcon = yield* MacApplicationIcon.MacApplicationIcon; + + assert.equal( + yield* applicationIcon.resolveDataUrl("/missing/Fixture.app"), + "data:image/png;base64,icon", + ); + assert.deepEqual(getFileIconMock.mock.calls[0], [ + "/missing/Fixture.app", + { size: "large" }, + ]); + }), + ), + ); + + it.effect("reports system icon lookup failures with the application path", () => + provideLayer( + Effect.gen(function* () { + getFileIconMock.mockRejectedValue(new Error("icon unavailable")); + const applicationIcon = yield* MacApplicationIcon.MacApplicationIcon; + + const error = yield* Effect.flip(applicationIcon.resolveDataUrl("/missing/Fixture.app")); + assert.equal(error._tag, "MacApplicationIconResolutionError"); + assert.equal(error.applicationPath, "/missing/Fixture.app"); + }), + ), + ); +}); diff --git a/apps/desktop/src/electron/MacApplicationIcon.ts b/apps/desktop/src/electron/MacApplicationIcon.ts new file mode 100644 index 000000000000..33e8d54f982e --- /dev/null +++ b/apps/desktop/src/electron/MacApplicationIcon.ts @@ -0,0 +1,125 @@ +import * as Electron from "electron"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; +import * as ChildProcess from "effect/unstable/process/ChildProcess"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +export class MacApplicationIconResolutionError extends Schema.TaggedError()( + "MacApplicationIconResolutionError", + { + applicationPath: Schema.String, + cause: Schema.Defect(), + }, +) { + override get message(): string { + return `Failed to resolve the macOS application icon for ${this.applicationPath}.`; + } +} + +export class MacApplicationIcon extends Context.Service< + MacApplicationIcon, + { + readonly resolveDataUrl: ( + applicationPath: string, + ) => Effect.Effect; + } +>()("@t3tools/desktop/electron/MacApplicationIcon") {} + +export const make = Effect.gen(function* () { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const pathService = yield* Path.Path; + const fs = yield* FileSystem.FileSystem; + + const resolveBundleIconPath = Effect.fn( + "desktop.electron.macApplicationIcon.resolveBundleIconPath", + )(function* (applicationPath: string) { + const infoPlistPath = pathService.join(applicationPath, "Contents", "Info.plist"); + const configuredName = yield* spawner + .string( + ChildProcess.make( + "/usr/bin/plutil", + ["-extract", "CFBundleIconFile", "raw", infoPlistPath], + { stdin: "ignore", stdout: "pipe", stderr: "pipe" }, + ), + ) + .pipe(Effect.map((output) => output.trim())); + if ( + configuredName.length === 0 || + pathService.basename(configuredName) !== configuredName || + configuredName === "." || + configuredName === ".." + ) { + return Option.none(); + } + const iconName = pathService.extname(configuredName) + ? configuredName + : `${configuredName}.icns`; + const iconPath = pathService.join(applicationPath, "Contents", "Resources", iconName); + const stat = yield* fs.stat(iconPath); + return stat.type === "File" ? Option.some(iconPath) : Option.none(); + }); + + const convertIcnsToDataUrl = Effect.fn( + "desktop.electron.macApplicationIcon.convertIcnsToDataUrl", + )(function* (applicationPath: string, iconPath: string) { + return yield* Effect.gen(function* () { + const temporaryDirectory = yield* fs.makeTempDirectoryScoped({ + prefix: "t3code-open-with-icon-", + }); + const pngPath = pathService.join(temporaryDirectory, "icon.png"); + yield* spawner.string( + ChildProcess.make("/usr/bin/sips", ["-s", "format", "png", iconPath, "--out", pngPath], { + stdin: "ignore", + stdout: "pipe", + stderr: "pipe", + }), + ); + const png = yield* fs.readFile(pngPath); + const image = yield* Effect.try({ + try: () => Electron.nativeImage.createFromBuffer(Buffer.from(png)), + catch: (cause) => new MacApplicationIconResolutionError({ applicationPath, cause }), + }); + if (image.isEmpty()) { + return yield* new MacApplicationIconResolutionError({ + applicationPath, + cause: new Error("The converted application icon is empty."), + }); + } + return image.toDataURL(); + }).pipe(Effect.scoped); + }); + + const resolveDataUrl = Effect.fn("desktop.electron.macApplicationIcon.resolveDataUrl")(function* ( + applicationPath: string, + ) { + // Electron can return a generic bundle icon, so prefer the app's declared ICNS asset. + const iconPath = yield* resolveBundleIconPath(applicationPath).pipe( + Effect.orElseSucceed(() => Option.none()), + ); + if (Option.isSome(iconPath)) { + const bundleIcon = yield* convertIcnsToDataUrl(applicationPath, iconPath.value).pipe( + Effect.map(Option.some), + Effect.orElseSucceed(() => Option.none()), + ); + if (Option.isSome(bundleIcon)) return bundleIcon.value; + } + + const image = yield* Effect.tryPromise({ + try: () => Electron.app.getFileIcon(applicationPath, { size: "large" }), + catch: (cause) => new MacApplicationIconResolutionError({ applicationPath, cause }), + }); + return yield* Effect.try({ + try: () => image.toDataURL(), + catch: (cause) => new MacApplicationIconResolutionError({ applicationPath, cause }), + }); + }); + + return MacApplicationIcon.of({ resolveDataUrl }); +}); + +export const layer = Layer.effect(MacApplicationIcon, make); diff --git a/apps/desktop/src/ipc/DesktopIpcHandlers.ts b/apps/desktop/src/ipc/DesktopIpcHandlers.ts index dc3769bb814f..f0a3c2e7970c 100644 --- a/apps/desktop/src/ipc/DesktopIpcHandlers.ts +++ b/apps/desktop/src/ipc/DesktopIpcHandlers.ts @@ -61,6 +61,11 @@ import { setSnapShotShortcutSuppressed, } from "./methods/snapShot.ts"; import * as PreviewIpc from "./methods/preview.ts"; +import { + openWith, + pickOpenWithApplication, + resolveOpenWithPresentations, +} from "./methods/openWith.ts"; import * as AppActivationIpc from "./methods/appActivation.ts"; import { getWslState, setWslBackendEnabled, setWslDistro, setWslOnly } from "./methods/wsl.ts"; @@ -121,6 +126,9 @@ export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers" yield* ipc.handle(setTheme); yield* ipc.handle(showContextMenu); yield* ipc.handle(openExternal); + yield* ipc.handle(pickOpenWithApplication); + yield* ipc.handle(resolveOpenWithPresentations); + yield* ipc.handle(openWith); yield* ipc.handle(openSystemSettings); yield* ipc.handle(probeRemoteEditors); yield* ipc.handle(getUpdateState); diff --git a/apps/desktop/src/ipc/channels.ts b/apps/desktop/src/ipc/channels.ts index 43ecee06c0ca..c3eba617599e 100644 --- a/apps/desktop/src/ipc/channels.ts +++ b/apps/desktop/src/ipc/channels.ts @@ -4,6 +4,9 @@ export const PICK_THEME_FILES_CHANNEL = "desktop:pick-theme-files"; export const SET_THEME_CHANNEL = "desktop:set-theme"; export const CONTEXT_MENU_CHANNEL = "desktop:context-menu"; export const OPEN_EXTERNAL_CHANNEL = "desktop:open-external"; +export const PICK_OPEN_WITH_APPLICATION_CHANNEL = "desktop:pick-open-with-application"; +export const RESOLVE_OPEN_WITH_PRESENTATIONS_CHANNEL = "desktop:resolve-open-with-presentations"; +export const OPEN_WITH_CHANNEL = "desktop:open-with"; export const OPEN_SYSTEM_SETTINGS_CHANNEL = "desktop:open-system-settings"; export const PROBE_REMOTE_EDITORS_CHANNEL = "desktop:probe-remote-editors"; export const MENU_ACTION_CHANNEL = "desktop:menu-action"; diff --git a/apps/desktop/src/ipc/methods/openWith.test.ts b/apps/desktop/src/ipc/methods/openWith.test.ts new file mode 100644 index 000000000000..9e606199ebd1 --- /dev/null +++ b/apps/desktop/src/ipc/methods/openWith.test.ts @@ -0,0 +1,43 @@ +import { assert, describe, it } from "@effect/vitest"; +import { OpenWithEntryId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; + +import * as DesktopOpenWith from "../../shell/DesktopOpenWith.ts"; +import { openWith, resolveOpenWithPresentations } from "./openWith.ts"; + +describe("Open With IPC methods", () => { + it.effect("encodes presentations and delegates launch inputs", () => + Effect.gen(function* () { + const opened = yield* Ref.make(null); + const entryId = OpenWithEntryId.make("terminal"); + const layer = Layer.succeed( + DesktopOpenWith.DesktopOpenWith, + DesktopOpenWith.DesktopOpenWith.of({ + resolvePresentations: Effect.succeed([ + { entryId, available: true, iconDataUrl: "data:image/png;base64,abc" }, + ]), + open: (input) => Ref.set(opened, input), + }), + ); + + assert.deepEqual( + yield* resolveOpenWithPresentations.handler(undefined).pipe(Effect.provide(layer)), + [{ entryId: "terminal", available: true, iconDataUrl: "data:image/png;base64,abc" }], + ); + yield* openWith + .handler({ + environmentId: "primary", + entryId: "terminal", + directory: "/tmp/project", + }) + .pipe(Effect.provide(layer)); + assert.deepEqual(yield* Ref.get(opened), { + environmentId: "primary", + entryId: "terminal", + directory: "/tmp/project", + }); + }), + ); +}); diff --git a/apps/desktop/src/ipc/methods/openWith.ts b/apps/desktop/src/ipc/methods/openWith.ts new file mode 100644 index 000000000000..eb19e0ec7e3c --- /dev/null +++ b/apps/desktop/src/ipc/methods/openWith.ts @@ -0,0 +1,47 @@ +import { + DesktopApplicationSelection, + DesktopOpenWithInput, + OpenWithEntryPresentation, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; + +import * as ElectronDialog from "../../electron/ElectronDialog.ts"; +import * as ElectronWindow from "../../electron/ElectronWindow.ts"; +import * as DesktopOpenWith from "../../shell/DesktopOpenWith.ts"; +import * as IpcChannels from "../channels.ts"; +import * as DesktopIpc from "../DesktopIpc.ts"; + +export const pickOpenWithApplication = DesktopIpc.makeIpcMethod({ + channel: IpcChannels.PICK_OPEN_WITH_APPLICATION_CHANNEL, + payload: Schema.Void, + result: Schema.NullOr(DesktopApplicationSelection), + handler: Effect.fn("desktop.ipc.openWith.pickApplication")(function* () { + const dialog = yield* ElectronDialog.ElectronDialog; + const electronWindow = yield* ElectronWindow.ElectronWindow; + return Option.getOrNull( + yield* dialog.pickApplication({ owner: yield* electronWindow.focusedMainOrFirst }), + ); + }), +}); + +export const resolveOpenWithPresentations = DesktopIpc.makeIpcMethod({ + channel: IpcChannels.RESOLVE_OPEN_WITH_PRESENTATIONS_CHANNEL, + payload: Schema.Void, + result: Schema.Array(OpenWithEntryPresentation), + handler: Effect.fn("desktop.ipc.openWith.resolvePresentations")(function* () { + const openWith = yield* DesktopOpenWith.DesktopOpenWith; + return yield* openWith.resolvePresentations; + }), +}); + +export const openWith = DesktopIpc.makeIpcMethod({ + channel: IpcChannels.OPEN_WITH_CHANNEL, + payload: DesktopOpenWithInput, + result: Schema.Void, + handler: Effect.fn("desktop.ipc.openWith.open")(function* (input) { + const openWith = yield* DesktopOpenWith.DesktopOpenWith; + yield* openWith.open(input); + }), +}); diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts index ed920abcdc8f..d09c0144ed68 100644 --- a/apps/desktop/src/main.ts +++ b/apps/desktop/src/main.ts @@ -20,9 +20,11 @@ import { resolveRemoteT3CliPackageSpec } from "@t3tools/ssh/command"; import type { RemoteT3RunnerOptions } from "@t3tools/ssh/tunnel"; import serverPackageJson from "../../server/package.json" with { type: "json" }; +import { configureDesktopEarlyStartup } from "./electron/DesktopEarlyStartup.ts"; import * as DesktopIpc from "./ipc/DesktopIpc.ts"; import * as ElectronApp from "./electron/ElectronApp.ts"; import * as ElectronDialog from "./electron/ElectronDialog.ts"; +import * as MacApplicationIcon from "./electron/MacApplicationIcon.ts"; import * as ElectronMenu from "./electron/ElectronMenu.ts"; import * as ElectronPowerMonitor from "./electron/ElectronPowerMonitor.ts"; import * as ElectronProtocol from "./electron/ElectronProtocol.ts"; @@ -36,6 +38,7 @@ import * as DesktopAppActivation from "./app/DesktopAppActivation.ts"; import * as DesktopAppIdentity from "./app/DesktopAppIdentity.ts"; import * as DesktopConnectionCatalogStore from "./app/DesktopConnectionCatalogStore.ts"; import * as DesktopClerk from "./app/DesktopClerk.ts"; +import * as DesktopDeepLinks from "./app/DesktopDeepLinks.ts"; import * as DesktopApplicationMenu from "./window/DesktopApplicationMenu.ts"; import * as DesktopAssets from "./app/DesktopAssets.ts"; import * as DesktopBackendConfiguration from "./backend/DesktopBackendConfiguration.ts"; @@ -54,6 +57,7 @@ import * as DesktopSnapShot from "./snapShot/DesktopSnapShot.ts"; import * as DesktopAppSettings from "./settings/DesktopAppSettings.ts"; import * as DesktopPreReadyPlatform from "./app/DesktopPreReadyPlatform.ts"; import * as DesktopShellEnvironment from "./shell/DesktopShellEnvironment.ts"; +import * as DesktopOpenWith from "./shell/DesktopOpenWith.ts"; import * as DesktopSshEnvironment from "./ssh/DesktopSshEnvironment.ts"; import * as DesktopSshPasswordPrompts from "./ssh/DesktopSshPasswordPrompts.ts"; import * as DesktopState from "./app/DesktopState.ts"; @@ -68,6 +72,12 @@ import * as DesktopWslBackend from "./wsl/DesktopWslBackend.ts"; import * as DesktopWslEnvironment from "./wsl/DesktopWslEnvironment.ts"; import * as DesktopWslServerTree from "./wsl/DesktopWslServerTree.ts"; +configureDesktopEarlyStartup({ + app: Electron.app, + argv: process.argv, + writeStdout: (value) => process.stdout.write(value), +}); + const desktopEnvironmentLayer = Layer.unwrap( Effect.gen(function* () { const metadata = yield* Effect.service(ElectronApp.ElectronApp).pipe( @@ -130,7 +140,7 @@ const electronLayer = Layer.mergeAll( ElectronUpdater.layer, ElectronWindow.layer, DesktopIpc.layer(Electron.ipcMain), -); +).pipe(Layer.provideMerge(MacApplicationIcon.layer)); const desktopFoundationLayer = Layer.mergeAll( DesktopState.layer, @@ -164,10 +174,16 @@ const desktopWindowLayer = DesktopWindow.layer.pipe( Layer.provideMerge(desktopPreviewLayer), ); +const desktopDeepLinksLayer = DesktopDeepLinks.layer.pipe( + Layer.provideMerge(desktopWindowLayer), + Layer.provideMerge(desktopFoundationLayer), +); + const desktopSnapShotLayer = DesktopSnapShot.layer.pipe( Layer.provideMerge(desktopWindowLayer), Layer.provideMerge(desktopFoundationLayer), ); + const desktopAppActivationLayer = DesktopAppActivation.layer.pipe( Layer.provide(desktopWindowLayer), ); @@ -203,9 +219,12 @@ const desktopApplicationLayer = Layer.mergeAll( DesktopApplicationMenu.layer, DesktopLinuxUrlHandler.layer, DesktopShellEnvironment.layer, + DesktopOpenWith.layer, desktopSshLayer, ).pipe( + Layer.provideMerge(desktopDeepLinksLayer), Layer.provideMerge(desktopSnapShotLayer), + Layer.provideMerge(DesktopUpdates.layer), Layer.provideMerge(desktopWslBackendLayer), Layer.provideMerge(desktopLocalEnvironmentAuthLayer), diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts index 7da32d7913ae..517d3dab0789 100644 --- a/apps/desktop/src/preload.ts +++ b/apps/desktop/src/preload.ts @@ -152,6 +152,10 @@ contextBridge.exposeInMainWorld("desktopBridge", { ...(position === undefined ? {} : { position }), }), openExternal: (url: string) => ipcRenderer.invoke(IpcChannels.OPEN_EXTERNAL_CHANNEL, url), + pickOpenWithApplication: () => ipcRenderer.invoke(IpcChannels.PICK_OPEN_WITH_APPLICATION_CHANNEL), + resolveOpenWithPresentations: () => + ipcRenderer.invoke(IpcChannels.RESOLVE_OPEN_WITH_PRESENTATIONS_CHANNEL), + openWith: (input) => ipcRenderer.invoke(IpcChannels.OPEN_WITH_CHANNEL, input), openSystemSettings: (pane: string) => ipcRenderer.invoke(IpcChannels.OPEN_SYSTEM_SETTINGS_CHANNEL, pane), probeRemoteEditors: () => ipcRenderer.invoke(IpcChannels.PROBE_REMOTE_EDITORS_CHANNEL, undefined), diff --git a/apps/desktop/src/settings/DesktopClientSettings.test.ts b/apps/desktop/src/settings/DesktopClientSettings.test.ts index ea2a80010124..48c48874a05d 100644 --- a/apps/desktop/src/settings/DesktopClientSettings.test.ts +++ b/apps/desktop/src/settings/DesktopClientSettings.test.ts @@ -3,6 +3,7 @@ import { assert, describe, it } from "@effect/vitest"; import { ClientSettingsSchema, DEFAULT_CLIENT_SETTINGS, + OpenWithEntryId, type ClientSettings, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; @@ -30,6 +31,7 @@ const clientSettings: ClientSettings = { confirmQuit: "double-click", confirmThreadArchive: true, confirmThreadDelete: false, + confirmWorktreeRemoval: true, confirmThreadUnpin: false, contextWindowMeterEnabled: false, composerCollapseOnScroll: true, @@ -50,6 +52,18 @@ const clientSettings: ClientSettings = { glassOpacity: 80, onboardingCompletedAt: null, panelAnimationDurationMs: 0, + providerFavorites: [], + openWithEntries: [ + { + id: OpenWithEntryId.make("terminal"), + name: "Terminal", + kind: "terminal", + invocation: { type: "mac-application", applicationPath: "/Applications/Terminal.app" }, + directoryMode: "open-target", + arguments: [], + }, + ], + preferredOpenWith: { type: "custom", id: OpenWithEntryId.make("terminal") }, planModeEnabled: false, proactivePanelsEnabled: true, showSkillsInSlashMenu: false, @@ -59,8 +73,10 @@ const clientSettings: ClientSettings = { "environment-1:/tmp/project-a": "separate", }, sidebarProjectSortOrder: "manual", + sidebarRecentThreadsEnabled: true, sidebarThreadSortOrder: "created_at", sidebarThreadPreviewCount: 6, + sidebarHideProviderIcons: false, legacySidebarEnabled: false, loadBalancingEnabled: false, loadBalancingWeights: { "environment-1": 75, "environment-2": 0 }, diff --git a/apps/desktop/src/shell/DesktopOpenWith.test.ts b/apps/desktop/src/shell/DesktopOpenWith.test.ts new file mode 100644 index 000000000000..e98b202a025b --- /dev/null +++ b/apps/desktop/src/shell/DesktopOpenWith.test.ts @@ -0,0 +1,196 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, describe, it } from "@effect/vitest"; +import { + DEFAULT_CLIENT_SETTINGS, + EnvironmentId, + OpenWithEntry, + OpenWithEntryId, + PRIMARY_LOCAL_ENVIRONMENT_ID, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Schema from "effect/Schema"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; + +import * as DesktopConfig from "../app/DesktopConfig.ts"; +import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; +import * as MacApplicationIcon from "../electron/MacApplicationIcon.ts"; +import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts"; +import * as DesktopOpenWith from "./DesktopOpenWith.ts"; + +const decodeEntry = Schema.decodeUnknownSync(OpenWithEntry); + +const configuredEntries = [ + decodeEntry({ + id: "echo", + name: "Echo", + kind: "other", + invocation: { type: "command", executable: "/bin/echo" }, + directoryMode: "open-target", + arguments: [], + }), + decodeEntry({ + id: "missing", + name: "Missing", + kind: "other", + invocation: { type: "command", executable: "/definitely/missing/t3-open-with" }, + directoryMode: "open-target", + arguments: [], + }), +] as const; + +const environmentLayer = DesktopEnvironment.layer({ + dirname: "/repo/apps/desktop/src", + homeDirectory: "/tmp", + platform: "darwin", + processArch: "arm64", + appVersion: "1.0.0", + appPath: "/repo", + isPackaged: true, + resourcesPath: "/repo/resources", + runningUnderArm64Translation: false, +}).pipe( + Layer.provide( + Layer.mergeAll( + NodeServices.layer, + DesktopConfig.layerTest({ T3CODE_HOME: "/tmp/t3-open-with" }), + ), + ), +); + +const openWithLayer = DesktopOpenWith.layer.pipe( + Layer.provideMerge( + Layer.succeed(MacApplicationIcon.MacApplicationIcon, { + resolveDataUrl: () => Effect.die("unexpected application icon resolution"), + } satisfies MacApplicationIcon.MacApplicationIcon["Service"]), + ), + Layer.provideMerge( + DesktopClientSettings.layerTest( + Option.some({ + ...DEFAULT_CLIENT_SETTINGS, + openWithEntries: configuredEntries, + }), + ), + ), + Layer.provideMerge(environmentLayer), + Layer.provideMerge(NodeServices.layer), +); + +describe("DesktopOpenWith launch resolution", () => { + it.effect("appends the directory for open-target command entries", () => + Effect.gen(function* () { + const launch = yield* DesktopOpenWith.resolveOpenWithLaunch( + decodeEntry({ + id: "echo", + name: "Echo", + kind: "other", + invocation: { type: "command", executable: "/bin/echo" }, + directoryMode: "open-target", + arguments: ["--flag"], + }), + "/tmp/work tree", + "darwin", + ); + assert.deepEqual(launch, { + command: "/bin/echo", + args: ["--flag", "/tmp/work tree"], + shell: false, + cwd: null, + }); + }).pipe(Effect.provide(NodeServices.layer)), + ); + + it.effect("sets cwd without adding a directory argument in working-directory mode", () => + Effect.gen(function* () { + const launch = yield* DesktopOpenWith.resolveOpenWithLaunch( + decodeEntry({ + id: "echo", + name: "Echo", + kind: "other", + invocation: { type: "command", executable: "/bin/echo" }, + directoryMode: "working-directory", + arguments: ["one argument"], + }), + "/tmp/work tree", + "darwin", + ); + assert.deepEqual(launch, { + command: "/bin/echo", + args: ["one argument"], + shell: false, + cwd: "/tmp/work tree", + }); + }).pipe(Effect.provide(NodeServices.layer)), + ); + + it.effect("expands placeholders within independent argument rows without shell parsing", () => + Effect.gen(function* () { + const launch = yield* DesktopOpenWith.resolveOpenWithLaunch( + decodeEntry({ + id: "echo", + name: "Echo", + kind: "other", + invocation: { type: "command", executable: "/bin/echo" }, + directoryMode: "custom-arguments", + arguments: ["prefix={directory}=suffix", "literal value"], + }), + "/tmp/work tree", + "darwin", + ); + assert.deepEqual(launch.args, ["prefix=/tmp/work tree=suffix", "literal value"]); + assert.isFalse(launch.shell ?? false); + }).pipe(Effect.provide(NodeServices.layer)), + ); + + it.effect("reports available and missing command presentations", () => + Effect.gen(function* () { + const openWith = yield* DesktopOpenWith.DesktopOpenWith; + const presentations = yield* openWith.resolvePresentations; + assert.deepEqual(presentations, [ + { entryId: configuredEntries[0].id, available: true, iconDataUrl: null }, + { + entryId: configuredEntries[1].id, + available: false, + iconDataUrl: null, + unavailableReason: "Executable not found: /definitely/missing/t3-open-with", + }, + ]); + }).pipe(Effect.provide(openWithLayer)), + ); + + it.effect("rejects secondary environments, invalid targets, and unknown entry ids", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const directory = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-open-target-" }); + const openWith = yield* DesktopOpenWith.DesktopOpenWith; + + const remoteError = yield* Effect.flip( + openWith.open({ + environmentId: EnvironmentId.make("ssh:test"), + entryId: configuredEntries[0].id, + directory, + }), + ); + assert.equal(remoteError._tag, "OpenWithEnvironmentError"); + + const relativeError = yield* Effect.flip( + openWith.open({ + environmentId: EnvironmentId.make(PRIMARY_LOCAL_ENVIRONMENT_ID), + entryId: configuredEntries[0].id, + directory: "relative/path", + }), + ); + assert.equal(relativeError._tag, "OpenWithInvalidTargetError"); + + const unknownError = yield* Effect.flip( + openWith.open({ + environmentId: EnvironmentId.make(PRIMARY_LOCAL_ENVIRONMENT_ID), + entryId: OpenWithEntryId.make("unknown"), + directory, + }), + ); + assert.equal(unknownError._tag, "OpenWithMissingEntryError"); + }).pipe(Effect.provide(openWithLayer), Effect.scoped), + ); +}); diff --git a/apps/desktop/src/shell/DesktopOpenWith.ts b/apps/desktop/src/shell/DesktopOpenWith.ts new file mode 100644 index 000000000000..95da0123394e --- /dev/null +++ b/apps/desktop/src/shell/DesktopOpenWith.ts @@ -0,0 +1,268 @@ +// @effect-diagnostics nodeBuiltinImport:off - macOS bundle paths use the host path grammar. +import { + OpenWithEnvironmentError, + OpenWithInvalidTargetError, + OpenWithMissingEntryError, + OpenWithSpawnError, + OpenWithUnavailableApplicationError, + PRIMARY_LOCAL_ENVIRONMENT_ID, + type DesktopOpenWithInput, + type OpenWithEntry, + type OpenWithEntryPresentation, + type OpenWithLaunchError, +} from "@t3tools/contracts"; +import { resolveCommandPath, resolveSpawnCommand } from "@t3tools/shared/shell"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Path from "effect/Path"; +import * as NodePath from "node:path"; +import * as ChildProcess from "effect/unstable/process/ChildProcess"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; +import * as MacApplicationIcon from "../electron/MacApplicationIcon.ts"; +import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts"; + +interface ResolvedLaunch { + readonly command: string; + readonly args: readonly string[]; + readonly cwd: string | null; + readonly shell?: boolean; +} + +const statPath = (path: string) => + FileSystem.FileSystem.pipe( + Effect.flatMap((fileSystem) => fileSystem.stat(path)), + Effect.map(Option.some), + Effect.orElseSucceed(() => Option.none()), + ); + +const applicationUnavailableReason = (entry: OpenWithEntry): string => + entry.invocation.type === "mac-application" + ? `Application not found: ${entry.invocation.applicationPath}` + : `Executable not found: ${entry.invocation.executable}`; + +const isMacApplicationPath = (value: string): boolean => + NodePath.isAbsolute(value) && value.toLowerCase().endsWith(".app"); + +const commandExists = Effect.fn("desktop.openWith.commandExists")(function* (command: string) { + return yield* resolveCommandPath(command).pipe( + Effect.as(true), + Effect.catchTag("CommandResolutionError", () => Effect.succeed(false)), + ); +}); + +const entryIsAvailable = Effect.fn("desktop.openWith.entryIsAvailable")(function* ( + entry: OpenWithEntry, + platform: NodeJS.Platform, +) { + if (entry.invocation.type === "command") { + return yield* commandExists(entry.invocation.executable); + } + if (platform !== "darwin" || !isMacApplicationPath(entry.invocation.applicationPath)) { + return false; + } + const stat = yield* statPath(entry.invocation.applicationPath); + return Option.isSome(stat) && stat.value.type === "Directory"; +}); + +const expandDirectoryArguments = (args: readonly string[], directory: string): string[] => + args.map((argument) => argument.replaceAll("{directory}", directory)); + +export const resolveOpenWithLaunch = Effect.fn("desktop.openWith.resolveLaunch")(function* ( + entry: OpenWithEntry, + directory: string, + platform: NodeJS.Platform, +): Effect.fn.Return< + ResolvedLaunch, + OpenWithLaunchError, + FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner +> { + if (!(yield* entryIsAvailable(entry, platform))) { + return yield* new OpenWithUnavailableApplicationError({ + entryId: entry.id, + executable: + entry.invocation.type === "mac-application" + ? entry.invocation.applicationPath + : entry.invocation.executable, + }); + } + + if (entry.directoryMode === "open-target") { + if (entry.invocation.type === "mac-application") { + return { + command: "/usr/bin/open", + args: ["-a", entry.invocation.applicationPath, directory], + cwd: null, + }; + } + const command = yield* resolveSpawnCommand(entry.invocation.executable, [ + ...entry.arguments, + directory, + ]); + return { ...command, cwd: null }; + } + + if (entry.directoryMode === "working-directory") { + if (entry.invocation.type === "mac-application") { + return { + command: "/usr/bin/open", + args: ["-a", entry.invocation.applicationPath, "--args", ...entry.arguments], + cwd: directory, + }; + } + const command = yield* resolveSpawnCommand(entry.invocation.executable, entry.arguments); + return { ...command, cwd: directory }; + } + + if (!entry.arguments.some((argument) => argument.includes("{directory}"))) { + return yield* new OpenWithUnavailableApplicationError({ + entryId: entry.id, + executable: "Custom arguments must include {directory}", + }); + } + const args = expandDirectoryArguments(entry.arguments, directory); + if (entry.invocation.type === "mac-application") { + return { + command: "/usr/bin/open", + args: ["-a", entry.invocation.applicationPath, "--args", ...args], + cwd: null, + }; + } + const command = yield* resolveSpawnCommand(entry.invocation.executable, args); + return { ...command, cwd: null }; +}); + +const spawnDetached = Effect.fn("desktopOpenWith.spawnDetached")(function* ( + entry: OpenWithEntry, + launch: ResolvedLaunch & { readonly shell?: boolean }, +): Effect.fn.Return { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + yield* spawner + .spawn( + ChildProcess.make(launch.command, launch.args, { + ...(launch.cwd === null ? {} : { cwd: launch.cwd }), + detached: true, + shell: launch.shell ?? false, + stdin: "ignore", + stdout: "ignore", + stderr: "ignore", + }), + ) + .pipe( + Effect.flatMap((handle) => handle.unref), + Effect.asVoid, + Effect.scoped, + Effect.mapError( + (cause) => + new OpenWithSpawnError({ + entryId: entry.id, + command: launch.command, + args: [...launch.args], + cwd: launch.cwd, + cause, + }), + ), + ); +}); + +export class DesktopOpenWith extends Context.Service< + DesktopOpenWith, + { + readonly resolvePresentations: Effect.Effect; + readonly open: (input: DesktopOpenWithInput) => Effect.Effect; + } +>()("@t3tools/desktop/shell/DesktopOpenWith") {} + +export const make = Effect.gen(function* () { + const clientSettings = yield* DesktopClientSettings.DesktopClientSettings; + const environment = yield* DesktopEnvironment.DesktopEnvironment; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const applicationIcon = yield* MacApplicationIcon.MacApplicationIcon; + + const providePlatformServices = ( + effect: Effect.Effect< + A, + E, + FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner + >, + ): Effect.Effect => + effect.pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + ); + + const readClientSettings = clientSettings.get.pipe( + Effect.catchTag("DesktopClientSettingsReadError", () => Effect.succeed(Option.none())), + ); + + const resolvePresentations = Effect.gen(function* () { + const settings = yield* readClientSettings; + if (Option.isNone(settings)) return []; + return yield* Effect.forEach(settings.value.openWithEntries, (entry) => + Effect.gen(function* () { + const available = yield* providePlatformServices( + entryIsAvailable(entry, environment.platform), + ); + const iconDataUrl = + available && entry.invocation.type === "mac-application" + ? yield* applicationIcon + .resolveDataUrl(entry.invocation.applicationPath) + .pipe(Effect.orElseSucceed(() => null)) + : null; + return { + entryId: entry.id, + available, + iconDataUrl, + ...(available ? {} : { unavailableReason: applicationUnavailableReason(entry) }), + } satisfies OpenWithEntryPresentation; + }), + ); + }).pipe(Effect.withSpan("desktop.openWith.resolvePresentations")); + + const open = Effect.fn("desktop.openWith.open")(function* (input: DesktopOpenWithInput) { + if (input.environmentId !== PRIMARY_LOCAL_ENVIRONMENT_ID) { + return yield* new OpenWithEnvironmentError({ environmentId: input.environmentId }); + } + if (!NodePath.isAbsolute(input.directory)) { + return yield* new OpenWithInvalidTargetError({ + directory: input.directory, + reason: "relative", + }); + } + const targetStat = yield* providePlatformServices(statPath(input.directory)); + if (Option.isNone(targetStat)) { + return yield* new OpenWithInvalidTargetError({ + directory: input.directory, + reason: "missing", + }); + } + if (targetStat.value.type !== "Directory") { + return yield* new OpenWithInvalidTargetError({ + directory: input.directory, + reason: "not-directory", + }); + } + const settings = yield* readClientSettings; + const entry = Option.isSome(settings) + ? settings.value.openWithEntries.find((candidate) => candidate.id === input.entryId) + : undefined; + if (entry === undefined) { + return yield* new OpenWithMissingEntryError({ entryId: input.entryId }); + } + const launch = yield* providePlatformServices( + resolveOpenWithLaunch(entry, input.directory, environment.platform), + ); + yield* providePlatformServices(spawnDetached(entry, launch)); + }); + + return DesktopOpenWith.of({ resolvePresentations, open }); +}); + +export const layer = Layer.effect(DesktopOpenWith, make); diff --git a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts index d705252ef588..b84f7d0a918b 100644 --- a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts +++ b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts @@ -35,6 +35,7 @@ function makeElectronAppLayer( setName: () => Effect.void, setAboutPanelOptions: () => Effect.void, setAppUserModelId: () => Effect.void, + requestSingleInstanceLock: Effect.succeed(true), getAppMetrics: Effect.sync(() => { onMetricsRead(); return metrics; diff --git a/apps/desktop/src/updates/DesktopUpdates.ts b/apps/desktop/src/updates/DesktopUpdates.ts index 51584e3c796d..74a76a3708de 100644 --- a/apps/desktop/src/updates/DesktopUpdates.ts +++ b/apps/desktop/src/updates/DesktopUpdates.ts @@ -27,6 +27,7 @@ import * as DesktopConfig from "../app/DesktopConfig.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import * as DesktopObservability from "../app/DesktopObservability.ts"; import * as DesktopState from "../app/DesktopState.ts"; +import * as ElectronApp from "../electron/ElectronApp.ts"; import * as ElectronUpdater from "../electron/ElectronUpdater.ts"; import * as ElectronWindow from "../electron/ElectronWindow.ts"; import * as IpcChannels from "../ipc/channels.ts"; @@ -252,9 +253,6 @@ function getAutoUpdateDisabledReason(args: { disabledByEnv: boolean; hasUpdateFeedConfig: boolean; }): string | null { - if (!args.hasUpdateFeedConfig) { - return "Automatic updates are not available because no update feed is configured."; - } if (args.isDevelopment || !args.isPackaged) { return "Automatic updates are only available in packaged production builds."; } @@ -262,7 +260,14 @@ function getAutoUpdateDisabledReason(args: { return "Automatic updates are disabled by the T3CODE_DISABLE_AUTO_UPDATE setting."; } if (args.platform === "linux" && !args.appImage) { - return "Automatic updates on Linux require running the AppImage build."; + // Directory installs (and other non-AppImage linux) do not use the network + // updater at all. We force-enable the update UI so the local on-disk probe + // can detect rsync'd builds and surface "Restart to update". + // We intentionally skip the feed-config requirement for dir installs. + return null; + } + if (!args.hasUpdateFeedConfig) { + return "Automatic updates are not available because no update feed is configured."; } return null; } @@ -278,6 +283,7 @@ export const make = Effect.gen(function* () { const desktopState = yield* DesktopState.DesktopState; const electronUpdater = yield* ElectronUpdater.ElectronUpdater; const electronWindow = yield* ElectronWindow.ElectronWindow; + const electronApp = yield* ElectronApp.ElectronApp; const environment = yield* DesktopEnvironment.DesktopEnvironment; const fileSystem = yield* FileSystem.FileSystem; const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings; @@ -294,6 +300,102 @@ export const make = Effect.gen(function* () { environment.defaultDesktopSettings.updateChannel, ), ); + const localDirModeRef = yield* Ref.make(false); + + // Local dir-mode build change detection (so "restart to update" works even + // when the semver was not bumped for a dir deploy). + const readOnDiskCommitHash = (): Effect.Effect> => + fileSystem + .readFileString(environment.path.join(environment.appRoot, "package.json"), "utf-8") + .pipe( + Effect.flatMap((raw) => { + try { + const parsed = JSON.parse(raw); + const h = + typeof parsed?.t3codeCommitHash === "string" ? parsed.t3codeCommitHash.trim() : ""; + return Effect.succeed( + /^[0-9a-f]{7,40}$/i.test(h) + ? Option.some(h.toLowerCase().slice(0, 12)) + : Option.none(), + ); + } catch { + return Effect.succeed(Option.none()); + } + }), + Effect.orElseSucceed(() => Option.none()), + ); + + const getOnDiskBinaryMtime = (): Effect.Effect => + fileSystem.stat(process.execPath).pipe( + Effect.map((s) => (s.mtime._tag === "Some" ? s.mtime.value.getTime() : null)), + Effect.orElseSucceed(() => null), + ); + + const probeOnDiskVersion = (): Effect.Effect => + Effect.tryPromise({ + try: () => + new Promise((resolve) => { + const CP: typeof import("node:child_process") = require("node:child_process"); + CP.execFile(process.execPath, ["--version"], { timeout: 7000 }, (err, out) => { + if (err) return resolve(""); + resolve(String(out || "").trim()); + }); + }), + catch: () => null, + }).pipe(Effect.orElseSucceed(() => null)); + + const applyLocalDirBuildUpdate = (reason: string) => + Effect.gen(function* () { + const state = yield* Ref.get(updateStateRef); + if (state.status === "downloading") return; + + const onDiskVersion = yield* probeOnDiskVersion(); + const runningVersion = state.currentVersion; + const versionChanged = !!onDiskVersion && onDiskVersion !== runningVersion; + + if (!versionChanged) { + const onDiskC = yield* readOnDiskCommitHash(); + if (Option.isNone(onDiskC)) return; + } + + yield* logUpdaterInfo("different build detected on disk for dir install", { + reason, + onDiskVersion, + runningVersion, + }); + + const targetVer = onDiskVersion ?? runningVersion; + yield* setState( + reduceDesktopUpdateStateOnDownloadComplete( + { ...state, availableVersion: targetVer }, + targetVer, + ), + ); + }); + + const dirBaselineMtimeRef = yield* Ref.make(null); + + const startLocalDirProbes = Effect.gen(function* () { + const baseline = yield* getOnDiskBinaryMtime(); + yield* Ref.set(dirBaselineMtimeRef, baseline); + + const tick = Effect.gen(function* () { + const state = yield* Ref.get(updateStateRef); + const baseM = yield* Ref.get(dirBaselineMtimeRef); + const curM = yield* getOnDiskBinaryMtime(); + const v = yield* probeOnDiskVersion(); + + const vChanged = !!v && v !== state.currentVersion; + const mChanged = baseM != null && curM != null && curM > baseM + 1000; + + if (vChanged || mChanged) { + yield* applyLocalDirBuildUpdate("dir-probe"); + } + }); + + yield* Effect.sleep("5 seconds").pipe(Effect.andThen(tick), Effect.forkScoped); + yield* Effect.sleep("45 seconds").pipe(Effect.andThen(tick), Effect.forever, Effect.forkScoped); + }); const stateChanges = yield* PubSub.sliding(16); // Makes ref writes + publishes atomic against subscribe, so a snapshot @@ -391,12 +493,25 @@ export const make = Effect.gen(function* () { const shouldEnableAutoUpdates = resolveDisabledReason.pipe(Effect.map(Option.isNone)); + const execBase = process.execPath.split(/[\\/]/).pop() || ""; + const isDirBinary = execBase === "t3code"; + const isLinuxDirStyleInstall = + environment.platform === "linux" && + environment.isPackaged && + (Option.isNone(config.appImagePath) || isDirBinary); + const checkForUpdates = Effect.fn("desktop.updates.checkForUpdates")(function* ( reason: string, actionReservation: "acquire" | "held" = "acquire", ) { yield* Effect.annotateCurrentSpan({ reason }); if (yield* Ref.get(desktopState.quitting)) return false; + + if (yield* Ref.get(localDirModeRef)) { + yield* applyLocalDirBuildUpdate(reason); + return true; + } + if (!(yield* Ref.get(updaterConfiguredRef))) return false; const state = yield* Ref.get(updateStateRef); @@ -445,7 +560,11 @@ export const make = Effect.gen(function* () { const downloadAvailableUpdate = Effect.gen(function* () { const state = yield* Ref.get(updateStateRef); - if (!(yield* Ref.get(updaterConfiguredRef)) || state.status !== "available") { + if ( + (yield* Ref.get(localDirModeRef)) || + !(yield* Ref.get(updaterConfiguredRef)) || + state.status !== "available" + ) { return { accepted: false, completed: false }; } @@ -548,9 +667,10 @@ export const make = Effect.gen(function* () { const hasExpectedDownload = state.downloadedVersion !== null && (expectedVersion === undefined || state.downloadedVersion === expectedVersion); + const isDirLocal = yield* Ref.get(localDirModeRef); if ( (yield* Ref.get(desktopState.quitting)) || - !(yield* Ref.get(updaterConfiguredRef)) || + (!isDirLocal && !(yield* Ref.get(updaterConfiguredRef))) || !hasExpectedDownload ) { return "refused" as const; @@ -599,6 +719,18 @@ export const make = Effect.gen(function* () { (instance) => instance.stop({ timeout: Duration.seconds(5) }), { concurrency: "unbounded" }, ); + + if (yield* Ref.get(localDirModeRef)) { + yield* electronWindow.destroyAll; + yield* logUpdaterInfo("relaunching for dir-installed build update"); + yield* electronApp.relaunch({ + execPath: process.execPath, + args: process.argv.slice(1), + }); + yield* electronApp.quit; + return { accepted: true, completed: false, failed: false }; + } + yield* electronUpdater.quitAndInstall({ isSilent: true, isForceRunAfter: true, @@ -882,6 +1014,16 @@ export const make = Effect.gen(function* () { if (!enabled) { return; } + + if (isLinuxDirStyleInstall) { + yield* Ref.set(localDirModeRef, true); + yield* logUpdaterInfo( + "dir install mode: using on-disk build detection (no network updater)", + ); + yield* startLocalDirProbes; + return; + } + yield* Ref.set(updaterConfiguredRef, true); yield* electronUpdater.setAutoDownload(false); @@ -966,7 +1108,7 @@ export const make = Effect.gen(function* () { }), check: Effect.fn("desktop.updates.check")(function* (reason: string) { yield* Effect.annotateCurrentSpan({ reason }); - if (!(yield* Ref.get(updaterConfiguredRef))) { + if (!(yield* Ref.get(updaterConfiguredRef)) && !(yield* Ref.get(localDirModeRef))) { return { checked: false, state: yield* Ref.get(updateStateRef), diff --git a/apps/desktop/src/updates/updatesTestHarness.ts b/apps/desktop/src/updates/updatesTestHarness.ts index cd1404a50464..c149446a30bb 100644 --- a/apps/desktop/src/updates/updatesTestHarness.ts +++ b/apps/desktop/src/updates/updatesTestHarness.ts @@ -7,6 +7,7 @@ import * as Option from "effect/Option"; import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts"; import * as DesktopConfig from "../app/DesktopConfig.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; +import * as ElectronApp from "../electron/ElectronApp.ts"; import * as ElectronUpdater from "../electron/ElectronUpdater.ts"; import * as ElectronWindow from "../electron/ElectronWindow.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; @@ -104,6 +105,30 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) { ).pipe(Effect.asVoid), } satisfies ElectronUpdater.ElectronUpdater["Service"]); + const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, { + metadata: Effect.die("unexpected metadata read"), + name: Effect.succeed("T3 Code"), + systemLocale: Effect.succeed("en-US"), + whenReady: Effect.void, + quit: Effect.void, + exit: () => Effect.void, + relaunch: () => Effect.void, + setPath: () => Effect.void, + setName: () => Effect.void, + setAboutPanelOptions: () => Effect.void, + setAppUserModelId: () => Effect.void, + requestSingleInstanceLock: Effect.succeed(true), + getAppMetrics: Effect.succeed([]), + isDefaultProtocolClient: () => Effect.succeed(false), + setAsDefaultProtocolClient: () => Effect.succeed(true), + setDesktopName: () => Effect.void, + setDockIcon: () => Effect.void, + appendCommandLineSwitch: () => Effect.void, + removeCommandLineSwitch: () => Effect.void, + onBeforeQuitForUpdate: () => Effect.void, + on: () => Effect.void, + } satisfies ElectronApp.ElectronApp["Service"]); + const windowLayer = Layer.succeed(ElectronWindow.ElectronWindow, { create: () => Effect.die("unexpected BrowserWindow creation"), main: Effect.succeed(Option.none()), @@ -204,6 +229,7 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) { const layer = DesktopUpdates.layer.pipe( Layer.provideMerge(updaterLayer), + Layer.provideMerge(electronAppLayer), Layer.provideMerge(windowLayer), Layer.provideMerge(backendLayer), Layer.provideMerge(DesktopState.layer), diff --git a/apps/desktop/src/window/DesktopApplicationMenu.test.ts b/apps/desktop/src/window/DesktopApplicationMenu.test.ts index eeb0c86f031c..5db8a9e2fc5b 100644 --- a/apps/desktop/src/window/DesktopApplicationMenu.test.ts +++ b/apps/desktop/src/window/DesktopApplicationMenu.test.ts @@ -40,6 +40,7 @@ const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, { setName: () => Effect.void, setAboutPanelOptions: () => Effect.void, setAppUserModelId: () => Effect.void, + requestSingleInstanceLock: Effect.succeed(true), getAppMetrics: Effect.succeed([]), isDefaultProtocolClient: () => Effect.succeed(false), setAsDefaultProtocolClient: () => Effect.succeed(true), @@ -53,6 +54,7 @@ const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, { const electronDialogLayer = Layer.succeed(ElectronDialog.ElectronDialog, { pickFolder: () => Effect.succeed(Option.none()), + pickApplication: () => Effect.succeed(Option.none()), pickFiles: () => Effect.succeed([]), showMessageBox: () => Effect.succeed({ response: 0, checkboxChecked: false }), showErrorBox: () => Effect.void, @@ -90,6 +92,8 @@ const makeDesktopWindowLayer = (selectedAction: Deferred.Deferred) => zoomMain: (direction) => Deferred.succeed(selectedAction, `zoom-${direction}`).pipe(Effect.asVoid), syncAppearance: Effect.void, + navigateToThread: () => Effect.void, + navigateToProject: () => Effect.void, } satisfies DesktopWindow.DesktopWindow["Service"]); const makeElectronMenuLayer = ( diff --git a/apps/desktop/src/window/DesktopWindow.test.ts b/apps/desktop/src/window/DesktopWindow.test.ts index 7bbb5c1da024..af7199ec6456 100644 --- a/apps/desktop/src/window/DesktopWindow.test.ts +++ b/apps/desktop/src/window/DesktopWindow.test.ts @@ -35,6 +35,8 @@ vi.mock("electron", async (importOriginal) => ({ }, })); +import { EnvironmentId, ThreadId } from "@t3tools/contracts"; + import * as DesktopAssets from "../app/DesktopAssets.ts"; import * as DesktopConfig from "../app/DesktopConfig.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; @@ -1400,6 +1402,94 @@ describe("DesktopWindow", () => { }), ); + it.effect("queues navigation before the main window is ready and applies it on create", () => + Effect.gen(function* () { + const fakeWindow = makeFakeBrowserWindow(); + const createCount = yield* Ref.make(0); + const mainWindow = yield* Ref.make>(Option.none()); + const layer = makeTestLayer({ + window: fakeWindow.window, + createCount, + mainWindow, + }); + + yield* Effect.gen(function* () { + const desktopWindow = yield* DesktopWindow.DesktopWindow; + yield* desktopWindow.navigateToThread({ + environmentId: EnvironmentId.make("db6d1813-ace4-42bd-9bce-e04ee27e97ff"), + threadId: ThreadId.make("ebf3a84d-7f60-4809-a5e0-bbd574275463"), + }); + assert.equal(yield* Ref.get(createCount), 0); + assert.equal(fakeWindow.loadURL.mock.calls.length, 0); + + yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773")); + assert.equal(yield* Ref.get(createCount), 1); + assert.deepEqual(fakeWindow.loadURL.mock.calls[0], [ + "t3code-dev://app/#/db6d1813-ace4-42bd-9bce-e04ee27e97ff/ebf3a84d-7f60-4809-a5e0-bbd574275463", + ]); + }).pipe(Effect.provide(layer)); + }), + ); + + it.effect("navigates an existing main window to the encoded canonical route", () => + Effect.gen(function* () { + const fakeWindow = makeFakeBrowserWindow(); + const createCount = yield* Ref.make(0); + const mainWindow = yield* Ref.make>(Option.none()); + const layer = makeTestLayer({ + window: fakeWindow.window, + createCount, + mainWindow, + }); + + yield* Effect.gen(function* () { + const desktopWindow = yield* DesktopWindow.DesktopWindow; + yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773")); + fakeWindow.loadURL.mockClear(); + + yield* desktopWindow.navigateToThread({ + environmentId: EnvironmentId.make("db6d1813-ace4-42bd-9bce-e04ee27e97ff"), + threadId: ThreadId.make("ebf3a84d-7f60-4809-a5e0-bbd574275463"), + }); + + assert.equal(yield* Ref.get(createCount), 1); + assert.deepEqual(fakeWindow.loadURL.mock.calls, [ + [ + "t3code-dev://app/#/db6d1813-ace4-42bd-9bce-e04ee27e97ff/ebf3a84d-7f60-4809-a5e0-bbd574275463", + ], + ]); + }).pipe(Effect.provide(layer)); + }), + ); + + it.effect("navigates an existing main window to a project jump route", () => + Effect.gen(function* () { + const fakeWindow = makeFakeBrowserWindow(); + const createCount = yield* Ref.make(0); + const mainWindow = yield* Ref.make>(Option.none()); + const layer = makeTestLayer({ + window: fakeWindow.window, + createCount, + mainWindow, + }); + + yield* Effect.gen(function* () { + const desktopWindow = yield* DesktopWindow.DesktopWindow; + yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773")); + fakeWindow.loadURL.mockClear(); + + yield* desktopWindow.navigateToProject({ + project: "macs-holding/scanner", + action: "latest", + }); + + assert.deepEqual(fakeWindow.loadURL.mock.calls, [ + ["t3code-dev://app/#/jump?project=macs-holding%2Fscanner&action=latest"], + ]); + }).pipe(Effect.provide(layer)); + }), + ); + it.effect("delivers capture completion and late errors without taking focus back", () => Effect.gen(function* () { const operations: Array = []; diff --git a/apps/desktop/src/window/DesktopWindow.ts b/apps/desktop/src/window/DesktopWindow.ts index 0a966ec36e4d..b8004d72a36c 100644 --- a/apps/desktop/src/window/DesktopWindow.ts +++ b/apps/desktop/src/window/DesktopWindow.ts @@ -1,3 +1,4 @@ +import type { EnvironmentId, ThreadId } from "@t3tools/contracts"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; @@ -14,7 +15,11 @@ import * as DesktopAssets from "../app/DesktopAssets.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import { makeComponentLogger } from "../app/DesktopObservability.ts"; import * as ElectronMenu from "../electron/ElectronMenu.ts"; -import { getDesktopUrl } from "../electron/ElectronProtocol.ts"; +import { + buildDesktopProjectNavigationUrl, + buildDesktopThreadNavigationUrl, + getDesktopUrl, +} from "../electron/ElectronProtocol.ts"; import * as ElectronShell from "../electron/ElectronShell.ts"; import * as ElectronTheme from "../electron/ElectronTheme.ts"; import * as ElectronWindow from "../electron/ElectronWindow.ts"; @@ -119,6 +124,20 @@ export class DesktopWindow extends Context.Service< // the main window. readonly zoomMain: (direction: MainWindowZoomDirection) => Effect.Effect; readonly syncAppearance: Effect.Effect; + /** + * Navigate the main window to the canonical thread route + * (`#/$environmentId/$threadId`). Reuses or creates the main window, + * preserves backend-readiness/splash behavior, and retains one pending + * target when the renderer is not yet navigable (newest wins). + */ + readonly navigateToThread: (input: { + readonly environmentId: EnvironmentId; + readonly threadId: ThreadId; + }) => Effect.Effect; + readonly navigateToProject: (input: { + readonly project: string; + readonly action: "reveal" | "latest" | "new"; + }) => Effect.Effect; } >()("@t3tools/desktop/window/DesktopWindow") {} @@ -311,11 +330,46 @@ export const make = Effect.gen(function* () { // The transient "Connecting to WSL" splash window, tracked separately so it // is never mistaken for the real main window. const splashWindowRef = yield* Ref.make>(Option.none()); + // Single pending deep-link route. Newest wins when several arrive during + // startup or while the main window is still loading. + const pendingNavigationUrlRef = yield* Ref.make>(Option.none()); const context = yield* Effect.context(); const runFork = Effect.runForkWith(context); const runPromise = Effect.runPromiseWith(context); let flushMainWindowBounds: Effect.Effect = Effect.void; + const loadPendingNavigationOnWindow = (window: Electron.BrowserWindow): void => { + if (window.isDestroyed()) { + return; + } + const apply = () => { + void runPromise( + Effect.gen(function* () { + if (window.isDestroyed()) { + return; + } + const pending = yield* Ref.get(pendingNavigationUrlRef); + if (Option.isNone(pending)) { + return; + } + void window.loadURL(pending.value).catch(() => undefined); + // Clear only the route we applied so a newer pending target is kept. + yield* Ref.update(pendingNavigationUrlRef, (current) => { + if (Option.isSome(current) && current.value === pending.value) { + return Option.none(); + } + return current; + }); + }), + ); + }; + if (window.webContents.isLoadingMainFrame()) { + window.webContents.once("did-finish-load", apply); + return; + } + apply(); + }; + const dismissConnectingSplash = Effect.gen(function* () { const splash = yield* Ref.getAndSet(splashWindowRef, Option.none()); if (Option.isSome(splash) && !splash.value.isDestroyed()) { @@ -679,7 +733,27 @@ export const make = Effect.gen(function* () { if (window.isDestroyed()) { return; } - void window.loadURL(applicationUrl).catch(() => undefined); + void runPromise( + Effect.gen(function* () { + const pending = yield* Ref.get(pendingNavigationUrlRef); + const url = Option.getOrElse(pending, () => applicationUrl); + if (window.isDestroyed()) { + return; + } + void window.loadURL(url).catch(() => undefined); + if (Option.isNone(pending)) { + return; + } + // Drop only the route we just loaded. A newer deep link that arrived + // after we read pending must stay queued. + yield* Ref.update(pendingNavigationUrlRef, (current) => { + if (Option.isSome(current) && current.value === pending.value) { + return Option.none(); + } + return current; + }); + }), + ); }; const scheduleDevelopmentLoadRetry = () => { if (developmentLoadRetryFiber !== undefined || window.isDestroyed()) { @@ -995,6 +1069,72 @@ export const make = Effect.gen(function* () { syncWindowAppearance(window, shouldUseDarkColors, environment.platform), ); }).pipe(Effect.withSpan("desktop.window.syncAppearance")), + navigateToThread: Effect.fn("desktop.window.navigateToThread")(function* (input) { + yield* Effect.annotateCurrentSpan({ + environmentId: input.environmentId, + threadId: input.threadId, + }); + // Newest deep link wins if several arrive before navigation applies. + yield* Ref.set( + pendingNavigationUrlRef, + Option.some( + buildDesktopThreadNavigationUrl({ + isDevelopment: environment.isDevelopment, + environmentId: input.environmentId, + threadId: input.threadId, + }), + ), + ); + + const existingWindow = yield* currentMainWindow; + if (Option.isSome(existingWindow)) { + const window = existingWindow.value; + loadPendingNavigationOnWindow(window); + yield* electronWindow.reveal(window); + yield* logWindowInfo("navigated main window to deep-linked thread"); + return; + } + + // No real main window yet. Keep the pending route so createWindow's + // initial load uses the thread URL. Create immediately when the backend + // is ready; otherwise handleBackendReady / createMainIfBackendReady will + // open the window and pick up the pending target. + yield* createMainIfBackendReady; + const createdWindow = yield* currentMainWindow; + if (Option.isSome(createdWindow)) { + // createWindow already scheduled the pending URL via loadApplication. + yield* electronWindow.reveal(createdWindow.value); + yield* logWindowInfo("created main window for deep-linked thread"); + return; + } + + yield* logWindowInfo("queued deep-linked thread until main window is navigable"); + }), + navigateToProject: Effect.fn("desktop.window.navigateToProject")(function* (input) { + yield* Ref.set( + pendingNavigationUrlRef, + Option.some( + buildDesktopProjectNavigationUrl({ + isDevelopment: environment.isDevelopment, + project: input.project, + action: input.action, + }), + ), + ); + + const existingWindow = yield* currentMainWindow; + if (Option.isSome(existingWindow)) { + loadPendingNavigationOnWindow(existingWindow.value); + yield* electronWindow.reveal(existingWindow.value); + return; + } + + yield* createMainIfBackendReady; + const createdWindow = yield* currentMainWindow; + if (Option.isSome(createdWindow)) { + yield* electronWindow.reveal(createdWindow.value); + } + }), }); }); diff --git a/apps/desktop/src/wsl/DesktopWslEnvironment.test.ts b/apps/desktop/src/wsl/DesktopWslEnvironment.test.ts index e1188e1a3387..714240d17546 100644 --- a/apps/desktop/src/wsl/DesktopWslEnvironment.test.ts +++ b/apps/desktop/src/wsl/DesktopWslEnvironment.test.ts @@ -645,7 +645,10 @@ describe.skipIf(posixShellRunner === null)("WSL runtime install script (executed `runtime_root=${sh(fixture.runtimeRoot)}`, `runtime_parent=${sh(fixture.runtimeParent)}`, 'rm "$runtime_root/.t3code-wsl-runtime-ready"', - 'sh -c "sleep 30" "$runtime_root/apps/server/dist/bin.mjs" >/dev/null 2>&1 &', + // Keep the shell alive so argv still contains the runtime path. A + // last-command `sleep` is exec'd on this host and the path vanishes + // from /proc/cmdline, so runtime_in_use cannot see the fake backend. + 'sh -c "while :; do sleep 1; done" "$runtime_root/apps/server/dist/bin.mjs" >/dev/null 2>&1 &', "active_pid=$!", "sleep 0.1", fixture.installScript(), @@ -683,7 +686,7 @@ describe.skipIf(posixShellRunner === null)("WSL runtime install script (executed 'touch -d "4 minutes ago" "$runtime_parent/sha256-active"', 'touch -d "3 minutes ago" "$runtime_parent/sha256-old"', 'touch -d "2 minutes ago" "$runtime_parent/sha256-locked"', - 'sh -c "sleep 30" "$runtime_parent/sha256-active/apps/server/dist/bin.mjs" >/dev/null 2>&1 &', + 'sh -c "while :; do sleep 1; done" "$runtime_parent/sha256-active/apps/server/dist/bin.mjs" >/dev/null 2>&1 &', "active_pid=$!", "(", ' exec 9> "$runtime_parent/.sha256-locked.install.lock"', diff --git a/apps/desktop/src/wsl/DesktopWslEnvironment.ts b/apps/desktop/src/wsl/DesktopWslEnvironment.ts index 79d2213d6990..83a8ed7dd998 100644 --- a/apps/desktop/src/wsl/DesktopWslEnvironment.ts +++ b/apps/desktop/src/wsl/DesktopWslEnvironment.ts @@ -1218,15 +1218,14 @@ export const layer = Layer.effect( // distro. Negative results aren't cached so a transient wsl.exe failure // doesn't permanently disable tilde expansion. const userHomeCache = new Map(); - const getUserHome = (distro: string | null) => - Effect.gen(function* () { - const key = distro ?? "__default__"; - const cached = userHomeCache.get(key); - if (cached !== undefined) return Option.some(cached); - const resolved = yield* provideSpawner(getUserHomeImpl(distro)); - if (Option.isSome(resolved)) userHomeCache.set(key, resolved.value); - return resolved; - }).pipe(Effect.withSpan("desktop.wsl.getUserHome")); + const getUserHome = Effect.fn("desktop.wsl.getUserHome")(function* (distro: string | null) { + const key = distro ?? "__default__"; + const cached = userHomeCache.get(key); + if (cached !== undefined) return Option.some(cached); + const resolved = yield* provideSpawner(getUserHomeImpl(distro)); + if (Option.isSome(resolved)) userHomeCache.set(key, resolved.value); + return resolved; + }); const getDistroIp = (distro: string | null) => provideSpawner(getDistroIpImpl(distro)).pipe(Effect.withSpan("desktop.wsl.getDistroIp")); diff --git a/apps/desktop/vite.config.ts b/apps/desktop/vite.config.ts index ac055a0f5bac..725058323b39 100644 --- a/apps/desktop/vite.config.ts +++ b/apps/desktop/vite.config.ts @@ -1,8 +1,50 @@ import "vite-plus/test/config"; import { defineConfig } from "vite-plus"; +import { defineProject } from "vite-plus/test/config"; import { loadRepoEnv } from "../../scripts/lib/public-config.ts"; +const isolatedDesktopTestFiles = [ + "src/app/DesktopClerk.test.ts", + "src/app/DesktopPreReadyPlatform.test.ts", + "src/backend/DesktopNetworkInterfaces.test.ts", + "src/electron/ElectronApp.test.ts", + "src/electron/ElectronDialog.test.ts", + "src/electron/ElectronMenu.test.ts", + "src/electron/ElectronProtocol.test.ts", + "src/electron/ElectronShell.test.ts", + "src/electron/ElectronTheme.test.ts", + "src/electron/ElectronUpdater.test.ts", + "src/electron/ElectronWindow.test.ts", + "src/electron/WindowsForegroundFocusThread.test.ts", + "src/electron/MacApplicationIcon.test.ts", + "src/ipc/methods/preview.test.ts", + "src/preview/BrowserSession.test.ts", + "src/preview/Manager.test.ts", + // Window-capture tests mock electron/nativeImage/child_process. Under + // isolate:false those mocks leak and later files see a half-applied vi.mock. + "src/snapShot/ActiveWindow.test.ts", + "src/snapShot/CaptureShortcutConfig.test.ts", + "src/snapShot/DesktopSnapShot.test.ts", + "src/snapShot/GnomeCaptureSetup.test.ts", + "src/snapShot/HyprlandSnapShot.test.ts", + "src/snapShot/KdeSnapShot.test.ts", + "src/snapShot/LinuxSnapShot.dbus.test.ts", + "src/snapShot/LinuxSnapShot.test.ts", + "src/snapShot/MacModifierPairShortcutProcess.test.ts", + "src/snapShot/MacSnapShot.test.ts", + "src/snapShot/NativeCaptureFeedback.test.ts", + "src/snapShot/NiriSnapShot.test.ts", + "src/snapShot/PortalCaptureShortcut.dbus.test.ts", + "src/snapShot/PortalCaptureShortcut.test.ts", + "src/snapShot/RegionSnapShot.test.ts", + "src/snapShot/SnapShotAccessibilityProcess.test.ts", + "src/snapShot/WindowsCaptureFeedback.test.ts", + "src/snapShot/captureConfigEdit.test.ts", + "src/snapShot/snapShot.test.ts", + "src/window/DesktopWindow.test.ts", +] as const; + const repoEnv = loadRepoEnv(); const shouldLaunchElectronAfterPack = process.env.T3CODE_DESKTOP_DEV === "1"; const publicConfigDefine = { @@ -12,6 +54,39 @@ const publicConfigDefine = { }; export default defineConfig({ + test: { + projects: [ + defineProject({ + test: { + name: "desktop", + environment: "node", + include: ["src/**/*.test.ts"], + exclude: [...isolatedDesktopTestFiles], + isolate: false, + fileParallelism: true, + maxWorkers: 4, + hookTimeout: 60_000, + testTimeout: 60_000, + }, + }), + defineProject({ + test: { + name: "desktop-isolated-module-mocks", + environment: "node", + include: [...isolatedDesktopTestFiles], + isolate: true, + fileParallelism: true, + maxWorkers: 1, + hookTimeout: 60_000, + testTimeout: 60_000, + }, + }), + ], + // The Windows lane runs workspace suites concurrently; filesystem-heavy + // desktop integration tests can exceed Vitest's 5 second default there. + testTimeout: 15_000, + setupFiles: ["../../packages/shared/src/testing/longTempDir.ts"], + }, run: { tasks: { build: { @@ -94,10 +169,4 @@ export default defineConfig({ entry: ["src/preview-pip-preload.ts"], }, ], - test: { - // The Windows lane runs workspace suites concurrently; filesystem-heavy - // desktop integration tests can exceed Vitest's 5 second default there. - testTimeout: 15_000, - setupFiles: ["../../packages/shared/src/testing/longTempDir.ts"], - }, }); diff --git a/apps/discord-bot/DESIGN-thread-restore.md b/apps/discord-bot/DESIGN-thread-restore.md new file mode 100644 index 000000000000..2ba1c88d949c --- /dev/null +++ b/apps/discord-bot/DESIGN-thread-restore.md @@ -0,0 +1,321 @@ +# Discord bot: restore thread bridges after restart + +**Status:** implemented (boot + T3 reconnect rehydrate) +**Branch context:** Discord bot restore bridges on start +**Non-goals for implementers:** do not deploy/restart microVM or host services as part of this design work unless explicitly asked later. + +## Problem + +After the Discord bot process restarts (or the T3 WebSocket session is replaced): + +- Durable **Discord ↔ T3** links already exist in `links.json`. +- **Live** T3 `subscribeThread` bridges and in-memory stream state do **not**. +- In-flight turns go silent on Discord until a human `@mention`s again. +- Completed turns that finished while the bot was down may never get a Discord final post. + +Mentions still **continue** the same T3 thread (lookup works). What is missing is **automatic re-attach + catch-up finalize**. + +## Goals + +1. On bot boot (and T3 reconnect), re-establish bridges for the right set of links. +2. If a turn finished offline, run the **normal finalize path**: remove in-progress stream tips (from **stored ids only**), post final answer + `stream-history.md` as today. +3. Cap concurrent bridges; prefer freshest activity. + +## Non-goals (v1) + +- Multi-bot HA / shared remote DB. +- Scanning arbitrary Discord threads for `_Working.._` outside stored stream message ids. +- Restoring idle historical links “just in case.” +- Perfect recovery of Discord message identity when stream tip ids were never persisted. + +--- + +## Locked decisions + +| # | Decision | +| --- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | **Restore set:** only threads that are **running** or **pending** (approval / user-input). Not idle/recent-by-default. | +| 2 | **Missed finalize:** **auto-post** to Discord using the usual pipeline — find previous in-progress messages for that turn (via **stored** tip/stale ids), replace with final message(s) + stream-history transcript. | +| 3 | **Orphan cleanup:** **only stored stream message ids**. Do not scan other channels/threads for Working.. markers. | +| 4 | **Cap:** max **50** concurrent bridges. When over capacity, **drop oldest by `lastActivityAt`** (do not restore / evict ensure). | + +--- + +## Current building blocks + +| Piece | Location | Notes | +| -------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------- | +| Link store | `apps/discord-bot/src/store/ThreadLinkStore.ts` | `$T3_DISCORD_BOT_DATA_DIR/links.json` | +| Link fields today | `discordThreadId`, `t3ThreadId`, `projectId`, `channelId`, `guildId`, `createdAt` | Written on first worktree turn | +| Bridge entry | `bridgeThreadToDiscord` in `ResponseBridge.ts` | In-memory `bridgeFibers` only | +| Adopt-without-repost | `adoptedInitialSnapshot` in bridge | Avoids re-posting completed answers on re-subscribe | +| Finalize | `finalizeAssistantMessage` | Create final + delete stream tip ids; stream-history.md | + +Guest path today: `/var/lib/t3/discord-bot/links.json`. + +--- + +## Architecture + +``` +main.ts boot / T3 reconnect + │ + ▼ + ThreadLinkStore.list() + │ + ▼ + selectCandidates(running | pending) + │ + ▼ + rank by lastActivityAt desc, take ≤ 50 + │ + ▼ + BridgeHub.ensure(link) ──singleflight per discordThreadId──► + │ + ├── subscribeThread(t3ThreadId) + ├── snapshot: turn running? → resume stream tips (new tip if needed) + └── snapshot: turn complete + not finalized on Discord? + → finalize (delete stored openStreamMessageIds, post final + transcript) +``` + +**Link** = durable mapping. +**Bridge** = live fiber + ephemeral Discord stream state. +Boot/reconnect turns links → bridges for the selected subset only. + +--- + +## Data model (links.json v2) + +Version the document so old arrays still load. + +```json +{ + "version": 2, + "links": [ + { + "discordThreadId": "string", + "t3ThreadId": "string", + "projectId": "string", + "channelId": "string", + "guildId": "string", + "createdAt": "ISO-8601", + "updatedAt": "ISO-8601", + "lastActivityAt": "ISO-8601", + "status": "active", + "lastSeenTurnId": null, + "lastFinalizedAssistantId": null, + "openStreamMessageIds": [] + } + ] +} +``` + +| Field | Purpose | +| ---------------------------- | ---------------------------------------------------------------------------------------------- | +| `lastActivityAt` | Eviction order; touch on mention, bridge event, put | +| `status` | `active` \| `tombstone` (missing Discord/T3 thread) | +| `lastSeenTurnId` | Correlate turn for catch-up finalize | +| `lastFinalizedAssistantId` | Skip re-finalizing the same assistant bubble | +| `lastThreadSnapshotSequence` | Orchestration cursor for performant `subscribeThread({ afterSequence })` resume | +| `lastDeliveredSequence` | Advances only after Discord delivery succeeds; lag vs orchestration triggers catch-up | +| `openStreamMessageIds` | Discord message ids for in-progress tips (+ stale tips). **Only** these are deleted on cleanup | + +**Migration:** if file is a bare array (v1), wrap as `{ version: 2, links: [...] }` and default `lastActivityAt = createdAt`, empty stream ids, `status: active`. + +**Store API additions:** + +- `getByT3ThreadId` +- `touch(discordThreadId, at?)` +- `tombstone(discordThreadId)` +- `updateBridgeHints(discordThreadId, partial)` — stream ids, last finalized assistant, lastSeenTurnId +- Atomic write: temp file + rename; mode `0o600` + +--- + +## BridgeHub + +Extract from ad-hoc `bridgeFibers` in `ResponseBridge.ts`. + +| Method | Behavior | +| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | +| `ensure(link, opts?)` | Singleflight per `discordThreadId`. If live fiber exists, no-op (or replace if `t3ThreadId` changed). Starts `runBridge`. | +| `drop(discordThreadId)` | Interrupt fiber; clear memory only (keep durable link). | +| `listActive()` | Ops / alerts | +| Cap enforcement | Before ensure beyond 50: drop active bridges with oldest `lastActivityAt` among **active fibers**, or skip restore of older candidates | + +`bridgeThreadToDiscord` becomes a thin wrapper around `BridgeHub.ensure` (callers: MentionRouter, boot rehydrate, T3 reconnect). + +**Opts (v1):** + +- `workingAckMessageId?` — only from mention path +- `mode: "interactive" | "rehydrate"` — rehydrate skips posting a new Working.. unless turn is running and no tip exists + +--- + +## Candidate selection (decision 1) + +For each `status === active` link: + +1. Resolve T3 thread from shell / thread detail (skip + tombstone if missing). +2. Resolve Discord channel (GET); on 404 tombstone. +3. Include if **any** of: + - `latestTurn.state === "running"` (or equivalent “in progress”) + - pending approval(s) on the thread + - pending user-input request(s) +4. Exclude idle completed threads (they restore **lazily** on next `@mention` via existing link lookup). + +Sort included candidates by `lastActivityAt` **descending**. +Take first **50**. Log dropped count. + +--- + +## Catch-up finalize (decision 2 + 3) + +When rehydrate snapshot shows: + +- Turn **not** running, and +- There is a completed assistant answer for the last user turn, and +- `assistant.id !== lastFinalizedAssistantId` (or open stream ids still present / never finalized), + +then run the **same** finalize path as live turns: + +1. Load `openStreamMessageIds` from the link (and any in-memory state if fiber just started). +2. **Delete only those ids** (decision 3) — no channel-wide Working.. scan. +3. Post final answer text (use existing `finalAnswerText` / finalize rules) + attachments. +4. Attach `stream-history.md` from accumulated progress text when available (from T3 messages this turn if stream text was not in memory). +5. Persist `lastFinalizedAssistantId`, clear `openStreamMessageIds`, `touch` link. + +If turn is **still running**: + +- `ensure` bridge, adopt snapshot, open/edit a stream tip if needed. +- Prefer reusing stored tip ids when still editable and latest; else create a new tip and **append** id to `openStreamMessageIds` (leave old ids listed so finalize still deletes them). +- Do not invent tips in unrelated threads. + +**Transcript source when process memory is empty:** reconstruct from T3 thread messages after last user message (same as `turnProgressText`), not from Discord history scraping. + +--- + +## Boot sequence + +``` +1. DiscordBotRunning / gateway up +2. t3.connect() +3. migrate links.json if needed +4. candidates = select running|pending +5. sort by lastActivityAt desc; cap 50 +6. for each candidate (concurrency 3–5): + BridgeHub.ensure(link, { mode: "rehydrate" }) +7. log: restored / failed / tombstoned / capped-out +8. Effect.never (existing) +``` + +Do **not** restart microVM or host units for this feature. + +--- + +## T3 WebSocket reconnect + +When `T3Session` replaces the session (existing pattern clears thread fibers): + +1. Interrupt / clear BridgeHub fibers (or they die with subscribe). +2. Re-run the **same** candidate selection + ensure (running|pending, cap 50). +3. Catch-up finalize again if turns completed during the outage. + +--- + +## Mention path (unchanged contract) + +- Resolve link by Discord thread id. +- `touch` + `BridgeHub.ensure` + `startTurn` as today. +- On first link create, `put` full record with `lastActivityAt = now`. +- While streaming, bridge **must** persist `openStreamMessageIds` (and stale tip ids) on each tip create/displace so restart cleanup works (decision 3). + +--- + +## Eviction (decision 4) + +- **Hard cap:** 50 concurrent **active bridges**. +- When selecting restores: only top 50 by `lastActivityAt`. +- If an interactive mention needs a bridge while at 50: + - Prefer evicting the active bridge with oldest `lastActivityAt` that is **not** running/pending; if all 50 are running/pending, log error / alert and still ensure the mentioned thread (or refuse with a Discord error — **prefer ensure mentioned thread** and drop oldest non-critical). +- Evict = `drop` fiber only; **keep** durable link. + +Suggested priority for forced eviction: idle completed bridges first; never evict `running` or pending-approval if avoidable. + +--- + +## Failure modes + +| Case | Handling | +| ---------------------------------- | ----------------------------------------------------------------- | +| Discord thread deleted | Tombstone link; skip | +| T3 thread missing | Tombstone link; skip | +| Subscribe timeout | Log + ops alert; leave link active for next mention | +| Finalize fails (Discord 4xx/5xx) | Log + alert; keep `openStreamMessageIds` for retry on next ensure | +| Corrupt links.json | Load empty / backup; do not crash bot | +| Stream ids stale (already deleted) | Delete is best-effort (ignore 404); clear hints after attempt | + +--- + +## Implementation PRs + +### PR1 — Store v2 + BridgeHub shell + +- Versioned links schema + migration +- `getByT3ThreadId`, `touch`, `tombstone`, `updateBridgeHints` +- `BridgeHub` with singleflight `ensure` / `drop` / cap stub +- Wire MentionRouter to Hub without behavior change +- Tests: migrate v1→v2, put/get/touch + +### PR2 — Persist stream message ids + +- Bridge writes `openStreamMessageIds` (+ stale) on tip create/displace/clear on finalize +- Tests: hints updated; finalize clears + +### PR3 — Boot + reconnect rehydrate + +- `selectCandidates(running|pending)` +- Cap 50 by `lastActivityAt` +- `main.ts` after connect; T3 session replace hook +- Catch-up finalize when turn complete and not yet finalized +- Integration-style tests with fakes + +### PR4 — Eviction polish + alerts + +- Cap eviction policy +- Ops alert on rehydrate failures / finalize retry exhaustion +- Docs: `docs/integrations/discord-bot.md` short section + +--- + +## Success criteria + +1. Bot killed mid-turn → start bot → Discord stream resumes or finalizes **without** a new `@mention`. +2. Turn completed while bot down → on boot, Discord gets **one** final post + transcript; stored tip ids removed; **no** duplicate finals on second restart. +3. Idle linked threads: no bridge until next mention; mention still continues T3 thread. +4. Never deletes messages outside `openStreamMessageIds` for that link. +5. ≤ 50 bridges; overflow prefers freshest `lastActivityAt`. +6. T3 WS reconnect re-applies the same restore rules. + +--- + +## File touch map (expected) + +| Path | Change | +| ------------------------------------------------- | ------------------------------------------------------- | +| `apps/discord-bot/src/store/ThreadLinkStore.ts` | v2 schema, migration, new APIs | +| `apps/discord-bot/src/features/BridgeHub.ts` | new | +| `apps/discord-bot/src/features/ResponseBridge.ts` | hub integration, persist stream ids, rehydrate finalize | +| `apps/discord-bot/src/features/MentionRouter.ts` | ensure via hub, touch | +| `apps/discord-bot/src/t3/T3Session.ts` | reconnect callback / re-ensure hook | +| `apps/discord-bot/src/main.ts` | boot rehydrate | +| `apps/discord-bot/src/**/*.test.ts` | store, hub, candidate selection | +| `docs/integrations/discord-bot.md` | operator-facing restore notes | + +--- + +## Out of scope reminders + +- Do not depend on Honeycomb/Sentry for restore logic. +- Do not scan guild history for orphan Working.. messages. +- Do not restore all historical links by default. diff --git a/apps/discord-bot/docs/agent-turn-rules.md b/apps/discord-bot/docs/agent-turn-rules.md new file mode 100644 index 000000000000..7b97c93601c0 --- /dev/null +++ b/apps/discord-bot/docs/agent-turn-rules.md @@ -0,0 +1,29 @@ +# Discord turn rules (client overlay) + +**Layer:** Discord overlay on top of global T3 product rules. + +Global product policy lives in `apps/server/docs/t3-agent-rules.md` and is +injected by the T3 server on session start (and again after compaction). This +file is **only** Discord-specific policy. Do not restate global rules here. + +You = Discord bot. Final reply posts in-thread. Do not comment on Jira, GitHub, +or Confluence unless the user explicitly asked. "you" = you unless another person is named. +Don't mix up requester vs thread starter vs others. + +**Style:** lead with answer; concise; no status recaps. + +**PR:** always open for commits/landable work; draft until lint/typecheck/tests/`vp check`; then mark ready. No abandoned drafts. +**PR lifecycle:** before push/handoff, check the linked PR is still **open** (`gh pr view --json state` or equivalent). If **merged** or **closed**, do **not** keep committing on that branch — branch fresh from `fork/dev`, re-apply unmerged work, open a **new** PR (draft if still iterating). One merged PR is not a free ticket for later commits. + +**PR footer** from turn `pr` + `t3` fields (paste at PR body end; bot may re-append): +`opened by [{name}](https://discord.com/users/{uid}) in chat thread **Discord** · [{title}](https://discord.com/channels/{g}/{c}/{m}) · [T3]({t3url})` +URL forms only; never bare snowflakes. +**t3url:** private GitHub repo → turn `t3 full=…`; public repo → turn `t3 short=…` (host is always just `t3vm`). Prefer short when unsure (don't leak internal hosts on public PRs). + +**jira:** put turn keys in PR body (prefer primary in title/branch). Keys are +context, not a request to comment on the issue. +**sentry:** turn `sentry:` URLs are Sentry issues — not Jira. Fetch via Sentry MCP. + +**ref:** referenced msg is primary context when present. + +**Sentry:** parse starter/ref → Sentry for trace id → Honeycomb link first (turn tpl) → then user ask. Don't invent data; report tool failures. diff --git a/apps/discord-bot/package.json b/apps/discord-bot/package.json new file mode 100644 index 000000000000..ec71943dd330 --- /dev/null +++ b/apps/discord-bot/package.json @@ -0,0 +1,35 @@ +{ + "name": "@t3tools/discord-bot", + "version": "0.0.1", + "private": true, + "type": "module", + "scripts": { + "browser-profile": "node --import tsx src/browserProfileCli.ts", + "dev": "node --watch --import tsx src/main.ts", + "dev:teams": "node --watch --import tsx src/teams-main.ts", + "start": "node --import tsx src/main.ts", + "start:teams": "node --import tsx src/teams-main.ts", + "typecheck": "tsc --noEmit", + "test": "vp test run" + }, + "dependencies": { + "@effect/platform-node": "catalog:", + "@microsoft/teams.apps": "2.0.14", + "@t3tools/client-runtime": "workspace:*", + "@t3tools/contracts": "workspace:*", + "@t3tools/shared": "workspace:*", + "dfx": "catalog:", + "effect": "catalog:", + "playwright-core": "1.60.0", + "yaml": "catalog:" + }, + "devDependencies": { + "@effect/vitest": "catalog:", + "@types/node": "catalog:", + "tsx": "^4.20.5", + "vite-plus": "catalog:" + }, + "engines": { + "node": "^22.16 || ^23.11 || >=24.10" + } +} diff --git a/apps/discord-bot/src/alertProcessRules.test.ts b/apps/discord-bot/src/alertProcessRules.test.ts new file mode 100644 index 000000000000..54d864a7f93a --- /dev/null +++ b/apps/discord-bot/src/alertProcessRules.test.ts @@ -0,0 +1,80 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { describe, expect, it } from "vite-plus/test"; + +import { + loadAlertProcessRulesFromFileSync, + parseAlertProcessRulesDocument, +} from "./alertProcessRules.ts"; + +describe("parseAlertProcessRulesDocument", () => { + it("parses structured rules with size and duration shorthands", () => { + const rules = parseAlertProcessRulesDocument({ + rules: [ + { + id: "jaeger-linux", + match: "jaeger-linux", + rss: "4gb", + duration: "5m", + }, + ], + }); + + expect(rules).toEqual([ + { + id: "jaeger-linux", + match: "jaeger-linux", + rssMbThreshold: 4096, + sustainedForMs: 5 * 60_000, + }, + ]); + }); + + it("accepts cpu-only rules", () => { + const rules = parseAlertProcessRulesDocument([ + { + id: "cpu-hot", + match: "worker", + cpuPercentThreshold: 90, + sustainedFor: "2m", + }, + ]); + + expect(rules[0]).toEqual({ + id: "cpu-hot", + match: "worker", + cpuPercentThreshold: 90, + sustainedForMs: 2 * 60_000, + }); + }); +}); + +describe("loadAlertProcessRulesFromFileSync", () => { + it("loads yaml files", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-bot-alert-rules-")); + const yamlPath = NodePath.join(dir, "alert-rules.yaml"); + await NodeFSP.writeFile( + yamlPath, + [ + "rules:", + " - id: jaeger-linux", + " match: jaeger-linux", + " rss: 4gb", + " duration: 5m", + "", + ].join("\n"), + "utf8", + ); + + expect(loadAlertProcessRulesFromFileSync(yamlPath)).toEqual([ + { + id: "jaeger-linux", + match: "jaeger-linux", + rssMbThreshold: 4096, + sustainedForMs: 5 * 60_000, + }, + ]); + }); +}); diff --git a/apps/discord-bot/src/alertProcessRules.ts b/apps/discord-bot/src/alertProcessRules.ts new file mode 100644 index 000000000000..63771904ffda --- /dev/null +++ b/apps/discord-bot/src/alertProcessRules.ts @@ -0,0 +1,162 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; +import { parse as parseYaml } from "yaml"; + +import { expandHomePath } from "./projectAliases.ts"; + +export interface AlertProcessRule { + readonly id: string; + readonly match: string; + readonly rssMbThreshold?: number; + readonly cpuPercentThreshold?: number; + readonly sustainedForMs: number; +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function normalizeNonEmptyString(value: unknown): string | null { + return typeof value === "string" && value.trim().length > 0 ? value.trim() : null; +} + +function parseCpuPercent(value: unknown, field: string): number | undefined { + if (value === undefined) return undefined; + if (typeof value !== "number" || !Number.isFinite(value) || value < 0) { + throw new Error(`${field} must be a non-negative number.`); + } + return value; +} + +function parseSizeToMb(value: unknown, field: string): number | undefined { + if (value === undefined) return undefined; + if (typeof value === "number" && Number.isFinite(value) && value >= 0) { + return value; + } + if (typeof value !== "string") { + throw new Error(`${field} must be a non-negative number or size string.`); + } + const trimmed = value.trim().toLowerCase(); + const match = /^(?\d+(?:\.\d+)?)\s*(?b|kb|kib|mb|mib|gb|gib|tb|tib)?$/u.exec( + trimmed, + ); + if (!match?.groups) { + throw new Error(`${field} must be a size like 4096, 4gb, or 512mb.`); + } + const amount = Number(match.groups.amount); + const unit = match.groups.unit ?? "mb"; + const multiplier = + unit === "b" + ? 1 / (1024 * 1024) + : unit === "kb" || unit === "kib" + ? 1 / 1024 + : unit === "mb" || unit === "mib" + ? 1 + : unit === "gb" || unit === "gib" + ? 1024 + : unit === "tb" || unit === "tib" + ? 1024 * 1024 + : null; + if (multiplier === null) { + throw new Error(`${field} has an unsupported unit.`); + } + return amount * multiplier; +} + +function parseDurationToMs(value: unknown, field: string): number { + if (typeof value === "number" && Number.isFinite(value) && value >= 0) { + return value; + } + if (typeof value !== "string") { + throw new Error(`${field} must be a non-negative number of milliseconds or duration string.`); + } + const trimmed = value.trim().toLowerCase(); + const match = /^(?\d+(?:\.\d+)?)\s*(?ms|s|m|h|d)?$/u.exec(trimmed); + if (!match?.groups) { + throw new Error(`${field} must be a duration like 5m, 30s, or 60000.`); + } + const amount = Number(match.groups.amount); + const unit = match.groups.unit ?? "ms"; + const multiplier = + unit === "ms" + ? 1 + : unit === "s" + ? 1_000 + : unit === "m" + ? 60_000 + : unit === "h" + ? 60 * 60_000 + : unit === "d" + ? 24 * 60 * 60_000 + : null; + if (multiplier === null) { + throw new Error(`${field} has an unsupported unit.`); + } + return amount * multiplier; +} + +function parseRule(value: unknown, index: number): AlertProcessRule { + if (!isRecord(value)) { + throw new Error(`Process alert rule #${index + 1} must be an object.`); + } + const id = normalizeNonEmptyString(value.id); + if (id === null) { + throw new Error(`Process alert rule #${index + 1} must include a non-empty id.`); + } + const match = normalizeNonEmptyString(value.match); + if (match === null) { + throw new Error(`Process alert rule '${id}' must include a non-empty match string.`); + } + const rssMbThreshold = parseSizeToMb( + value.rssMbThreshold ?? value.rssMb ?? value.rss, + `Process alert rule '${id}' rss`, + ); + const cpuPercentThreshold = parseCpuPercent( + value.cpuPercentThreshold ?? value.cpuPercent ?? value.cpu, + `Process alert rule '${id}' cpu`, + ); + if (rssMbThreshold === undefined && cpuPercentThreshold === undefined) { + throw new Error(`Process alert rule '${id}' must set rss and/or cpu thresholds.`); + } + const sustainedForMs = parseDurationToMs( + value.sustainedForMs ?? value.sustainedFor ?? value.duration, + `Process alert rule '${id}' duration`, + ); + if (sustainedForMs < 0) { + throw new Error(`Process alert rule '${id}' duration must be non-negative.`); + } + return { + id, + match, + ...(rssMbThreshold === undefined ? {} : { rssMbThreshold }), + ...(cpuPercentThreshold === undefined ? {} : { cpuPercentThreshold }), + sustainedForMs, + }; +} + +export function parseAlertProcessRulesDocument(document: unknown): ReadonlyArray { + const source = Array.isArray(document) + ? document + : isRecord(document) && Array.isArray(document.rules) + ? document.rules + : null; + if (source === null) { + throw new Error("Alert process rules file must be an array or an object with a rules array."); + } + return source.map((entry, index) => parseRule(entry, index)); +} + +export function loadAlertProcessRulesFromFileSync( + filePath: string | undefined, +): ReadonlyArray { + if (filePath === undefined || filePath.trim() === "") return []; + const resolvedPath = NodePath.resolve(expandHomePath(filePath.trim())); + if (!NodeFS.existsSync(resolvedPath)) { + throw new Error(`Alert process rules file not found: ${resolvedPath}`); + } + const raw = NodeFS.readFileSync(resolvedPath, "utf8").trim(); + if (raw.length === 0) return []; + const document = resolvedPath.endsWith(".json") ? JSON.parse(raw) : parseYaml(raw); + return parseAlertProcessRulesDocument(document); +} diff --git a/apps/discord-bot/src/browser/BrowserAutomationHost.test.ts b/apps/discord-bot/src/browser/BrowserAutomationHost.test.ts new file mode 100644 index 000000000000..68e871f2272f --- /dev/null +++ b/apps/discord-bot/src/browser/BrowserAutomationHost.test.ts @@ -0,0 +1,37 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + browserOperationDeadlineMs, + BrowserOperationTimeoutError, + withBrowserOperationDeadline, +} from "./BrowserAutomationHost.ts"; + +describe("browser automation host deadline", () => { + it("reserves time for delivering the response to the broker", () => { + expect(browserOperationDeadlineMs(15_000)).toBe(14_000); + expect(browserOperationDeadlineMs(500)).toBe(450); + }); + + it("rejects a stalled operation before the broker timeout", async () => { + const stalled = new Promise(() => {}); + let interrupted = false; + + await expect( + withBrowserOperationDeadline(stalled, 10, () => { + interrupted = true; + }), + ).rejects.toBeInstanceOf(BrowserOperationTimeoutError); + expect(interrupted).toBe(true); + }); + + it("does not interrupt an operation that completes before its deadline", async () => { + let interrupted = false; + + await expect( + withBrowserOperationDeadline(Promise.resolve("complete"), 100, () => { + interrupted = true; + }), + ).resolves.toBe("complete"); + expect(interrupted).toBe(false); + }); +}); diff --git a/apps/discord-bot/src/browser/BrowserAutomationHost.ts b/apps/discord-bot/src/browser/BrowserAutomationHost.ts new file mode 100644 index 000000000000..6f253b6b8e5d --- /dev/null +++ b/apps/discord-bot/src/browser/BrowserAutomationHost.ts @@ -0,0 +1,162 @@ +import * as NodeTimersPromises from "node:timers/promises"; + +import { + type EnvironmentId, + type PreviewAutomationHost, + type PreviewAutomationHostFocus, + type PreviewAutomationResponse, + type PreviewAutomationStreamEvent, + type ThreadId, +} from "@t3tools/contracts"; + +import type { DiscordBotConfig } from "../config.ts"; +import { BrowserRuntime } from "./BrowserRuntime.ts"; + +const SUPPORTED_OPERATIONS = [ + "status", + "open", + "navigate", + "snapshot", + "click", + "type", + "press", + "scroll", + "evaluate", + "waitFor", + "recordingStart", + "recordingStop", +] as const; + +const MAX_RESPONSE_RESERVE_MS = 1_000; +const RESPONSE_RESERVE_RATIO = 0.1; + +export class BrowserOperationTimeoutError extends Error { + readonly timeoutMs: number; + + constructor(timeoutMs: number) { + super(`Browser automation host timed out after ${timeoutMs}ms.`); + this.name = "BrowserOperationTimeoutError"; + this.timeoutMs = timeoutMs; + } +} + +export function browserOperationDeadlineMs(timeoutMs: number): number { + const reserve = Math.min( + MAX_RESPONSE_RESERVE_MS, + Math.max(1, timeoutMs * RESPONSE_RESERVE_RATIO), + ); + return Math.max(1, Math.floor(timeoutMs - reserve)); +} + +export function withBrowserOperationDeadline( + operation: Promise, + timeoutMs: number, + onTimeout: () => void = () => {}, +): Promise { + const deadlineMs = browserOperationDeadlineMs(timeoutMs); + const controller = new AbortController(); + const timeout = NodeTimersPromises.setTimeout(deadlineMs, undefined, { + signal: controller.signal, + ref: false, + }).then(() => { + onTimeout(); + throw new BrowserOperationTimeoutError(deadlineMs); + }); + return Promise.race([operation, timeout]).finally(() => controller.abort()); +} + +export class BrowserAutomationHost { + readonly #runtime: BrowserRuntime; + readonly #clientId: string; + readonly #environmentId: EnvironmentId; + #connectionId: PreviewAutomationHostFocus["connectionId"] | null = null; + + private constructor(runtime: BrowserRuntime, profile: string, environmentId: EnvironmentId) { + this.#runtime = runtime; + this.#clientId = `discord-browser-${profile}`; + this.#environmentId = environmentId; + } + + static async launch( + config: DiscordBotConfig, + environmentId: EnvironmentId, + ): Promise { + if (!config.browserExecutablePath) { + throw new Error( + "T3_DISCORD_BROWSER_EXECUTABLE_PATH is required when browser automation is enabled.", + ); + } + if (config.browserAllowedOrigins.length === 0) { + throw new Error( + "T3_DISCORD_BROWSER_ALLOWED_ORIGINS is required when browser automation is enabled.", + ); + } + const runtime = await BrowserRuntime.launch({ + dataDir: config.dataDir, + profile: config.browserProfile, + executablePath: config.browserExecutablePath, + ffmpegPath: config.browserFfmpegPath, + allowedOrigins: config.browserAllowedOrigins, + headless: true, + }); + return new BrowserAutomationHost(runtime, config.browserProfile, environmentId); + } + + registration(): PreviewAutomationHost { + return { + clientId: this.#clientId, + environmentId: this.#environmentId, + supportedOperations: [...SUPPORTED_OPERATIONS], + }; + } + + async consume(event: PreviewAutomationStreamEvent): Promise { + if (event.type === "connected") { + this.#connectionId = event.connectionId; + return null; + } + const responseBase = { + clientId: this.#clientId, + connectionId: event.connectionId, + requestId: event.request.requestId, + } as const; + let response: PreviewAutomationResponse; + try { + const result = await withBrowserOperationDeadline( + this.#runtime.handle(event.request), + event.request.timeoutMs, + () => this.#runtime.interrupt(event.request), + ); + response = { ...responseBase, ok: true, ...(result === undefined ? {} : { result }) }; + } catch (cause) { + const message = cause instanceof Error ? cause.message : "Browser automation failed."; + response = { + ...responseBase, + ok: false, + error: { + _tag: + cause instanceof BrowserOperationTimeoutError + ? "PreviewAutomationTimeoutError" + : "PreviewAutomationExecutionError", + message, + }, + }; + } + return response; + } + + claim(threadId: ThreadId): PreviewAutomationHostFocus | null { + if (this.#connectionId === null) return null; + return { + clientId: this.#clientId, + environmentId: this.#environmentId, + connectionId: this.#connectionId, + focused: true, + threadId, + }; + } + + close(): Promise { + return this.#runtime.close(); + } +} diff --git a/apps/discord-bot/src/browser/BrowserRecording.test.ts b/apps/discord-bot/src/browser/BrowserRecording.test.ts new file mode 100644 index 000000000000..fa778960eed4 --- /dev/null +++ b/apps/discord-bot/src/browser/BrowserRecording.test.ts @@ -0,0 +1,20 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodePath from "node:path"; + +import { describe, expect, it } from "vite-plus/test"; + +import { ffmpegRecordingArguments } from "./BrowserRecording.ts"; + +describe("browser recording", () => { + it("builds a shell-free MP4 encoding command", () => { + const args = ffmpegRecordingArguments({ + framesDirectory: "/tmp/browser frames", + outputPath: "/tmp/artifacts/recording.mp4", + }); + + expect(args).toContain(NodePath.join("/tmp/browser frames", "frame-%08d.jpg")); + expect(args).toContain("libx264"); + expect(args).toContain("yuv420p"); + expect(args.at(-1)).toBe("/tmp/artifacts/recording.mp4"); + }); +}); diff --git a/apps/discord-bot/src/browser/BrowserRecording.ts b/apps/discord-bot/src/browser/BrowserRecording.ts new file mode 100644 index 000000000000..6a587ef36789 --- /dev/null +++ b/apps/discord-bot/src/browser/BrowserRecording.ts @@ -0,0 +1,267 @@ +// @effect-diagnostics globalDate:off nodeBuiltinImport:off +import * as NodeChildProcess from "node:child_process"; +import * as NodeCrypto from "node:crypto"; +import * as NodeFSP from "node:fs/promises"; +import * as NodePath from "node:path"; + +import type { + PreviewAutomationRecordingArtifact, + PreviewAutomationRecordingStatus, + PreviewTabId, +} from "@t3tools/contracts"; +import type { CDPSession, Page } from "playwright-core"; + +import { expandHome } from "./ProfileStore.ts"; + +const RECORDING_FRAME_RATE = 15; +const MAX_RECORDING_FRAMES = RECORDING_FRAME_RATE * 60 * 10; +const MAX_FFMPEG_ERROR_BYTES = 8_192; + +interface ScreencastFrame { + readonly data: string; + readonly sessionId: number; + readonly metadata?: { + readonly timestamp?: number; + }; +} + +export class BrowserRecordingError extends Error { + constructor(message: string, options?: { cause?: unknown }) { + super(message, options); + this.name = "BrowserRecordingError"; + } +} + +export function ffmpegRecordingArguments(input: { + readonly framesDirectory: string; + readonly outputPath: string; +}): ReadonlyArray { + return [ + "-hide_banner", + "-loglevel", + "error", + "-y", + "-framerate", + String(RECORDING_FRAME_RATE), + "-start_number", + "1", + "-i", + NodePath.join(input.framesDirectory, "frame-%08d.jpg"), + "-vf", + "scale=in_range=pc:out_range=tv,pad=ceil(iw/2)*2:ceil(ih/2)*2", + "-an", + "-c:v", + "libx264", + "-preset", + "veryfast", + "-pix_fmt", + "yuv420p", + "-movflags", + "+faststart", + input.outputPath, + ]; +} + +export async function encodeBrowserRecordingFrames( + executablePath: string, + framesDirectory: string, + outputPath: string, +): Promise { + const args = ffmpegRecordingArguments({ framesDirectory, outputPath }); + await new Promise((resolve, reject) => { + const child = NodeChildProcess.spawn(executablePath, args, { + stdio: ["ignore", "ignore", "pipe"], + }); + let errorOutput = ""; + child.stderr.on("data", (chunk: Buffer) => { + if (errorOutput.length < MAX_FFMPEG_ERROR_BYTES) { + errorOutput += chunk.toString("utf8").slice(0, MAX_FFMPEG_ERROR_BYTES - errorOutput.length); + } + }); + child.once("error", (cause) => { + reject( + new BrowserRecordingError( + `Could not start ffmpeg at ${executablePath}; configure T3_DISCORD_BROWSER_FFMPEG_PATH.`, + { cause }, + ), + ); + }); + child.once("close", (code, signal) => { + if (code === 0) resolve(); + else { + reject( + new BrowserRecordingError( + `ffmpeg failed (${signal ?? `exit ${code ?? "unknown"}`}): ${errorOutput.trim() || "no diagnostics"}`, + ), + ); + } + }); + }); +} + +export class BrowserRecording { + readonly #tabId: PreviewTabId; + readonly #id: string; + readonly #startedAt: string; + readonly #session: CDPSession; + readonly #framesDirectory: string; + readonly #outputPath: string; + readonly #ffmpegPath: string; + readonly #onFrame: (frame: ScreencastFrame) => void; + #frameCount = 0; + #writeChain = Promise.resolve(); + #writeError: unknown = null; + #lastFrameTimestamp: number | null = null; + #finished = false; + + private constructor(input: { + tabId: PreviewTabId; + id: string; + startedAt: string; + session: CDPSession; + framesDirectory: string; + outputPath: string; + ffmpegPath: string; + }) { + this.#tabId = input.tabId; + this.#id = input.id; + this.#startedAt = input.startedAt; + this.#session = input.session; + this.#framesDirectory = input.framesDirectory; + this.#outputPath = input.outputPath; + this.#ffmpegPath = input.ffmpegPath; + this.#onFrame = (frame) => { + void this.#session + .send("Page.screencastFrameAck", { sessionId: frame.sessionId }) + .catch(() => {}); + if (this.#frameCount >= MAX_RECORDING_FRAMES || this.#finished) return; + const timestamp = frame.metadata?.timestamp; + if ( + timestamp !== undefined && + this.#lastFrameTimestamp !== null && + timestamp - this.#lastFrameTimestamp < 1 / RECORDING_FRAME_RATE + ) { + return; + } + if (timestamp !== undefined) this.#lastFrameTimestamp = timestamp; + this.#frameCount += 1; + const framePath = NodePath.join( + this.#framesDirectory, + `frame-${String(this.#frameCount).padStart(8, "0")}.jpg`, + ); + this.#writeChain = this.#writeChain + .then(() => + NodeFSP.writeFile(framePath, Buffer.from(frame.data, "base64"), { mode: 0o600 }), + ) + .catch((cause) => { + this.#writeError ??= cause; + }); + }; + } + + static async start(input: { + readonly page: Page; + readonly tabId: PreviewTabId; + readonly dataDir: string; + readonly ffmpegPath: string; + }): Promise { + const id = `browser-recording-${NodeCrypto.randomUUID()}`; + const browserRoot = NodePath.join(expandHome(input.dataDir), "browser"); + const framesDirectory = NodePath.join(browserRoot, "recordings", id); + const artifactsDirectory = NodePath.join(browserRoot, "artifacts"); + const outputPath = NodePath.join(artifactsDirectory, `${id}.mp4`); + await Promise.all([ + NodeFSP.mkdir(framesDirectory, { recursive: true, mode: 0o700 }), + NodeFSP.mkdir(artifactsDirectory, { recursive: true, mode: 0o700 }), + ]); + let session: CDPSession; + try { + session = await input.page.context().newCDPSession(input.page); + } catch (cause) { + await NodeFSP.rm(framesDirectory, { recursive: true, force: true }); + throw new BrowserRecordingError("Could not attach to the browser tab for recording.", { + cause, + }); + } + const recording = new BrowserRecording({ + tabId: input.tabId, + id, + startedAt: new Date().toISOString(), + session, + framesDirectory, + outputPath, + ffmpegPath: input.ffmpegPath, + }); + session.on("Page.screencastFrame", recording.#onFrame); + try { + await session.send("Page.enable"); + await session.send("Page.startScreencast", { + format: "jpeg", + quality: 80, + maxWidth: 1_600, + maxHeight: 1_200, + everyNthFrame: 1, + }); + return recording; + } catch (cause) { + session.off("Page.screencastFrame", recording.#onFrame); + await session.detach().catch(() => {}); + await NodeFSP.rm(framesDirectory, { recursive: true, force: true }); + throw new BrowserRecordingError("Could not start Chromium screencast recording.", { cause }); + } + } + + status(): PreviewAutomationRecordingStatus { + return { + tabId: this.#tabId, + recording: true, + startedAt: this.#startedAt, + }; + } + + async stop(): Promise { + if (this.#finished) throw new BrowserRecordingError("Browser recording is already stopped."); + this.#finished = true; + this.#session.off("Page.screencastFrame", this.#onFrame); + await this.#session.send("Page.stopScreencast").catch(() => {}); + await this.#session.detach().catch(() => {}); + await this.#writeChain; + try { + if (this.#writeError !== null) { + throw new BrowserRecordingError("Could not write browser recording frames.", { + cause: this.#writeError, + }); + } + if (this.#frameCount === 0) { + throw new BrowserRecordingError("Browser recording captured no frames."); + } + await encodeBrowserRecordingFrames(this.#ffmpegPath, this.#framesDirectory, this.#outputPath); + await NodeFSP.chmod(this.#outputPath, 0o600); + const file = await NodeFSP.stat(this.#outputPath); + return { + id: this.#id, + tabId: this.#tabId, + path: this.#outputPath, + mimeType: "video/mp4", + sizeBytes: file.size, + createdAt: new Date().toISOString(), + }; + } finally { + await NodeFSP.rm(this.#framesDirectory, { recursive: true, force: true }); + } + } + + async abort(): Promise { + if (this.#finished) return; + this.#finished = true; + this.#session.off("Page.screencastFrame", this.#onFrame); + await this.#session.send("Page.stopScreencast").catch(() => {}); + await this.#session.detach().catch(() => {}); + await this.#writeChain; + await NodeFSP.rm(this.#framesDirectory, { recursive: true, force: true }); + } + + isForTab(tabId: string | undefined): boolean { + return tabId === undefined || tabId === this.#tabId; + } +} diff --git a/apps/discord-bot/src/browser/BrowserRuntime.test.ts b/apps/discord-bot/src/browser/BrowserRuntime.test.ts new file mode 100644 index 000000000000..3988b599199f --- /dev/null +++ b/apps/discord-bot/src/browser/BrowserRuntime.test.ts @@ -0,0 +1,185 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { describe, expect, it } from "vite-plus/test"; + +import type { Page } from "playwright-core"; + +import { + assertUrlAllowed, + browserStatusForPage, + browserTabsToEvict, + captureScreenshotWithCdp, + matchesExpectedUrl, + normalizeBrowserUrl, + readSnapshotPageState, + saveScreenshotArtifact, +} from "./BrowserRuntime.ts"; + +describe("browser tab retention", () => { + it("evicts least-recently-used tabs beyond the retention limit", () => { + expect( + browserTabsToEvict( + ["oldest", "older", "recent", "newest"].map((tabId) => ({ + tabId, + threadId: "thread-a", + })), + new Set(), + 2, + 10, + ), + ).toEqual(["oldest", "older"]); + }); + + it("does not evict tabs with in-flight work or recordings", () => { + expect( + browserTabsToEvict( + ["busy-oldest", "recording", "eligible", "newest"].map((tabId) => ({ + tabId, + threadId: "thread-a", + })), + new Set(["busy-oldest", "recording"]), + 3, + 10, + ), + ).toEqual(["eligible"]); + }); + + it("allows temporary overflow when every excess tab is protected", () => { + const tabs = ["busy-a", "busy-b"].map((tabId) => ({ tabId, threadId: "thread-a" })); + expect(browserTabsToEvict(tabs, new Set(["busy-a", "busy-b"]), 1, 10)).toEqual([]); + }); + + it("enforces a global ceiling across threads", () => { + const tabs = [ + { tabId: "a-old", threadId: "thread-a" }, + { tabId: "b-old", threadId: "thread-b" }, + { tabId: "a-new", threadId: "thread-a" }, + { tabId: "b-new", threadId: "thread-b" }, + ]; + expect(browserTabsToEvict(tabs, new Set(), 2, 3)).toEqual(["a-old"]); + }); +}); + +describe("browser URL policy", () => { + it("normalizes schemeless hosts to HTTPS", () => { + expect(normalizeBrowserUrl("github.com/login").toString()).toBe("https://github.com/login"); + }); + + it("rejects unsafe protocols and non-loopback HTTP", () => { + expect(() => normalizeBrowserUrl("file:///etc/passwd")).toThrow(/only supports HTTP/); + expect(() => assertUrlAllowed(new URL("http://example.com"), [])).toThrow(/loopback/); + expect(() => assertUrlAllowed(new URL("http://127.0.0.1:5173"), [])).not.toThrow(); + }); + + it("supports exact and wildcard origin allowlists", () => { + expect(() => + assertUrlAllowed(new URL("https://github.com/x"), ["https://github.com"]), + ).not.toThrow(); + expect(() => + assertUrlAllowed(new URL("https://api.github.com/x"), ["https://*.github.com"]), + ).not.toThrow(); + expect(() => + assertUrlAllowed(new URL("https://example.com"), ["https://*.github.com"]), + ).toThrow(/not allowed/); + }); + + it("matches verification URL globs", () => { + expect( + matchesExpectedUrl("https://github.com/settings/profile", "https://github.com/settings/**"), + ).toBe(true); + expect(matchesExpectedUrl("https://github.com/login", "https://github.com/settings/**")).toBe( + false, + ); + }); +}); + +describe("browser status", () => { + it("returns a JSON-safe result when no tab is active", async () => { + const status = await browserStatusForPage(null, undefined); + + expect(status).toEqual({ + available: false, + visible: false, + tabId: null, + url: null, + title: null, + loading: false, + }); + expect(JSON.parse(JSON.stringify(status))).toEqual(status); + }); +}); + +describe("browser screenshots", () => { + it("persists a PNG artifact for the agent to attach", async () => { + const dataDir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-snapshot-test-")); + const source = Buffer.from("png-content").toString("base64"); + + const artifactPath = await saveScreenshotArtifact(dataDir, source); + + expect(NodePath.dirname(artifactPath)).toBe(NodePath.join(dataDir, "browser", "artifacts")); + await expect(NodeFSP.readFile(artifactPath, "utf8")).resolves.toBe("png-content"); + }); + + it("evaluates DOM extraction as browser-native source", async () => { + let expression: unknown; + const expected = { + url: "https://example.com", + title: "Example", + loading: false, + visibleText: "Example", + interactiveElements: [], + }; + const page = { + evaluate: async (input: unknown) => { + expression = input; + return expected; + }, + } as unknown as Page; + + await expect(readSnapshotPageState(page)).resolves.toEqual(expected); + expect(expression).toEqual(expect.any(String)); + expect(expression).not.toContain("__name"); + }); + + it("captures through CDP without invoking Playwright's font-aware screenshot wrapper", async () => { + let detached = false; + const page = { + context: () => ({ + newCDPSession: async () => ({ + send: async () => ({ data: "base64-png" }), + detach: async () => { + detached = true; + }, + }), + }), + screenshot: async () => { + throw new Error("page.screenshot must not be called"); + }, + } as unknown as Page; + + await expect(captureScreenshotWithCdp(page)).resolves.toBe("base64-png"); + expect(detached).toBe(true); + }); + + it("detaches the CDP session when capture fails", async () => { + let detached = false; + const page = { + context: () => ({ + newCDPSession: async () => ({ + send: async () => { + throw new Error("capture failed"); + }, + detach: async () => { + detached = true; + }, + }), + }), + } as unknown as Page; + + await expect(captureScreenshotWithCdp(page)).rejects.toThrow("capture failed"); + expect(detached).toBe(true); + }); +}); diff --git a/apps/discord-bot/src/browser/BrowserRuntime.ts b/apps/discord-bot/src/browser/BrowserRuntime.ts new file mode 100644 index 000000000000..80ea62b8b089 --- /dev/null +++ b/apps/discord-bot/src/browser/BrowserRuntime.ts @@ -0,0 +1,622 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeCrypto from "node:crypto"; +import * as NodeFSP from "node:fs/promises"; +import * as NodePath from "node:path"; + +import { + PreviewTabId, + type PreviewAutomationClickInput, + type PreviewAutomationEvaluateInput, + type PreviewAutomationNavigateInput, + type PreviewAutomationOpenInput, + type PreviewAutomationPressInput, + type PreviewAutomationRequest, + type PreviewAutomationScrollInput, + type PreviewAutomationSnapshot, + type PreviewAutomationTypeInput, + type PreviewAutomationWaitForInput, +} from "@t3tools/contracts"; +import { chromium, type BrowserContext, type Page } from "playwright-core"; + +import { BrowserRecording } from "./BrowserRecording.ts"; +import { acquireProfileLock, profilePaths, readProfileMetadata } from "./ProfileStore.ts"; + +const MAX_VISIBLE_TEXT = 50_000; +const MAX_INTERACTIVE_ELEMENTS = 200; +const MAX_SCREENSHOT_WIDTH = 1_600; +export const MAX_RETAINED_BROWSER_TABS_PER_THREAD = 4; +export const MAX_RETAINED_BROWSER_TABS_TOTAL = 12; + +type SnapshotPageState = Pick< + PreviewAutomationSnapshot, + "url" | "title" | "loading" | "visibleText" | "interactiveElements" +>; + +// Keep this as browser-native source. Runtime transpilers otherwise inject +// helpers into nested callbacks that are unavailable in the page context. +const SNAPSHOT_PAGE_STATE_EXPRESSION = `(() => { + const maxText = ${MAX_VISIBLE_TEXT}; + const maxElements = ${MAX_INTERACTIVE_ELEMENTS}; + const visible = (element) => { + const style = getComputedStyle(element); + const rect = element.getBoundingClientRect(); + return style.visibility !== "hidden" && + style.display !== "none" && + rect.width > 0 && + rect.height > 0; + }; + const selectorFor = (element) => { + if (element.id) return "#" + CSS.escape(element.id); + for (const attribute of ["data-testid", "name"]) { + const value = element.getAttribute(attribute); + if (value) { + return element.tagName.toLowerCase() + + "[" + attribute + "=" + JSON.stringify(value) + "]"; + } + } + const parts = []; + let current = element; + while (current && parts.length < 8) { + const siblings = current.parentElement + ? Array.from(current.parentElement.children).filter( + (sibling) => sibling.tagName === current.tagName, + ) + : []; + const base = current.tagName.toLowerCase(); + parts.unshift( + siblings.length > 1 + ? base + ":nth-of-type(" + (siblings.indexOf(current) + 1) + ")" + : base, + ); + current = current.parentElement; + } + return parts.join(" > "); + }; + const elements = Array.from(document.querySelectorAll( + "a[href],button,input,textarea,select,[role],[tabindex]", + )) + .filter(visible) + .slice(0, maxElements) + .map((element) => { + const rect = element.getBoundingClientRect(); + return { + tag: element.tagName.toLowerCase(), + role: element.getAttribute("role"), + name: element.getAttribute("aria-label") || + element.innerText || + element.getAttribute("name") || + "", + selector: selectorFor(element), + x: rect.x, + y: rect.y, + width: rect.width, + height: rect.height, + }; + }); + return { + url: location.href, + title: document.title, + loading: document.readyState !== "complete", + visibleText: (document.body?.innerText || "").slice(0, maxText), + interactiveElements: elements, + }; +})()`; + +export async function readSnapshotPageState(page: Page): Promise { + return (await page.evaluate(SNAPSHOT_PAGE_STATE_EXPRESSION)) as SnapshotPageState; +} + +export async function captureScreenshotWithCdp(page: Page): Promise { + const session = await page.context().newCDPSession(page); + try { + const result = await session.send("Page.captureScreenshot", { + format: "png", + fromSurface: true, + captureBeyondViewport: false, + }); + return result.data; + } finally { + await session.detach().catch(() => {}); + } +} + +export async function saveScreenshotArtifact(dataDir: string, source: string): Promise { + const artifactsDirectory = NodePath.join(dataDir, "browser", "artifacts"); + const outputPath = NodePath.join(artifactsDirectory, `snapshot-${NodeCrypto.randomUUID()}.png`); + await NodeFSP.mkdir(artifactsDirectory, { recursive: true, mode: 0o700 }); + await NodeFSP.writeFile(outputPath, source, { encoding: "base64", mode: 0o600 }); + return outputPath; +} + +export async function browserStatusForPage( + tabId: string | null, + page: Page | undefined, +): Promise { + const available = page !== undefined && !page.isClosed(); + const viewport = available ? page.viewportSize() : null; + return { + available, + visible: false, + tabId: available ? PreviewTabId.make(tabId!) : null, + url: available ? page.url() : null, + title: available ? await page.title() : null, + loading: false, + ...(viewport === null ? {} : { viewport }), + }; +} + +export function browserTabsToEvict( + tabsByLeastRecentUse: ReadonlyArray<{ readonly tabId: string; readonly threadId: string }>, + protectedTabIds: ReadonlySet, + maximumTabsPerThread = MAX_RETAINED_BROWSER_TABS_PER_THREAD, + maximumTabsTotal = MAX_RETAINED_BROWSER_TABS_TOTAL, +): ReadonlyArray { + const evictions = new Set(); + const threadIds = new Set(tabsByLeastRecentUse.map((tab) => tab.threadId)); + for (const threadId of threadIds) { + const threadTabs = tabsByLeastRecentUse.filter((tab) => tab.threadId === threadId); + let excess = Math.max(0, threadTabs.length - maximumTabsPerThread); + for (const { tabId } of threadTabs) { + if (excess === 0) break; + if (protectedTabIds.has(tabId)) continue; + evictions.add(tabId); + excess -= 1; + } + } + let totalExcess = Math.max(0, tabsByLeastRecentUse.length - evictions.size - maximumTabsTotal); + for (const { tabId } of tabsByLeastRecentUse) { + if (totalExcess === 0) break; + if (evictions.has(tabId) || protectedTabIds.has(tabId)) continue; + evictions.add(tabId); + totalExcess -= 1; + } + return [...evictions]; +} + +export interface BrowserRuntimeOptions { + readonly dataDir: string; + readonly profile: string; + readonly executablePath: string; + readonly ffmpegPath: string; + readonly allowedOrigins: ReadonlyArray; + readonly headless: boolean; +} + +export class BrowserRuntimeError extends Error { + constructor(message: string, options?: { cause?: unknown }) { + super(message, options); + this.name = "BrowserRuntimeError"; + } +} + +export function normalizeBrowserUrl(input: string): URL { + const trimmed = input.trim(); + const candidate = /^[a-z][a-z\d+.-]*:/i.test(trimmed) ? trimmed : `https://${trimmed}`; + let url: URL; + try { + url = new URL(candidate); + } catch (cause) { + throw new BrowserRuntimeError(`Invalid browser URL: ${trimmed}`, { cause }); + } + if (url.protocol !== "https:" && url.protocol !== "http:") { + throw new BrowserRuntimeError(`Browser navigation only supports HTTP(S), not ${url.protocol}`); + } + return url; +} + +function wildcardPattern(pattern: string): RegExp { + return new RegExp( + `^${pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replaceAll("*", ".*")}$`, + "i", + ); +} + +export function matchesExpectedUrl(actual: string, expected: string): boolean { + return wildcardPattern(expected).test(actual); +} + +export function assertUrlAllowed(url: URL, allowedOrigins: ReadonlyArray): void { + const loopback = ["localhost", "127.0.0.1", "::1"].includes(url.hostname); + if (url.protocol === "http:" && !loopback) { + throw new BrowserRuntimeError("Plain HTTP browser navigation is restricted to loopback hosts."); + } + if (allowedOrigins.length === 0) return; + if (!allowedOrigins.some((pattern) => wildcardPattern(pattern).test(url.origin))) { + throw new BrowserRuntimeError(`Browser navigation to origin ${url.origin} is not allowed.`); + } +} + +function requestUrl(input: PreviewAutomationNavigateInput): string { + if (input.target?.kind === "environment-port") { + throw new BrowserRuntimeError( + "Project-server navigation is not supported by the Discord browser host yet; pass a URL.", + ); + } + const url = input.target?.kind === "url" ? input.target.url : input.url; + if (url === undefined) throw new BrowserRuntimeError("Navigate requires a URL."); + return url; +} + +function locatorFor( + page: Page, + input: { selector?: string | undefined; locator?: string | undefined }, +) { + if (input.locator !== undefined) return page.locator(input.locator); + if (input.selector !== undefined) return page.locator(input.selector); + return null; +} + +export class BrowserRuntime { + readonly #context: BrowserContext; + readonly #releaseLock: () => Promise; + readonly #allowedOrigins: ReadonlyArray; + readonly #dataDir: string; + readonly #ffmpegPath: string; + readonly #pages = new Map(); + readonly #tabThreads = new Map(); + readonly #busyTabs = new Map(); + #recording: BrowserRecording | null = null; + #activeTabId: string | null = null; + #closed = false; + + private constructor(input: { + context: BrowserContext; + releaseLock: () => Promise; + allowedOrigins: ReadonlyArray; + dataDir: string; + ffmpegPath: string; + }) { + this.#context = input.context; + this.#releaseLock = input.releaseLock; + this.#allowedOrigins = input.allowedOrigins; + this.#dataDir = input.dataDir; + this.#ffmpegPath = input.ffmpegPath; + } + + static async launch(options: BrowserRuntimeOptions): Promise { + const paths = profilePaths(options.dataDir, options.profile); + const metadata = await readProfileMetadata(paths); + if (metadata.browserExecutablePath !== options.executablePath) { + throw new BrowserRuntimeError( + `Profile ${options.profile} was created with ${metadata.browserExecutablePath}; use the same browser executable.`, + ); + } + const releaseLock = await acquireProfileLock(paths); + let context: BrowserContext | null = null; + try { + context = await chromium.launchPersistentContext(paths.userDataDir, { + executablePath: options.executablePath, + headless: options.headless, + viewport: { width: 1_440, height: 900 }, + }); + if (!metadata.verifyUrl || !metadata.expectUrl) { + await context.close(); + throw new BrowserRuntimeError( + `Profile ${options.profile} is unverified; rerun headed setup with --verify-url and --expect-url.`, + ); + } + const verificationUrl = normalizeBrowserUrl(metadata.verifyUrl); + assertUrlAllowed(verificationUrl, options.allowedOrigins); + const verificationPage = context.pages()[0] ?? (await context.newPage()); + await verificationPage.goto(verificationUrl.toString(), { + waitUntil: "domcontentloaded", + timeout: 15_000, + }); + if (!matchesExpectedUrl(verificationPage.url(), metadata.expectUrl)) { + await context.close(); + throw new BrowserRuntimeError( + `Profile ${options.profile} is no longer authenticated; rerun headed setup.`, + ); + } + await verificationPage.close(); + return new BrowserRuntime({ + context, + releaseLock, + allowedOrigins: options.allowedOrigins, + dataDir: options.dataDir, + ffmpegPath: options.ffmpegPath, + }); + } catch (cause) { + await context?.close().catch(() => {}); + await releaseLock(); + if (cause instanceof BrowserRuntimeError) throw cause; + throw new BrowserRuntimeError(`Could not launch browser profile ${options.profile}.`, { + cause, + }); + } + } + + async close(): Promise { + if (this.#closed) return; + this.#closed = true; + try { + await this.#recording?.abort().catch(() => {}); + this.#recording = null; + await this.#context.close(); + } finally { + this.#pages.clear(); + this.#tabThreads.clear(); + this.#busyTabs.clear(); + await this.#releaseLock(); + } + } + + interrupt(request: PreviewAutomationRequest): void { + const tabId = request.tabId ?? this.#activeTabId; + if (tabId === null) return; + const page = this.#pages.get(tabId); + this.#pages.delete(tabId); + this.#tabThreads.delete(tabId); + if (this.#activeTabId === tabId) this.#activeTabId = null; + if (this.#recording?.isForTab(tabId)) { + const recording = this.#recording; + this.#recording = null; + void recording.abort().catch(() => {}); + } + // Closing the target interrupts pending CDP and Playwright commands. Do + // not await it here: the timeout response must still beat the broker. + void page?.close({ runBeforeUnload: false }).catch(() => {}); + } + + #touchTab(tabId: string, page: Page): void { + this.#pages.delete(tabId); + this.#pages.set(tabId, page); + } + + #markTabBusy(tabId: string): void { + this.#busyTabs.set(tabId, (this.#busyTabs.get(tabId) ?? 0) + 1); + } + + #releaseBusyTab(tabId: string): void { + const remaining = (this.#busyTabs.get(tabId) ?? 1) - 1; + if (remaining === 0) this.#busyTabs.delete(tabId); + else this.#busyTabs.set(tabId, remaining); + } + + async #enforceTabLimit(): Promise { + const protectedTabIds = new Set(this.#busyTabs.keys()); + for (const tabId of this.#pages.keys()) { + if (this.#recording?.isForTab(tabId)) protectedTabIds.add(tabId); + } + const tabs = [...this.#pages.keys()].flatMap((tabId) => { + const threadId = this.#tabThreads.get(tabId); + return threadId === undefined ? [] : [{ tabId, threadId }]; + }); + const evictions = browserTabsToEvict(tabs, protectedTabIds); + for (const tabId of evictions) { + const page = this.#pages.get(tabId); + this.#pages.delete(tabId); + this.#tabThreads.delete(tabId); + if (this.#activeTabId === tabId) this.#activeTabId = null; + await page?.close({ runBeforeUnload: false }).catch(() => {}); + } + } + + #page(tabId?: string): Page { + const id = tabId ?? this.#activeTabId; + const page = id === null ? undefined : this.#pages.get(id); + if (id === null || page === undefined || page.isClosed()) { + throw new BrowserRuntimeError( + id === null ? "No browser tab is open." : `Browser tab ${id} was not found.`, + ); + } + this.#activeTabId = id; + this.#touchTab(id, page); + return page; + } + + async #open( + input: PreviewAutomationOpenInput, + threadId: string, + requestedTabId?: string, + ): Promise { + const reusableId = requestedTabId ?? this.#activeTabId; + let page = input.reuseExistingTab === false ? undefined : this.#pages.get(reusableId ?? ""); + let tabId = reusableId; + if (page === undefined || page.isClosed()) { + page = await this.#context.newPage(); + const createdTabId = PreviewTabId.make(`tab-discord-${NodeCrypto.randomUUID()}`); + tabId = createdTabId; + this.#pages.set(createdTabId, page); + this.#tabThreads.set(createdTabId, threadId); + page.once("close", () => { + this.#pages.delete(createdTabId); + this.#tabThreads.delete(createdTabId); + if (this.#recording?.isForTab(createdTabId)) { + const recording = this.#recording; + this.#recording = null; + void recording.abort().catch(() => {}); + } + }); + } + this.#tabThreads.set(tabId!, threadId); + this.#activeTabId = tabId!; + this.#touchTab(tabId!, page); + this.#markTabBusy(tabId!); + try { + if (input.url !== undefined) await this.#navigate(page, input.url, "load", 15_000); + return this.#status(tabId!); + } finally { + this.#releaseBusyTab(tabId!); + } + } + + async #navigate( + page: Page, + rawUrl: string, + readiness: "load" | "domcontentloaded" | "networkidle" | "commit" = "load", + timeout = 15_000, + ): Promise { + const url = normalizeBrowserUrl(rawUrl); + assertUrlAllowed(url, this.#allowedOrigins); + await page.goto(url.toString(), { waitUntil: readiness, timeout }); + } + + async #status(tabId?: string): Promise { + const id = tabId ?? this.#activeTabId; + const page = id === null ? undefined : this.#pages.get(id); + if (id !== null && page !== undefined && !page.isClosed()) this.#touchTab(id, page); + return browserStatusForPage(id, page); + } + + async #snapshot(page: Page): Promise { + const pageState = await readSnapshotPageState(page); + const accessibilityTree = await page + .locator("body") + .ariaSnapshot({ timeout: 5_000 }) + .catch(() => ""); + // Playwright's screenshot wrapper waits for document.fonts.ready. Some + // authenticated apps leave that promise pending, so capture through CDP. + const source = await captureScreenshotWithCdp(page); + const artifactPath = await saveScreenshotArtifact(this.#dataDir, source); + const viewport = page.viewportSize() ?? { width: 1_440, height: 900 }; + return { + ...pageState, + accessibilityTree, + consoleEntries: [], + networkEntries: [], + actionTimeline: [], + screenshot: { + mimeType: "image/png", + data: source, + width: Math.min(viewport.width, MAX_SCREENSHOT_WIDTH), + height: viewport.height, + path: artifactPath, + }, + }; + } + + async handle(request: PreviewAutomationRequest): Promise { + const busyTabId = request.operation === "open" ? null : (request.tabId ?? this.#activeTabId); + if (busyTabId !== null) { + if (this.#pages.has(busyTabId)) this.#tabThreads.set(busyTabId, request.threadId); + this.#markTabBusy(busyTabId); + } + try { + return await this.#handle(request); + } finally { + if (busyTabId !== null) { + const page = this.#pages.get(busyTabId); + if (page !== undefined && !page.isClosed()) this.#touchTab(busyTabId, page); + this.#releaseBusyTab(busyTabId); + } + await this.#enforceTabLimit(); + } + } + + async #handle(request: PreviewAutomationRequest): Promise { + const timeout = request.timeoutMs; + switch (request.operation) { + case "status": + return this.#status(request.tabId); + case "open": + return this.#open( + request.input as PreviewAutomationOpenInput, + request.threadId, + request.tabId, + ); + case "navigate": { + const input = request.input as PreviewAutomationNavigateInput; + const page = this.#page(request.tabId); + const readiness = + input.readiness === "domContentLoaded" + ? "domcontentloaded" + : input.readiness === "none" + ? "commit" + : input.readiness; + await this.#navigate(page, requestUrl(input), readiness, input.timeoutMs ?? timeout); + return this.#status(request.tabId); + } + case "snapshot": + return this.#snapshot(this.#page(request.tabId)); + case "click": { + const input = request.input as PreviewAutomationClickInput; + const page = this.#page(request.tabId); + const locator = locatorFor(page, input); + if (locator !== null) await locator.click({ timeout: input.timeoutMs ?? timeout }); + else await page.mouse.click(input.x!, input.y!); + return { clicked: true }; + } + case "type": { + const input = request.input as PreviewAutomationTypeInput; + const page = this.#page(request.tabId); + const locator = locatorFor(page, input) ?? page.locator(":focus"); + if (input.clear) await locator.fill(input.text, { timeout: input.timeoutMs ?? timeout }); + else await locator.pressSequentially(input.text, { timeout: input.timeoutMs ?? timeout }); + return { typed: true }; + } + case "press": { + const input = request.input as PreviewAutomationPressInput; + const key = [...(input.modifiers ?? []), input.key].join("+"); + await this.#page(request.tabId).keyboard.press(key); + return { pressed: true }; + } + case "scroll": { + const input = request.input as PreviewAutomationScrollInput; + const page = this.#page(request.tabId); + const x = input.deltaX ?? 0; + const y = input.deltaY ?? 0; + const locator = locatorFor(page, input); + if (locator === null) await page.mouse.wheel(x, y); + else + await locator.evaluate((element, delta) => element.scrollBy(delta.x, delta.y), { x, y }); + return { scrolled: true }; + } + case "evaluate": { + const input = request.input as PreviewAutomationEvaluateInput; + return this.#page(request.tabId).evaluate(input.expression); + } + case "waitFor": { + const input = request.input as PreviewAutomationWaitForInput; + const page = this.#page(request.tabId); + const waits: Array> = []; + const locator = locatorFor(page, input); + if (locator !== null) + waits.push(locator.waitFor({ state: "visible", timeout: input.timeoutMs ?? timeout })); + if (input.text !== undefined) + waits.push( + page + .getByText(input.text, { exact: false }) + .first() + .waitFor({ timeout: input.timeoutMs ?? timeout }), + ); + if (input.urlIncludes !== undefined) + waits.push( + page.waitForURL((url) => url.toString().includes(input.urlIncludes!), { + timeout: input.timeoutMs ?? timeout, + }), + ); + await Promise.all(waits); + return this.#status(request.tabId); + } + case "recordingStart": + if (this.#recording !== null) { + throw new BrowserRuntimeError("A browser recording is already active."); + } + { + const tabId = request.tabId ?? this.#activeTabId; + const page = this.#page(request.tabId); + if (tabId === null) throw new BrowserRuntimeError("No browser tab is open."); + this.#recording = await BrowserRecording.start({ + page, + tabId: PreviewTabId.make(tabId), + dataDir: this.#dataDir, + ffmpegPath: this.#ffmpegPath, + }); + return this.#recording.status(); + } + case "recordingStop": { + const recording = this.#recording; + if (recording === null || !recording.isForTab(request.tabId)) { + throw new BrowserRuntimeError("No browser recording is active for this tab."); + } + this.#recording = null; + return recording.stop(); + } + case "resize": + throw new BrowserRuntimeError( + `The Discord browser host does not support ${request.operation}.`, + ); + } + } +} diff --git a/apps/discord-bot/src/browser/ProfileStore.test.ts b/apps/discord-bot/src/browser/ProfileStore.test.ts new file mode 100644 index 000000000000..a2bed91d0350 --- /dev/null +++ b/apps/discord-bot/src/browser/ProfileStore.test.ts @@ -0,0 +1,65 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { afterEach, describe, expect, it } from "vite-plus/test"; + +import { + acquireProfileLock, + listProfiles, + profilePaths, + validateProfileName, + writeProfileMetadata, +} from "./ProfileStore.ts"; + +const temporaryDirectories: string[] = []; + +async function temporaryDirectory(): Promise { + const directory = await NodeFSP.mkdtemp( + NodePath.join(NodeOS.tmpdir(), "t3-browser-profile-test-"), + ); + temporaryDirectories.push(directory); + return directory; +} + +afterEach(async () => { + await Promise.all( + temporaryDirectories + .splice(0) + .map((directory) => NodeFSP.rm(directory, { recursive: true, force: true })), + ); +}); + +describe("browser profile store", () => { + it("rejects path-like profile names", () => { + expect(() => validateProfileName("../credentials")).toThrow(/Profile names/); + expect(() => validateProfileName("Work Account")).toThrow(/Profile names/); + expect(validateProfileName("github-work")).toBe("github-work"); + }); + + it("prevents concurrent profile use", async () => { + const paths = profilePaths(await temporaryDirectory(), "github-work"); + const release = await acquireProfileLock(paths); + await expect(acquireProfileLock(paths)).rejects.toThrow(/is in use/); + await release(); + const releaseAgain = await acquireProfileLock(paths); + await releaseAgain(); + }); + + it("stores only profile metadata in the index", async () => { + const dataDir = await temporaryDirectory(); + const paths = profilePaths(dataDir, "github-work"); + await writeProfileMetadata(paths, { + name: "github-work", + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + browserExecutablePath: "/usr/bin/chromium", + }); + await NodeFSP.writeFile(NodePath.join(paths.userDataDir, "Cookies"), "secret"); + + await expect(listProfiles(dataDir)).resolves.toEqual([ + expect.objectContaining({ name: "github-work", browserExecutablePath: "/usr/bin/chromium" }), + ]); + }); +}); diff --git a/apps/discord-bot/src/browser/ProfileStore.ts b/apps/discord-bot/src/browser/ProfileStore.ts new file mode 100644 index 000000000000..5c5ef485913c --- /dev/null +++ b/apps/discord-bot/src/browser/ProfileStore.ts @@ -0,0 +1,198 @@ +// @effect-diagnostics nodeBuiltinImport:off globalDate:off +import * as NodeFS from "node:fs"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +const PROFILE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/; + +export interface BrowserProfileMetadata { + readonly name: string; + readonly createdAt: string; + readonly updatedAt: string; + readonly setupUrl?: string; + readonly verifyUrl?: string; + readonly expectUrl?: string; + readonly verifiedAt?: string; + readonly browserExecutablePath: string; +} + +interface LockOwner { + readonly pid: number; + readonly startedAt: string; +} + +export interface BrowserProfilePaths { + readonly root: string; + readonly userDataDir: string; + readonly metadataPath: string; + readonly lockDir: string; +} + +export class BrowserProfileError extends Error { + constructor(message: string, options?: { cause?: unknown }) { + super(message, options); + this.name = "BrowserProfileError"; + } +} + +export function expandHome(input: string): string { + if (input === "~") return NodeOS.homedir(); + if (input.startsWith("~/")) return NodePath.join(NodeOS.homedir(), input.slice(2)); + return NodePath.resolve(input); +} + +export function validateProfileName(name: string): string { + if (!PROFILE_NAME.test(name)) { + throw new BrowserProfileError( + "Profile names must be 1-64 lowercase letters, numbers, or hyphens.", + ); + } + return name; +} + +export function profilePaths(dataDir: string, name: string): BrowserProfilePaths { + const safeName = validateProfileName(name); + const root = NodePath.join(expandHome(dataDir), "browser", "profiles", safeName); + return { + root, + userDataDir: NodePath.join(root, "user-data"), + metadataPath: NodePath.join(root, "profile.json"), + lockDir: NodePath.join(expandHome(dataDir), "browser", "locks", `${safeName}.lock`), + }; +} + +async function pathExists(target: string): Promise { + try { + await NodeFSP.access(target, NodeFS.constants.F_OK); + return true; + } catch { + return false; + } +} + +function isProcessAlive(pid: number): boolean { + try { + process.kill(pid, 0); + return true; + } catch (cause) { + return (cause as NodeJS.ErrnoException).code === "EPERM"; + } +} + +async function readLockOwner(lockDir: string): Promise { + try { + const value = JSON.parse( + await NodeFSP.readFile(NodePath.join(lockDir, "owner.json"), "utf8"), + ) as { + pid?: unknown; + startedAt?: unknown; + }; + return typeof value.pid === "number" && typeof value.startedAt === "string" + ? { pid: value.pid, startedAt: value.startedAt } + : null; + } catch { + return null; + } +} + +export async function acquireProfileLock(paths: BrowserProfilePaths): Promise<() => Promise> { + await NodeFSP.mkdir(NodePath.dirname(paths.lockDir), { recursive: true, mode: 0o700 }); + for (let attempt = 0; attempt < 2; attempt += 1) { + try { + await NodeFSP.mkdir(paths.lockDir, { mode: 0o700 }); + await NodeFSP.writeFile( + NodePath.join(paths.lockDir, "owner.json"), + `${JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() })}\n`, + { mode: 0o600 }, + ); + let released = false; + return async () => { + if (released) return; + released = true; + await NodeFSP.rm(paths.lockDir, { recursive: true, force: true }); + }; + } catch (cause) { + const error = cause as NodeJS.ErrnoException; + if (error.code !== "EEXIST") { + throw new BrowserProfileError( + `Could not lock browser profile ${NodePath.basename(paths.root)}.`, + { + cause, + }, + ); + } + const owner = await readLockOwner(paths.lockDir); + if (attempt === 0 && owner !== null && !isProcessAlive(owner.pid)) { + await NodeFSP.rm(paths.lockDir, { recursive: true, force: true }); + continue; + } + const ownerDescription = owner + ? `PID ${owner.pid} since ${owner.startedAt}` + : "an unknown process"; + throw new BrowserProfileError( + `Browser profile ${NodePath.basename(paths.root)} is in use by ${ownerDescription}.`, + ); + } + } + throw new BrowserProfileError(`Could not lock browser profile ${NodePath.basename(paths.root)}.`); +} + +export async function ensureProfileDirectories(paths: BrowserProfilePaths): Promise { + await NodeFSP.mkdir(paths.userDataDir, { recursive: true, mode: 0o700 }); + await NodeFSP.chmod(paths.root, 0o700); + await NodeFSP.chmod(paths.userDataDir, 0o700); +} + +export async function readProfileMetadata( + paths: BrowserProfilePaths, +): Promise { + try { + return JSON.parse(await NodeFSP.readFile(paths.metadataPath, "utf8")) as BrowserProfileMetadata; + } catch (cause) { + throw new BrowserProfileError( + `Browser profile ${NodePath.basename(paths.root)} is not set up. Run browser-profile setup first.`, + { cause }, + ); + } +} + +export async function writeProfileMetadata( + paths: BrowserProfilePaths, + metadata: BrowserProfileMetadata, +): Promise { + await ensureProfileDirectories(paths); + const temporary = `${paths.metadataPath}.${process.pid}.tmp`; + await NodeFSP.writeFile(temporary, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 0o600 }); + await NodeFSP.rename(temporary, paths.metadataPath); +} + +export async function listProfiles( + dataDir: string, +): Promise> { + const profilesDir = NodePath.join(expandHome(dataDir), "browser", "profiles"); + if (!(await pathExists(profilesDir))) return []; + const entries = await NodeFSP.readdir(profilesDir, { withFileTypes: true }); + const profiles = await Promise.all( + entries + .filter((entry) => entry.isDirectory() && PROFILE_NAME.test(entry.name)) + .map(async (entry) => { + try { + return await readProfileMetadata(profilePaths(dataDir, entry.name)); + } catch { + return null; + } + }), + ); + return profiles.filter((profile): profile is BrowserProfileMetadata => profile !== null); +} + +export async function clearProfile(dataDir: string, name: string): Promise { + const paths = profilePaths(dataDir, name); + const release = await acquireProfileLock(paths); + try { + await NodeFSP.rm(paths.root, { recursive: true, force: true }); + } finally { + await release(); + } +} diff --git a/apps/discord-bot/src/browserProfileCli.test.ts b/apps/discord-bot/src/browserProfileCli.test.ts new file mode 100644 index 000000000000..51cbb204b5a6 --- /dev/null +++ b/apps/discord-bot/src/browserProfileCli.test.ts @@ -0,0 +1,18 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { parseArguments } from "./browserProfileCli.ts"; + +describe("browser profile CLI arguments", () => { + it("parses flags for profile-less commands", () => { + const parsed = parseArguments(["list", "--data-dir", "/tmp/profiles"]); + expect(parsed.command).toBe("list"); + expect(parsed.profile).toBeUndefined(); + expect(parsed.options.get("data-dir")).toBe("/tmp/profiles"); + }); + + it("parses a profile followed by flags", () => { + const parsed = parseArguments(["verify", "github-work", "--executable-path", "/bin/chrome"]); + expect(parsed.profile).toBe("github-work"); + expect(parsed.options.get("executable-path")).toBe("/bin/chrome"); + }); +}); diff --git a/apps/discord-bot/src/browserProfileCli.ts b/apps/discord-bot/src/browserProfileCli.ts new file mode 100644 index 000000000000..e94688fc1804 --- /dev/null +++ b/apps/discord-bot/src/browserProfileCli.ts @@ -0,0 +1,210 @@ +// @effect-diagnostics globalDate:off nodeBuiltinImport:off +import * as NodeProcess from "node:process"; +import * as NodeReadlinePromises from "node:readline/promises"; +import * as NodeURL from "node:url"; + +import { chromium } from "playwright-core"; + +import { + acquireProfileLock, + clearProfile, + ensureProfileDirectories, + listProfiles, + profilePaths, + readProfileMetadata, + writeProfileMetadata, + type BrowserProfileMetadata, +} from "./browser/ProfileStore.ts"; + +interface ParsedArguments { + readonly command: string | undefined; + readonly profile: string | undefined; + readonly options: ReadonlyMap; +} + +export function parseArguments(argv: ReadonlyArray): ParsedArguments { + const [command, ...tail] = argv; + const profile = tail[0]?.startsWith("--") === false ? tail.shift() : undefined; + const rest = tail; + const options = new Map(); + for (let index = 0; index < rest.length; index += 1) { + const item = rest[index]!; + if (!item.startsWith("--")) throw new Error(`Unexpected argument: ${item}`); + const next = rest[index + 1]; + if (next !== undefined && !next.startsWith("--")) { + options.set(item.slice(2), next); + index += 1; + } else { + options.set(item.slice(2), true); + } + } + return { command, profile, options }; +} + +function option(input: ParsedArguments, name: string): string | undefined { + const value = input.options.get(name); + return typeof value === "string" ? value : undefined; +} + +function required(value: string | undefined, message: string): string { + if (value === undefined || value.trim() === "") throw new Error(message); + return value; +} + +function matchesExpectedUrl(actual: string, expected: string): boolean { + const expression = new RegExp( + `^${expected.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replaceAll("*", ".*")}$`, + ); + return expression.test(actual); +} + +async function setup(input: ParsedArguments, dataDir: string, executablePath: string) { + const name = required(input.profile, "setup requires a profile name"); + const setupUrl = option(input, "url") ?? "about:blank"; + const verifyUrl = option(input, "verify-url"); + const expectUrl = option(input, "expect-url"); + const paths = profilePaths(dataDir, name); + await ensureProfileDirectories(paths); + const release = await acquireProfileLock(paths); + try { + const context = await chromium.launchPersistentContext(paths.userDataDir, { + executablePath, + headless: false, + viewport: { width: 1_440, height: 900 }, + }); + try { + const page = context.pages()[0] ?? (await context.newPage()); + if (setupUrl !== "about:blank") await page.goto(setupUrl, { waitUntil: "domcontentloaded" }); + const prompt = NodeReadlinePromises.createInterface({ + input: NodeProcess.stdin, + output: NodeProcess.stdout, + }); + try { + await prompt.question( + "Complete login in the browser, then press Enter to verify and save. ", + ); + } finally { + prompt.close(); + } + + let verifiedAt: string | undefined; + if (verifyUrl !== undefined && expectUrl !== undefined) { + await page.goto(verifyUrl, { waitUntil: "domcontentloaded" }); + if (!matchesExpectedUrl(page.url(), expectUrl)) { + throw new Error(`Verification failed: ${page.url()} does not match ${expectUrl}`); + } + verifiedAt = new Date().toISOString(); + } + const now = new Date().toISOString(); + let previous: BrowserProfileMetadata | undefined; + try { + previous = await readProfileMetadata(paths); + } catch { + previous = undefined; + } + await writeProfileMetadata(paths, { + name, + createdAt: previous?.createdAt ?? now, + updatedAt: now, + setupUrl, + ...(verifyUrl === undefined ? {} : { verifyUrl }), + ...(expectUrl === undefined ? {} : { expectUrl }), + ...(verifiedAt === undefined ? {} : { verifiedAt }), + browserExecutablePath: executablePath, + }); + NodeProcess.stdout.write( + verifiedAt === undefined + ? `Saved unverified profile ${name}. Add --verify-url and --expect-url for login checks.\n` + : `Saved and verified profile ${name}.\n`, + ); + } finally { + await context.close(); + } + } finally { + await release(); + } +} + +async function verify(input: ParsedArguments, dataDir: string, executablePath: string) { + const name = required(input.profile, "verify requires a profile name"); + const paths = profilePaths(dataDir, name); + const metadata = await readProfileMetadata(paths); + if (metadata.browserExecutablePath !== executablePath) { + throw new Error( + `Profile was created with ${metadata.browserExecutablePath}; use the same executable.`, + ); + } + const verifyUrl = required(metadata.verifyUrl, "Profile has no verification URL; rerun setup."); + const expectUrl = required(metadata.expectUrl, "Profile has no expected URL; rerun setup."); + const release = await acquireProfileLock(paths); + try { + const context = await chromium.launchPersistentContext(paths.userDataDir, { + executablePath, + headless: true, + viewport: { width: 1_440, height: 900 }, + }); + try { + const page = context.pages()[0] ?? (await context.newPage()); + await page.goto(verifyUrl, { waitUntil: "domcontentloaded" }); + if (!matchesExpectedUrl(page.url(), expectUrl)) { + throw new Error(`Profile ${name} is no longer authenticated; rerun headed setup.`); + } + await writeProfileMetadata(paths, { + ...metadata, + updatedAt: new Date().toISOString(), + verifiedAt: new Date().toISOString(), + }); + NodeProcess.stdout.write(`Profile ${name} is authenticated.\n`); + } finally { + await context.close(); + } + } finally { + await release(); + } +} + +function usage(): never { + throw new Error( + "Usage: browser-profile [name] [--data-dir PATH] [--executable-path PATH]", + ); +} + +async function main() { + const input = parseArguments(NodeProcess.argv.slice(2)); + const dataDir = + option(input, "data-dir") ?? NodeProcess.env["T3_DISCORD_BOT_DATA_DIR"] ?? "~/.t3/discord-bot"; + if (input.command === "list") { + const profiles = await listProfiles(dataDir); + if (profiles.length === 0) NodeProcess.stdout.write("No browser profiles configured.\n"); + for (const profile of profiles) { + NodeProcess.stdout.write( + `${profile.name}\t${profile.verifiedAt ? `verified ${profile.verifiedAt}` : "unverified"}\n`, + ); + } + return; + } + if (input.command === "clear") { + if (input.options.get("yes") !== true) throw new Error("clear requires --yes"); + await clearProfile(dataDir, required(input.profile, "clear requires a profile name")); + NodeProcess.stdout.write(`Cleared profile ${input.profile}.\n`); + return; + } + const executablePath = required( + option(input, "executable-path") ?? NodeProcess.env["T3_DISCORD_BROWSER_EXECUTABLE_PATH"], + "Set --executable-path or T3_DISCORD_BROWSER_EXECUTABLE_PATH.", + ); + if (input.command === "setup") return setup(input, dataDir, executablePath); + if (input.command === "verify") return verify(input, dataDir, executablePath); + return usage(); +} + +if ( + NodeProcess.argv[1] !== undefined && + import.meta.url === NodeURL.pathToFileURL(NodeProcess.argv[1]).href +) { + main().catch((cause: unknown) => { + const message = cause instanceof Error ? cause.message : String(cause); + NodeProcess.stderr.write(`browser-profile: ${message}\n`); + NodeProcess.exit(1); + }); +} diff --git a/apps/discord-bot/src/config.test.ts b/apps/discord-bot/src/config.test.ts new file mode 100644 index 000000000000..bbe7d0fb7859 --- /dev/null +++ b/apps/discord-bot/src/config.test.ts @@ -0,0 +1,199 @@ +import { ProviderInstanceId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { preferredModelSelection, type DiscordBotConfig } from "./config.ts"; + +const baseConfig = { + discordToken: "x", + t3HttpBaseUrl: "http://127.0.0.1:8080", + t3BootstrapCredential: undefined, + t3BearerToken: undefined, + t3DefaultInstanceId: "codex", + t3DefaultModel: "gpt-5.4", + t3DefaultBaseBranch: "main", + t3DefaultRuntimeMode: "full-access" as const, + dataDir: "~/.t3/discord-bot", + webUiBaseUrl: undefined, + projectAliasesPath: undefined, + identityMapPath: undefined, + honeycombTraceUrlTemplate: undefined, + alertsChannelId: undefined, + alertProcessRulesPath: undefined, + stateSqlitePath: "/var/lib/t3/userdata/state.sqlite", + browserEnabled: false, + browserProfile: "default", + browserExecutablePath: undefined, + browserFfmpegPath: "ffmpeg", + browserAllowedOrigins: [], + jiraBrowseBaseUrl: "https://example.atlassian.net", + teamsEnabled: false, + teamsTenantId: undefined, + teamsClientId: undefined, + teamsClientSecret: undefined, + teamsChannelsPath: undefined, + teamsPollIntervalSeconds: 60, + teamsBotDisplayName: undefined, + teamsNativeEnabled: false, + teamsPort: 3978, + teamsMessagingEndpoint: "/api/messages" as const, + teamsDefaultProjectShortName: undefined, +} satisfies DiscordBotConfig; + +describe("preferredModelSelection", () => { + it("defaults to codex gpt-5.4 over project grok", () => { + const selection = preferredModelSelection({ + config: baseConfig, + projectDefault: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + driver: "codex", + enabled: true, + installed: true, + models: [{ slug: "gpt-5.4", name: "GPT-5.4" }], + }, + { + instanceId: ProviderInstanceId.make("grok"), + driver: "grok", + enabled: true, + installed: true, + models: [{ slug: "grok-build", name: "Grok Build" }], + }, + ], + }); + + expect(selection.instanceId).toBe("codex"); + expect(selection.model).toBe("gpt-5.4"); + }); + + it("honors explicit mention overrides", () => { + const selection = preferredModelSelection({ + config: baseConfig, + overrideInstanceId: "cursor", + overrideModel: "composer-2", + providers: [ + { + instanceId: ProviderInstanceId.make("cursor"), + driver: "cursor", + enabled: true, + installed: true, + models: [{ slug: "composer-2", name: "Composer 2" }], + }, + ], + }); + + expect(selection).toEqual({ + instanceId: "cursor", + model: "composer-2", + }); + }); + + it("uses the current thread provider as the sticky base for model-only overrides", () => { + const selection = preferredModelSelection({ + config: baseConfig, + stickyModelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "claude-sonnet-4-6", + }, + overrideModel: "claude-opus-4-6", + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + driver: "codex", + enabled: true, + installed: true, + models: [{ slug: "gpt-5.4", name: "GPT-5.4" }], + }, + { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: "claudeAgent", + enabled: true, + installed: true, + models: [ + { slug: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" }, + { slug: "claude-opus-4-6", name: "Claude Opus 4.6" }, + ], + }, + ], + }); + + expect(selection).toEqual({ + instanceId: "claudeAgent", + model: "claude-opus-4-6", + }); + }); + + it("matches model-only overrides to the native provider instead of sticky default", () => { + const selection = preferredModelSelection({ + config: { + ...baseConfig, + t3DefaultInstanceId: "grok", + t3DefaultModel: "grok-build", + }, + stickyModelSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + overrideModel: "gpt-5.6", + providers: [ + { + instanceId: ProviderInstanceId.make("grok"), + driver: "grok", + enabled: true, + installed: true, + models: [{ slug: "grok-build", name: "Grok Build" }], + }, + { + instanceId: ProviderInstanceId.make("codex"), + driver: "codex", + enabled: true, + installed: true, + models: [ + { slug: "gpt-5.4", name: "GPT-5.4" }, + { slug: "gpt-5.6", name: "GPT-5.6" }, + ], + }, + ], + }); + + expect(selection).toEqual({ + instanceId: "codex", + model: "gpt-5.6", + }); + }); + + it("keeps the current thread model as the sticky default when only the provider override changes", () => { + const selection = preferredModelSelection({ + config: baseConfig, + stickyModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + overrideInstanceId: "codex_work", + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + driver: "codex", + enabled: true, + installed: true, + models: [{ slug: "gpt-5.4", name: "GPT-5.4" }], + }, + { + instanceId: ProviderInstanceId.make("codex_work"), + driver: "codex", + enabled: true, + installed: true, + models: [{ slug: "gpt-5.4", name: "GPT-5.4" }], + }, + ], + }); + + expect(selection).toEqual({ + instanceId: "codex_work", + model: "gpt-5.4", + }); + }); +}); diff --git a/apps/discord-bot/src/config.ts b/apps/discord-bot/src/config.ts new file mode 100644 index 000000000000..198a64806817 --- /dev/null +++ b/apps/discord-bot/src/config.ts @@ -0,0 +1,301 @@ +import { + DEFAULT_MODEL, + type ModelSelection, + type ProviderInstanceId, + type RuntimeMode, +} from "@t3tools/contracts"; +import { resolveProviderModelSelection } from "@t3tools/shared/providerModelSelection"; +import * as Config from "effect/Config"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Redacted from "effect/Redacted"; +import * as Schema from "effect/Schema"; + +export interface DiscordBotConfig { + readonly discordToken: string | undefined; + readonly t3HttpBaseUrl: string; + readonly t3BootstrapCredential: string | undefined; + readonly t3BearerToken: string | undefined; + readonly t3DefaultInstanceId: string | undefined; + readonly t3DefaultModel: string | undefined; + readonly t3DefaultBaseBranch: string; + readonly t3DefaultRuntimeMode: RuntimeMode; + readonly dataDir: string; + readonly webUiBaseUrl: string | undefined; + /** Bot-local shortName → workspaceRoot map (not on the T3 server). */ + readonly projectAliasesPath: string | undefined; + /** + * Optional Discord → GitHub/Jira identity map path for commit/PR co-authorship. + * Staged like project aliases (e.g. /run/secrets/identity-map.yaml). + */ + readonly identityMapPath: string | undefined; + /** + * Optional Honeycomb trace URL template for bootstrap prompts. + * Placeholders: {traceId}, {environment}, {dataset}, {team} + */ + readonly honeycombTraceUrlTemplate: string | undefined; + /** + * Discord channel id for guest ops alerts (load, mem, runaway MCP, long turns). + * Unset → watchdog does not post. + */ + readonly alertsChannelId: string | undefined; + /** + * Optional YAML/JSON rules file for per-process Discord alert ceilings. + * Lets operators raise/lower RSS, CPU, and sustained-duration thresholds + * for named guest processes without changing code. + */ + readonly alertProcessRulesPath: string | undefined; + /** + * Path to t3code `state.sqlite` for long-turn detection (guest: /var/lib/t3/userdata/state.sqlite). + */ + readonly stateSqlitePath: string; + readonly browserEnabled: boolean; + readonly browserProfile: string; + readonly browserExecutablePath: string | undefined; + readonly browserFfmpegPath: string; + readonly browserAllowedOrigins: ReadonlyArray; + /** + * Optional Jira site base for browse links on pinned thread-info messages + * (e.g. `https://example.atlassian.net`). + */ + readonly jiraBrowseBaseUrl: string | undefined; + /** Optional Microsoft Teams intake module (Graph channel polling → Discord/T3). */ + readonly teamsEnabled: boolean; + readonly teamsTenantId: string | undefined; + readonly teamsClientId: string | undefined; + readonly teamsClientSecret: string | undefined; + readonly teamsChannelsPath: string | undefined; + readonly teamsPollIntervalSeconds: number; + readonly teamsBotDisplayName: string | undefined; + /** Run the native Teams SDK activity/message-extension endpoint. */ + readonly teamsNativeEnabled: boolean; + readonly teamsPort: number; + readonly teamsMessagingEndpoint: `/${string}`; + /** Fallback alias for personal/group chats that do not map to a configured channel. */ + readonly teamsDefaultProjectShortName: string | undefined; +} + +const RuntimeModeConfig = Schema.Literals([ + "full-access", + "auto-accept-edits", + "approval-required", +]); + +/** Match T3 Code web defaults (Codex / GPT-5.4). */ +const DEFAULT_BOT_INSTANCE_ID = "codex"; +const DEFAULT_BOT_MODEL = DEFAULT_MODEL; + +export const DiscordBotConfig: Effect.Effect = Effect.gen( + function* () { + const discordToken = yield* Config.redacted("DISCORD_BOT_TOKEN").pipe( + Config.option, + Config.map((value) => (Option.isSome(value) ? Redacted.value(value.value) : undefined)), + ); + const t3HttpBaseUrl = yield* Config.string("T3_HTTP_BASE_URL").pipe( + Config.withDefault("http://127.0.0.1:3773"), + ); + const t3BootstrapCredential = yield* Config.string("T3_BOOTSTRAP_CREDENTIAL").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const t3BearerToken = yield* Config.string("T3_BEARER_TOKEN").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + // Align with T3 web default unless operator pins another instance/model. + const t3DefaultInstanceId = yield* Config.string("T3_DEFAULT_INSTANCE_ID").pipe( + Config.withDefault(DEFAULT_BOT_INSTANCE_ID), + ); + const t3DefaultModel = yield* Config.string("T3_DEFAULT_MODEL").pipe( + Config.withDefault(DEFAULT_BOT_MODEL), + ); + const t3DefaultBaseBranch = yield* Config.string("T3_DEFAULT_BASE_BRANCH").pipe( + Config.withDefault("main"), + ); + const t3DefaultRuntimeMode = yield* Config.schema( + RuntimeModeConfig, + "T3_DEFAULT_RUNTIME_MODE", + ).pipe(Config.withDefault("full-access" as const)); + const dataDir = yield* Config.string("T3_DISCORD_BOT_DATA_DIR").pipe( + Config.withDefault("~/.t3/discord-bot"), + ); + const webUiBaseUrl = yield* Config.string("T3_WEB_UI_BASE_URL").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const projectAliasesPath = yield* Config.string("T3_PROJECT_ALIASES_PATH").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const identityMapPath = yield* Config.string("T3_IDENTITY_MAP_PATH").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const honeycombTraceUrlTemplate = yield* Config.string("T3_HONEYCOMB_TRACE_URL_TEMPLATE").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const alertsChannelId = yield* Config.string("DISCORD_ALERTS_CHANNEL_ID").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const alertProcessRulesPath = yield* Config.string("T3_DISCORD_ALERT_PROCESS_RULES_PATH").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const stateSqlitePath = yield* Config.string("T3_STATE_SQLITE_PATH").pipe( + Config.withDefault("/var/lib/t3/userdata/state.sqlite"), + ); + const browserEnabled = yield* Config.boolean("T3_DISCORD_BROWSER_ENABLED").pipe( + Config.withDefault(false), + ); + const browserProfile = yield* Config.string("T3_DISCORD_BROWSER_PROFILE").pipe( + Config.withDefault("default"), + ); + const browserExecutablePath = yield* Config.string("T3_DISCORD_BROWSER_EXECUTABLE_PATH").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const browserFfmpegPath = yield* Config.string("T3_DISCORD_BROWSER_FFMPEG_PATH").pipe( + Config.withDefault("ffmpeg"), + ); + const browserAllowedOrigins = yield* Config.string("T3_DISCORD_BROWSER_ALLOWED_ORIGINS").pipe( + Config.withDefault(""), + Config.map((value) => + value + .split(",") + .map((origin) => origin.trim()) + .filter(Boolean), + ), + ); + const jiraBrowseBaseUrl = yield* Config.string("T3_JIRA_BROWSE_BASE_URL").pipe( + Config.orElse(() => Config.string("JIRA_BROWSE_BASE_URL")), + Config.option, + Config.map((value) => { + const raw = Option.getOrUndefined(value); + if (raw === undefined) return undefined; + const trimmed = raw.trim().replace(/\/+$/u, ""); + if (trimmed.length === 0) return undefined; + const site = trimmed.match(/^(https?:\/\/[a-z0-9.-]+\.atlassian\.net)(?:\/.*)?$/iu); + if (site?.[1] !== undefined) return site[1]; + if (/^https?:\/\//iu.test(trimmed) && !trimmed.includes("/ex/jira/")) return trimmed; + return undefined; + }), + ); + const teamsEnabled = yield* Config.boolean("TEAMS_ENABLED").pipe(Config.withDefault(false)); + const teamsTenantId = yield* Config.string("TEAMS_TENANT_ID").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const teamsClientId = yield* Config.string("TEAMS_CLIENT_ID").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const teamsClientSecret = yield* Config.redacted("TEAMS_CLIENT_SECRET").pipe( + Config.option, + Config.map((value) => (Option.isSome(value) ? Redacted.value(value.value) : undefined)), + ); + const teamsChannelsPath = yield* Config.string("TEAMS_CHANNELS_PATH").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const teamsPollIntervalSeconds = yield* Config.int("TEAMS_POLL_INTERVAL_SECONDS").pipe( + Config.withDefault(60), + ); + const teamsBotDisplayName = yield* Config.string("TEAMS_BOT_DISPLAY_NAME").pipe( + Config.option, + Config.map(Option.getOrUndefined), + ); + const teamsNativeEnabled = yield* Config.boolean("TEAMS_NATIVE_ENABLED").pipe( + Config.withDefault(false), + ); + const teamsPort = yield* Config.int("TEAMS_PORT").pipe(Config.withDefault(3978)); + const teamsMessagingEndpoint = yield* Config.string("TEAMS_MESSAGING_ENDPOINT").pipe( + Config.withDefault("/api/messages"), + Config.map((value) => { + const normalized = value.trim(); + return (normalized.startsWith("/") ? normalized : `/${normalized}`) as `/${string}`; + }), + ); + const teamsDefaultProjectShortName = yield* Config.string( + "TEAMS_DEFAULT_PROJECT_SHORT_NAME", + ).pipe(Config.option, Config.map(Option.getOrUndefined)); + + return { + discordToken, + t3HttpBaseUrl, + t3BootstrapCredential, + t3BearerToken, + t3DefaultInstanceId, + t3DefaultModel, + t3DefaultBaseBranch, + t3DefaultRuntimeMode, + dataDir, + webUiBaseUrl, + projectAliasesPath, + identityMapPath, + honeycombTraceUrlTemplate, + alertsChannelId, + alertProcessRulesPath, + stateSqlitePath, + browserEnabled, + browserProfile, + browserExecutablePath, + browserFfmpegPath, + browserAllowedOrigins, + jiraBrowseBaseUrl, + teamsEnabled, + teamsTenantId, + teamsClientId, + teamsClientSecret, + teamsChannelsPath, + teamsPollIntervalSeconds, + teamsBotDisplayName, + teamsNativeEnabled, + teamsPort, + teamsMessagingEndpoint, + teamsDefaultProjectShortName, + } satisfies DiscordBotConfig; + }, +); + +/** + * Discord bot model selection (conservative defaults): + * 1. Explicit mention overrides (`--provider` / `--model`) + * - Model-only (`--model` without `--provider`) picks the best cataloged + * native provider for that model (e.g. gpt-5.6 → codex, not sticky Grok) + * - Sticky/current provider still wins when it catalogs the requested model + * 2. Bot env defaults (default: codex + gpt-5.4, same as T3 web) + * 3. Project defaultModelSelection if that provider is available + * 4. First enabled installed provider + * + * Note: Grok Build previously hit provider turn-start decode failures for large + * Discord bootstrap prompts; prefer Codex unless the operator pins Grok/Composer. + */ +export function preferredModelSelection(input: { + readonly config: DiscordBotConfig; + readonly providers: Parameters[0]["providers"]; + readonly projectDefault?: ModelSelection | null; + readonly stickyModelSelection?: ModelSelection | null; + readonly overrideInstanceId?: string; + readonly overrideModel?: string; +}): ModelSelection { + const fallbackSelection = { + instanceId: DEFAULT_BOT_INSTANCE_ID as ProviderInstanceId, + model: DEFAULT_BOT_MODEL, + }; + const preferredSelection = input.stickyModelSelection ?? { + instanceId: (input.config.t3DefaultInstanceId ?? DEFAULT_BOT_INSTANCE_ID) as ProviderInstanceId, + model: input.config.t3DefaultModel ?? DEFAULT_BOT_MODEL, + }; + return resolveProviderModelSelection({ + providers: input.providers, + ...(input.projectDefault === undefined ? {} : { projectDefault: input.projectDefault }), + preferredSelection, + fallbackSelection, + ...(input.overrideInstanceId === undefined + ? {} + : { overrideInstanceId: input.overrideInstanceId }), + ...(input.overrideModel === undefined ? {} : { overrideModel: input.overrideModel }), + }); +} diff --git a/apps/discord-bot/src/discord/DiscordLive.ts b/apps/discord-bot/src/discord/DiscordLive.ts new file mode 100644 index 000000000000..905741fba2fd --- /dev/null +++ b/apps/discord-bot/src/discord/DiscordLive.ts @@ -0,0 +1,92 @@ +import { NodeHttpClient, NodeSocket } from "@effect/platform-node"; +import { Discord, DiscordConfig, DiscordREST, Intents } from "dfx"; +import * as Redacted from "effect/Redacted"; +import { DiscordIxLive } from "dfx/gateway"; +import * as Config from "effect/Config"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +import { withSuppressEmbeds } from "../presentation/suppressEmbeds.ts"; + +/** Intents required for channel mentions → agent turns. */ +export const BOT_GATEWAY_INTENTS = Intents.fromList([ + "Guilds", + "GuildMessages", + "MessageContent", + "GuildMessageReactions", +]); + +/** + * Wrap DiscordREST so every createMessage / updateMessage sets SuppressEmbeds. + * Link previews are suppressed; file attachments are unaffected (separate multipart fields). + * + * Uses getUnsafe because Layer.build's output type is opaque to Context.get's + * "service must be in Services" constraint, even though DiscordIxLive always + * provides DiscordREST. + */ +const wrapDiscordRestSuppressEmbeds = (layer: Layer.Layer) => + Layer.effectContext( + Effect.gen(function* () { + const ctx = yield* Layer.build(layer); + const rest = Context.getUnsafe(ctx, DiscordREST); + return Context.add( + ctx, + DiscordREST, + DiscordREST.of({ + ...rest, + createMessage: (channelId, options) => + rest.createMessage(channelId, withSuppressEmbeds(options)), + updateMessage: (channelId, messageId, options) => + rest.updateMessage(channelId, messageId, withSuppressEmbeds(options)), + }), + ) as Context.Context; + }), + ); + +export const makeDiscordLayer = (token: string) => + wrapDiscordRestSuppressEmbeds( + DiscordIxLive.pipe( + // provideMerge keeps DiscordConfig in the runtime (not only as a hidden dep). + // Bridge multipart uploads yield DiscordConfig for token + REST baseUrl. + Layer.provideMerge( + DiscordConfig.layer({ + token: Redacted.make(token), + gateway: { + // Explicit bitfield (also loggable at boot). + intents: BOT_GATEWAY_INTENTS, + }, + }), + ), + Layer.provide([NodeHttpClient.layerUndici, NodeSocket.layerWebSocketConstructor]), + ), + ); + +export function describeIntents(bitfield: number): string { + const names = Object.entries(Discord.GatewayIntentBits) + .filter(([, bit]) => typeof bit === "number" && (bitfield & bit) === bit) + .map(([name]) => name); + return `${bitfield} [${names.join(", ")}]`; +} + +/** Config-based variant when token comes from env via Config. */ +export const DiscordLayerFromEnv = wrapDiscordRestSuppressEmbeds( + DiscordIxLive.pipe( + Layer.provideMerge( + DiscordConfig.layerConfig({ + token: Config.redacted("DISCORD_BOT_TOKEN"), + gateway: { + intents: Config.succeed( + Intents.fromList([ + "Guilds", + "GuildMessages", + "MessageContent", + "GuildMessageReactions", + ]), + ), + }, + }), + ), + Layer.provide([NodeHttpClient.layerUndici, NodeSocket.layerWebSocketConstructor]), + ), +); diff --git a/apps/discord-bot/src/features/Alerts.test.ts b/apps/discord-bot/src/features/Alerts.test.ts new file mode 100644 index 000000000000..1378996eae2e --- /dev/null +++ b/apps/discord-bot/src/features/Alerts.test.ts @@ -0,0 +1,415 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import * as Cause from "effect/Cause"; +import { describe, expect, it, vi } from "vite-plus/test"; + +vi.mock("dfx", () => ({ + DiscordConfig: { DiscordConfig: {} }, + DiscordREST: {}, +})); + +import { + bridgeAlertDelivery, + classifySessionLastError, + fatalAlertDelivery, + formatAlertCause, + formatLongRunningTurnMilestone, + isExpectedSessionLastError, + listSessionErrors, + longRunningTurnMilestoneMs, + nextLongRunningTurnMilestoneMs, + selectSessionErrorsForAlert, + sessionErrorAgeMs, + sessionErrorAlertDelivery, + sessionErrorAlertKey, + SESSION_ERROR_MAX_AGE_MS, + shouldAlertLongRunningTurn, + trackSustainedHotProcesses, + TURN_RUNNING_MIN_MS, + type ProcInfo, + type ProcSustainState, +} from "./Alerts.ts"; + +const TICK_MS = 60_000; +const CPU_THRESHOLD = 50; +const RSS_THRESHOLD = 768; +const SUSTAINED_FOR_MS = 4 * TICK_MS; + +const proc = (over: Partial & { pid: number }): ProcInfo => ({ + pid: over.pid, + rssMb: over.rssMb ?? 100, + cpuSeconds: over.cpuSeconds ?? 0, + cmd: over.cmd ?? `/bin/proc-${over.pid}`, + label: over.label ?? `proc-${over.pid}`, +}); + +/** Replay a fixed per-tick behaviour and return the final tick's hot list. */ +function run( + ticks: ReadonlyArray>, + startMs = 1_000_000, +): { + hot: ReturnType["hot"]; + state: ReadonlyMap; +} { + let state: ReadonlyMap = new Map(); + let hot: ReturnType["hot"] = []; + ticks.forEach((procs, index) => { + const result = trackSustainedHotProcesses({ + prev: state, + procs, + nowMs: startMs + index * TICK_MS, + resolveRule: () => ({ + id: "default", + cpuPercentThreshold: CPU_THRESHOLD, + rssMbThreshold: RSS_THRESHOLD, + sustainedForMs: SUSTAINED_FOR_MS, + }), + }); + state = result.next; + hot = result.hot; + }); + return { hot, state }; +} + +describe("formatAlertCause", () => { + it("pretty-prints Effect Cause failures instead of [Object]", () => { + const cause = Cause.fail(new Error("stream tip update failed")); + const rendered = formatAlertCause(cause); + expect(rendered).toContain("stream tip update failed"); + expect(rendered).not.toContain("[Object]"); + }); + + it("falls back for plain Errors and strings", () => { + expect(formatAlertCause(new Error("boom"))).toContain("boom"); + expect(formatAlertCause("plain")).toBe("plain"); + }); + + it("keeps complete causes by default while honoring explicit preview limits", () => { + const cause = `start\n${"x".repeat(4_000)}\nend`; + expect(formatAlertCause(cause)).toBe(cause); + expect(formatAlertCause(cause, 20)).toBe(`${cause.slice(0, 20)}…`); + }); +}); + +describe("Discord alert content", () => { + it("reads the complete persisted session error before attaching it", () => { + const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-alert-trace-")); + const dbPath = NodePath.join(tempDir, "state.sqlite"); + const trace = `Error: Invalid params\n${" at decodeFrame (file:///long/path.js:1:1)\n".repeat(80)}`; + + try { + NodeChildProcess.execFileSync( + "python3", + [ + "-c", + [ + "import sqlite3, sys", + "db = sqlite3.connect(sys.argv[1])", + "db.execute('CREATE TABLE projection_thread_sessions (thread_id TEXT, last_error TEXT, status TEXT, updated_at TEXT)')", + "db.execute('INSERT INTO projection_thread_sessions VALUES (?, ?, ?, ?)', ('thread-1', sys.argv[2], 'error', '2026-07-28T00:00:00Z'))", + "db.commit()", + ].join("\n"), + dbPath, + trace, + ], + { encoding: "utf8" }, + ); + + expect(trace.length).toBeGreaterThan(300); + expect(listSessionErrors(dbPath)).toEqual([ + { + threadId: "thread-1", + lastError: trace, + status: "error", + updatedAt: "2026-07-28T00:00:00Z", + }, + ]); + } finally { + NodeFS.rmSync(tempDir, { recursive: true, force: true }); + } + }); + + it("attaches the complete T3 session stack as one text file", () => { + const trace = [ + "Error: Invalid params", + ...Array.from( + { length: 80 }, + (_, index) => + ` at decodeFrame${index} (file:///var/lib/t3/src/t3code/node_modules/effect/frame-${index}.js:877:8)`, + ), + ].join("\n"); + const delivery = sessionErrorAlertDelivery("2d9ccf35-a36a-41bc-a762-523f5e423f41", trace); + + expect(delivery.content).toContain("thread=`2d9ccf35-a36a-41bc-a762-523f5e423f41`"); + expect(delivery.content).not.toContain("Invalid params"); + expect(delivery.files).toHaveLength(1); + expect(delivery.files[0]?.name).toBe( + "t3-session-error-2d9ccf35-a36a-41bc-a762-523f5e423f41.txt", + ); + expect(delivery.files[0]?.mimeType).toBe("text/plain;charset=utf-8"); + expect(new TextDecoder().decode(delivery.files[0]?.data)).toBe(trace); + }); + + it("keeps fatal and bridge traces out of message content and intact in attachments", () => { + const trace = `start\n${"x".repeat(4_000)}\nend`; + for (const delivery of [ + fatalAlertDelivery("failure", trace), + bridgeAlertDelivery("failure", trace), + ]) { + expect(delivery.content).not.toContain(trace); + expect(delivery.files).toHaveLength(1); + expect(delivery.files[0]?.name.endsWith(".txt")).toBe(true); + expect(new TextDecoder().decode(delivery.files[0]?.data)).toBe(trace); + } + }); + + it("puts t3 thread id on the short fatal/bridge Discord message", () => { + const trace = "stack goes in the attachment"; + const threadId = "44c2ab99-729b-4999-83cc-3a4dd04432e0"; + const channelId = "1532989230219919520"; + const fatal = fatalAlertDelivery("T3 thread subscription exited", trace, { + threadId, + channelId, + }); + expect(fatal.content).toContain("**FATAL: T3 thread subscription exited**"); + expect(fatal.content).toContain(`thread=\`${threadId}\``); + expect(fatal.content).toContain(`channel=\`${channelId}\``); + expect(fatal.content).not.toContain(trace); + expect(new TextDecoder().decode(fatal.files[0]?.data)).toBe(trace); + + const bridge = bridgeAlertDelivery("Working heartbeat failed", trace, { threadId }); + expect(bridge.content).toContain("**BRIDGE: Working heartbeat failed**"); + expect(bridge.content).toContain(`thread=\`${threadId}\``); + expect(bridge.content).not.toContain("channel="); + }); +}); + +describe("session last_error alert classification", () => { + it("treats orphan / server-restart recover text as expected (not fatal)", () => { + expect( + isExpectedSessionLastError( + "Recovered orphan session (server_restart). Send a follow-up to resume.", + ), + ).toBe(true); + expect( + isExpectedSessionLastError( + "Server restarted while the agent was working. Send a follow-up to resume it.", + ), + ).toBe(true); + expect(classifySessionLastError({ lastError: "Recovered orphan session (reaper)." })).toBe( + "ignore", + ); + }); + + it("keeps real provider failures as fatal", () => { + expect( + classifySessionLastError({ + lastError: "ProviderAdapterProcessError: Failed to spawn ACP process for command: grok", + status: "error", + }), + ).toBe("fatal"); + }); + + it("filters recoveries and caps fatals for posting", () => { + const selected = selectSessionErrorsForAlert( + [ + { + threadId: "t1", + lastError: "Recovered orphan session (server_restart). Send a follow-up to resume.", + }, + { + threadId: "t2", + lastError: "Recovered orphan session (server_restart). Send a follow-up to resume.", + }, + { threadId: "t3", lastError: "Provider adapter process error (grok)" }, + { threadId: "t4", lastError: "Provider adapter process error (codex)" }, + ], + 1, + ); + expect(selected.ignoredRecoveryCount).toBe(2); + expect(selected.ignoredStaleCount).toBe(0); + expect(selected.fatals).toHaveLength(1); + expect(selected.fatals[0]?.threadId).toBe("t3"); + }); + + it("drops sticky last_error rows older than the max age window", () => { + const nowMs = Date.parse("2026-08-01T07:30:00.000Z"); + const selected = selectSessionErrorsForAlert( + [ + { + // The live spam: 10-day-old Invalid params still status=error. + threadId: "2d9ccf35-a36a-41bc-a762-523f5e423f41", + lastError: "Error: Invalid params\n at decodeJsonError (...)", + status: "error", + updatedAt: "2026-07-21T15:11:34.330Z", + }, + { + threadId: "fresh-1", + lastError: "ProviderAdapterProcessError: Failed to spawn ACP process for command: grok", + status: "error", + updatedAt: "2026-08-01T07:00:00.000Z", + }, + ], + 5, + { nowMs, maxAgeMs: SESSION_ERROR_MAX_AGE_MS }, + ); + expect(selected.ignoredStaleCount).toBe(1); + expect(selected.fatals).toEqual([ + { + threadId: "fresh-1", + lastError: "ProviderAdapterProcessError: Failed to spawn ACP process for command: grok", + }, + ]); + expect( + classifySessionLastError({ + lastError: "Error: Invalid params", + status: "error", + updatedAt: "2026-07-21T15:11:34.330Z", + nowMs, + }), + ).toBe("stale"); + expect(sessionErrorAgeMs("2026-07-21T15:11:34.330Z", nowMs)).toBeGreaterThan( + SESSION_ERROR_MAX_AGE_MS, + ); + }); + + it("shares cooldown keys across threads with the same failure signature", () => { + const a = sessionErrorAlertKey( + "aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb", + "Failed to spawn ACP process for thread aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb", + ); + const b = sessionErrorAlertKey( + "cccccccc-1111-2222-3333-dddddddddddd", + "Failed to spawn ACP process for thread cccccccc-1111-2222-3333-dddddddddddd", + ); + expect(a).toBe(b); + expect(a.startsWith("session-error-sig:")).toBe(true); + }); +}); + +describe("long-running turn alert milestones (0.25h × 2ⁿ)", () => { + const min = (n: number) => n * 60_000; + + it("stays quiet below the first 15m threshold", () => { + expect(longRunningTurnMilestoneMs(min(14))).toBeNull(); + expect(shouldAlertLongRunningTurn(min(14), undefined).alert).toBe(false); + }); + + it("pages at 15m, 30m, 1h, 2h, 4h and not between rungs", () => { + // First page at 15m. + expect(longRunningTurnMilestoneMs(min(15))).toBe(min(15)); + expect(shouldAlertLongRunningTurn(min(15), undefined)).toEqual({ + alert: true, + milestoneMs: min(15), + }); + // Still on the 15m rung until 30m — no re-page. + expect(longRunningTurnMilestoneMs(min(29))).toBe(min(15)); + expect(shouldAlertLongRunningTurn(min(29), min(15)).alert).toBe(false); + // 30m / 1h / 2h / 4h rungs. + expect(longRunningTurnMilestoneMs(min(30))).toBe(min(30)); + expect(longRunningTurnMilestoneMs(min(75))).toBe(min(60)); // the 75m spam case + expect(longRunningTurnMilestoneMs(min(125))).toBe(min(120)); + expect(longRunningTurnMilestoneMs(min(240))).toBe(min(240)); + + let last: number | undefined; + const ages = [15, 20, 25, 30, 45, 59, 60, 75, 90, 119, 120, 180, 240]; + const paged: number[] = []; + for (const ageMin of ages) { + const decision = shouldAlertLongRunningTurn(min(ageMin), last); + if (decision.alert) { + paged.push(ageMin); + last = decision.milestoneMs; + } + } + // Only when a new doubling rung is crossed — not every 10 minutes. + expect(paged).toEqual([15, 30, 60, 120, 240]); + }); + + it("re-pages at most once for the current rung after a restart", () => { + // Bot restart loses last milestone; age is already 75m → one page for 1h rung. + const decision = shouldAlertLongRunningTurn(min(75), undefined); + expect(decision).toEqual({ alert: true, milestoneMs: min(60) }); + expect(shouldAlertLongRunningTurn(min(75), min(60)).alert).toBe(false); + // Next page only when age reaches 2h. + expect(shouldAlertLongRunningTurn(min(119), min(60)).alert).toBe(false); + expect(shouldAlertLongRunningTurn(min(120), min(60))).toEqual({ + alert: true, + milestoneMs: min(120), + }); + }); + + it("formats milestone labels and next-rung helper", () => { + expect(formatLongRunningTurnMilestone(min(15))).toBe("15m"); + expect(formatLongRunningTurnMilestone(min(30))).toBe("30m"); + expect(formatLongRunningTurnMilestone(min(60))).toBe("1h"); + expect(formatLongRunningTurnMilestone(min(120))).toBe("2h"); + expect(nextLongRunningTurnMilestoneMs(TURN_RUNNING_MIN_MS)).toBe(min(30)); + expect(nextLongRunningTurnMilestoneMs(min(60))).toBe(min(120)); + }); +}); + +describe("trackSustainedHotProcesses", () => { + it("does not alert on a long-lived but idle process", () => { + // The reported bug: a process with lots of cumulative CPU time that now barely + // moves (a few seconds every tick) must never alert. +2s of CPU per 60s tick + // is ~3% of a core. + const ticks = Array.from({ length: 12 }, (_unused, i) => [ + proc({ pid: 773, rssMb: 141, cpuSeconds: 232 + i * 2 }), + ]); + expect(run(ticks).hot).toEqual([]); + }); + + it("alerts once a process stays CPU-hot for the sustained window", () => { + // A full core busy: +60s of CPU per 60s tick = ~100%. + const ticks = Array.from({ length: 6 }, (_unused, i) => [ + proc({ pid: 900, rssMb: 200, cpuSeconds: i * 60 }), + ]); + const hot = run(ticks).hot; + expect(hot).toHaveLength(1); + expect(hot[0]!.pid).toBe(900); + expect(hot[0]!.cpuPercent).toBeGreaterThanOrEqual(CPU_THRESHOLD); + expect(Math.round(hot[0]!.sustainedMs / TICK_MS)).toBe(4); + }); + + it("does not alert before the sustained window elapses", () => { + const ticks = Array.from({ length: 5 }, (_unused, i) => [ + proc({ pid: 900, cpuSeconds: i * 60 }), + ]); + expect(run(ticks).hot).toEqual([]); + }); + + it("resets the streak when CPU drops back to idle", () => { + const hotTick = (i: number) => [proc({ pid: 900, cpuSeconds: i * 60 })]; + const idleTick = (cpu: number) => [proc({ pid: 900, cpuSeconds: cpu })]; + // Three hot ticks, then idle — must clear, not alert. + const ticks = [hotTick(0), hotTick(1), hotTick(2), hotTick(3), idleTick(181), idleTick(182)]; + expect(run(ticks).hot).toEqual([]); + }); + + it("alerts on sustained high RSS even at zero CPU", () => { + const ticks = Array.from({ length: 5 }, () => [proc({ pid: 950, rssMb: 900, cpuSeconds: 5 })]); + const hot = run(ticks).hot; + expect(hot).toHaveLength(1); + expect(hot[0]!.rssMb).toBe(900); + expect(hot[0]!.cpuPercent).toBe(0); + }); + + it("treats a reused pid as a new process and resets its streak", () => { + const busy = Array.from({ length: 4 }, (_unused, i) => [ + proc({ pid: 900, cpuSeconds: i * 60 }), + ]); + // pid 900 reappears with a lower cumulative counter → different process. + const reused = [proc({ pid: 900, cpuSeconds: 1 })]; + expect(run([...busy, reused]).hot).toEqual([]); + }); + + it("prunes state for processes that have exited", () => { + const { state } = run([[proc({ pid: 900 })], [proc({ pid: 901 })]]); + expect(state.has(900)).toBe(false); + expect(state.has(901)).toBe(true); + }); +}); diff --git a/apps/discord-bot/src/features/Alerts.ts b/apps/discord-bot/src/features/Alerts.ts new file mode 100644 index 000000000000..01ff23a021c2 --- /dev/null +++ b/apps/discord-bot/src/features/Alerts.ts @@ -0,0 +1,1159 @@ +// @effect-diagnostics nodeBuiltinImport:off missingEffectContext:off anyUnknownInErrorContext:off +/** + * Guest-side ops alerts → a dedicated Discord channel. + * + * - Host: load, CPU%, memory, disk free + * - Runaways: legacy stdio Sentry MCP proliferation / high RSS → alert only (never kill) + * - T3: long-running turns (page at 0.25h × 2ⁿ age milestones); **real** session errors only + * (not orphan-restart recover text) + * - App: postFatalAlert() / postBridgeAlert() for hard + bridge failures + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import { DiscordConfig, DiscordREST } from "dfx"; +import * as Cause from "effect/Cause"; +import * as Clock from "effect/Clock"; +import * as Effect from "effect/Effect"; +import * as Redacted from "effect/Redacted"; +import * as Schedule from "effect/Schedule"; + +import { loadAlertProcessRulesFromFileSync, type AlertProcessRule } from "../alertProcessRules.ts"; +import type { DiscordBotConfig } from "../config.ts"; +import { + createMessageWithAttachments, + DiscordUploadError, + textFile, + type DiscordUploadFile, +} from "../presentation/discordFiles.ts"; + +const POLL_MS = 60 * 1000; +const POLL = "60 seconds"; +const COOLDOWN_MS = 10 * 60 * 1000; +/** Fatal errors use a shorter cooldown so distinct keys still surface quickly. */ +const FATAL_COOLDOWN_MS = 2 * 60 * 1000; +/** + * Session last_error fatals used to re-post every 2m per thread after restarts. + * Sticky projection rows never clear, so cooldown alone re-pages the same failure + * forever (e.g. a week-old "Invalid params" every 30m). Age-gate + matching + * cooldown: page once while the row is still fresh, then drop it. + */ +export const SESSION_ERROR_MAX_AGE_MS = 2 * 60 * 60 * 1000; +const SESSION_ERROR_FATAL_COOLDOWN_MS = SESSION_ERROR_MAX_AGE_MS; +/** Cap distinct session-error posts per watchdog tick. */ +const SESSION_ERROR_ALERT_MAX = 5; +/** Leave headroom below Discord's 2,000-character message-content limit. */ +const DISCORD_ALERT_MESSAGE_LIMIT = 1900; + +const LOAD_RATIO = 0.75; +const CPU_PERCENT_ALERT = 85; +const MEM_AVAILABLE_MIN_MB = 1024; +const DISK_FREE_MIN_PERCENT = 10; +const DISK_FREE_MIN_GB = 2; +/** Alert when a legacy stdio Sentry MCP process exceeds this RSS. */ +const SENTRY_RSS_ALERT_MB = 512; +const SENTRY_COUNT_ALERT = 2; +/** + * Default generic process rule for "unexpectedly hot" processes. + * The sustained duration preserves the prior five-sample window semantics: + * the first sample establishes the CPU-rate baseline, then four 60s intervals + * must stay hot before alerting. + * + * This measures a *rate* (Δcpu / Δwall between ticks), not cumulative CPU time: + * a long-lived-but-idle process (e.g. one that gathered 200s of CPU over hours + * yet now moves a few seconds per 10 min) is not a problem and used to re-alert + * forever. What we want to catch is a process actually pegging CPU or memory for + * a sustained stretch. + */ +const DEFAULT_PROCESS_CPU_PERCENT = 50; // percent of a single core, averaged over the tick gap +const DEFAULT_PROCESS_RSS_ALERT_MB = 768; +const DEFAULT_PROCESS_SUSTAINED_FOR_MS = 4 * POLL_MS; +/** + * First long-turn page threshold and base of the doubling milestone ladder. + * Pages at 0.25h, 0.5h, 1h, 2h, 4h, … (15m × 2ⁿ) while the turn stays `running`, + * instead of re-paging every fixed cooldown (was 10m — spammy for multi-hour turns). + */ +export const TURN_RUNNING_MIN_MS = 15 * 60 * 1000; + +/** Paths to check for free space (guest rootfs is tiny; data volume is the real store). */ +const DISK_PATHS = ["/", "/var/lib/t3"] as const; + +/** + * Processes we watch as "runaways" (alert only — never auto-kill). + * Targets legacy local `@sentry/mcp-server` stdio children. Excludes the shared + * `shared-sentry-mcp-proxy` HTTP proxy (contains "sentry-mcp" in the path). + */ +const RUNAWAY_PATTERNS: ReadonlyArray<{ + readonly id: string; + readonly match: (cmd: string) => boolean; +}> = [ + { + id: "sentry-mcp", + match: (cmd) => { + if (cmd.includes("shared-sentry-mcp-proxy") || cmd.includes("t3-watchdog")) return false; + return cmd.includes("@sentry/mcp-server") || /\bsentry-mcp\b/.test(cmd); + }, + }, +]; + +export interface ProcInfo { + readonly pid: number; + readonly rssMb: number; + readonly cpuSeconds: number; + readonly cmd: string; + readonly label: string; +} + +/** Per-process tracker state carried between ticks to derive a CPU rate. */ +export interface ProcSustainState { + readonly cpuSeconds: number; + readonly sampledAtMs: number; + readonly wasHot: boolean; + /** When the current hot streak began, for reporting how long it has lasted. */ + readonly hotSinceMs: number; +} + +/** A process that has been hot (high CPU rate or RSS) for long enough to alert. */ +export interface SustainedHotProcess { + readonly pid: number; + readonly rssMb: number; + /** Average CPU over the last tick gap, as percent of a single core. */ + readonly cpuPercent: number; + readonly ruleId: string; + readonly rssMbThreshold: number | null; + readonly cpuPercentThreshold: number | null; + readonly sustainedForMs: number; + /** How long it has been continuously hot. */ + readonly sustainedMs: number; + readonly label: string; +} + +interface ResolvedProcessAlertRule { + readonly id: string; + readonly rssMbThreshold: number | null; + readonly cpuPercentThreshold: number | null; + readonly sustainedForMs: number; +} + +const DEFAULT_PROCESS_ALERT_RULE: ResolvedProcessAlertRule = { + id: "default", + rssMbThreshold: DEFAULT_PROCESS_RSS_ALERT_MB, + cpuPercentThreshold: DEFAULT_PROCESS_CPU_PERCENT, + sustainedForMs: DEFAULT_PROCESS_SUSTAINED_FOR_MS, +}; + +/** + * Advance the per-process hotness tracker by one tick. + * + * Pure so the streak/rate logic is testable without /proc. Only pids present in + * `procs` survive into the returned state, which prunes exited processes; a pid + * whose CPU counter went backwards is treated as reused and its streak resets. + */ +export function trackSustainedHotProcesses(input: { + readonly prev: ReadonlyMap; + readonly procs: ReadonlyArray; + readonly nowMs: number; + readonly resolveRule: (proc: ProcInfo) => ResolvedProcessAlertRule; +}): { + readonly next: Map; + readonly hot: ReadonlyArray; +} { + const next = new Map(); + const hot: SustainedHotProcess[] = []; + + for (const proc of input.procs) { + const rule = input.resolveRule(proc); + const prior = input.prev.get(proc.pid); + // A counter that went backwards means the pid was reused; ignore the prior. + const reused = prior !== undefined && proc.cpuSeconds < prior.cpuSeconds; + const previous = reused ? undefined : prior; + + const elapsedMs = previous ? input.nowMs - previous.sampledAtMs : 0; + const cpuPercent = + previous && elapsedMs > 0 + ? (Math.max(0, proc.cpuSeconds - previous.cpuSeconds) / (elapsedMs / 1_000)) * 100 + : null; + + const isHot = + (rule.cpuPercentThreshold !== null && + cpuPercent !== null && + cpuPercent >= rule.cpuPercentThreshold) || + (rule.rssMbThreshold !== null && proc.rssMb >= rule.rssMbThreshold); + const hotSinceMs = isHot ? (previous?.wasHot ? previous.hotSinceMs : input.nowMs) : input.nowMs; + + next.set(proc.pid, { + cpuSeconds: proc.cpuSeconds, + sampledAtMs: input.nowMs, + wasHot: isHot, + hotSinceMs, + }); + + if (isHot && input.nowMs - hotSinceMs >= rule.sustainedForMs) { + hot.push({ + pid: proc.pid, + rssMb: proc.rssMb, + cpuPercent: cpuPercent ?? 0, + ruleId: rule.id, + rssMbThreshold: rule.rssMbThreshold, + cpuPercentThreshold: rule.cpuPercentThreshold, + sustainedForMs: rule.sustainedForMs, + sustainedMs: input.nowMs - hotSinceMs, + label: proc.label, + }); + } + } + + hot.sort((a, b) => b.cpuPercent - a.cpuPercent || b.rssMb - a.rssMb); + return { next, hot: hot.slice(0, 8) }; +} + +export interface DiskInfo { + readonly path: string; + readonly totalGb: number; + readonly freeGb: number; + readonly freePercent: number; +} + +export interface HostSnapshot { + readonly load1: number; + readonly load5: number; + readonly nproc: number; + readonly cpuPercent: number | null; + readonly memTotalMb: number; + readonly memAvailableMb: number; + readonly disks: ReadonlyArray; + readonly runaways: ReadonlyArray; + readonly fatProcesses: ReadonlyArray; + readonly longTurns: ReadonlyArray<{ + readonly threadId: string; + readonly turnId: string; + readonly ageMin: number; + }>; + readonly sessionErrors: ReadonlyArray<{ + readonly threadId: string; + readonly lastError: string; + readonly status?: string | null; + readonly updatedAt?: string | null; + }>; + readonly failedUnits: ReadonlyArray; +} + +export type SessionLastErrorKind = "ignore" | "stale" | "fatal"; + +/** + * Operational recover text that must not page as FATAL. + * Written by orphan settle after server restart / reaper — expected, high volume. + */ +export function isExpectedSessionLastError(lastError: string): boolean { + const text = lastError.trim().toLowerCase(); + if (text === "") return true; + if (text.includes("recovered orphan session")) return true; + if (text.includes("server restarted while the agent was working")) return true; + if (text.includes("send a follow-up to resume")) return true; + return false; +} + +/** + * Age of a projection_thread_sessions.updated_at value, or null if unparseable. + * Sticky last_error rows keep their original timestamp; use this to drop ancient noise. + */ +export function sessionErrorAgeMs( + updatedAt: string | null | undefined, + nowMs: number, +): number | null { + if (updatedAt == null || updatedAt.trim() === "") return null; + const parsed = Date.parse(updatedAt); + if (Number.isNaN(parsed)) return null; + return Math.max(0, nowMs - parsed); +} + +/** + * Classify a session last_error for the ops watchdog. + * - ignore: expected recover / empty + * - stale: real failure text, but too old to re-page (sticky projection row) + * - fatal: real provider / process / hard session failure still worth paging + */ +export function classifySessionLastError(input: { + readonly lastError: string; + readonly status?: string | null | undefined; + readonly updatedAt?: string | null | undefined; + readonly nowMs?: number; + readonly maxAgeMs?: number; +}): SessionLastErrorKind { + if (isExpectedSessionLastError(input.lastError)) return "ignore"; + // Age-gate only when the caller supplied both updatedAt and nowMs (projection path). + // Pure text-only classification (unit tests) skips the gate — no Date.now() here. + if (input.updatedAt !== undefined && input.nowMs !== undefined) { + const maxAgeMs = input.maxAgeMs ?? SESSION_ERROR_MAX_AGE_MS; + const ageMs = sessionErrorAgeMs(input.updatedAt, input.nowMs); + // null/unparseable timestamps: treat as stale so a bad row cannot page forever. + if (ageMs === null || ageMs > maxAgeMs) return "stale"; + } + // Prefer true error rows; still allow non-empty last_error on other statuses when + // the text is not an expected recover (e.g. ACP spawn failure left on interrupted). + if (input.status === "error" || input.status === "interrupted" || input.status == null) { + return "fatal"; + } + // ready/idle/stopped with a leftover last_error string — still worth a quiet fatal + // once, but not recover spam (already ignored above). + return "fatal"; +} + +/** + * Filter + cap session errors for Discord posting. + * Groups ignored recoveries / stale stickies for optional summary; never emits them as FATAL. + */ +export function selectSessionErrorsForAlert( + errors: ReadonlyArray<{ + readonly threadId: string; + readonly lastError: string; + readonly status?: string | null | undefined; + readonly updatedAt?: string | null | undefined; + }>, + maxFatals: number = SESSION_ERROR_ALERT_MAX, + timing?: { readonly nowMs: number; readonly maxAgeMs?: number }, +): { + readonly fatals: ReadonlyArray<{ readonly threadId: string; readonly lastError: string }>; + readonly ignoredRecoveryCount: number; + readonly ignoredStaleCount: number; +} { + let ignoredRecoveryCount = 0; + let ignoredStaleCount = 0; + const fatals: Array<{ threadId: string; lastError: string }> = []; + const maxAgeMs = timing?.maxAgeMs ?? SESSION_ERROR_MAX_AGE_MS; + for (const entry of errors) { + const kind = classifySessionLastError({ + lastError: entry.lastError, + status: entry.status, + updatedAt: entry.updatedAt, + ...(timing !== undefined ? { nowMs: timing.nowMs, maxAgeMs } : {}), + }); + if (kind === "ignore") { + ignoredRecoveryCount += 1; + continue; + } + if (kind === "stale") { + ignoredStaleCount += 1; + continue; + } + if (fatals.length < Math.max(0, maxFatals)) { + fatals.push({ threadId: entry.threadId, lastError: entry.lastError }); + } + } + return { fatals, ignoredRecoveryCount, ignoredStaleCount }; +} + +/** Stable-ish key so identical failure text across threads shares one cooldown bucket. */ +export function sessionErrorAlertKey(threadId: string, lastError: string): string { + const signature = lastError + .trim() + .toLowerCase() + .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/giu, "") + .replace(/\b\d{4,}\b/gu, "") + .slice(0, 120); + // Prefer signature-first so N threads with the same spawn error share cooldown. + // Fall back to thread id when the body is empty/unique. + if (signature.length >= 12) { + return `session-error-sig:${signature}`; + } + return `session-error:${threadId}`; +} + +// --- /proc helpers ----------------------------------------------------------- + +function readLoad(): { load1: number; load5: number } { + const raw = NodeFS.readFileSync("/proc/loadavg", "utf8"); + const parts = raw.split(/\s+/); + return { load1: Number(parts[0] ?? "0"), load5: Number(parts[1] ?? "0") }; +} + +function readNproc(): number { + try { + return NodeFS.readdirSync("/sys/devices/system/cpu").filter((name) => /^cpu\d+$/.test(name)) + .length; + } catch { + return 1; + } +} + +function readMemMb(): { total: number; available: number } { + const raw = NodeFS.readFileSync("/proc/meminfo", "utf8"); + const get = (key: string) => { + const match = new RegExp(`^${key}:\\s+(\\d+)`, "m").exec(raw); + return match ? Number(match[1]) / 1024 : 0; + }; + return { total: get("MemTotal"), available: get("MemAvailable") }; +} + +/** Sample total jiffies from /proc/stat (all cpus line). */ +function readCpuJiffies(): { idle: number; total: number } | null { + try { + const line = NodeFS.readFileSync("/proc/stat", "utf8").split("\n")[0] ?? ""; + // cpu user nice system idle iowait irq softirq steal ... + const parts = line.trim().split(/\s+/).slice(1).map(Number); + if (parts.length < 4) return null; + const idle = (parts[3] ?? 0) + (parts[4] ?? 0); // idle + iowait + const total = parts.reduce((a, b) => a + b, 0); + return { idle, total }; + } catch { + return null; + } +} + +let lastCpuSample: { idle: number; total: number } | null = null; + +function sampleCpuPercent(): number | null { + const now = readCpuJiffies(); + if (now === null) return null; + const prev = lastCpuSample; + lastCpuSample = now; + if (prev === null) return null; + const dTotal = now.total - prev.total; + const dIdle = now.idle - prev.idle; + if (dTotal <= 0) return null; + return Math.max(0, Math.min(100, (1 - dIdle / dTotal) * 100)); +} + +function readDisk(path: string): DiskInfo | null { + try { + if (!NodeFS.existsSync(path)) return null; + const s = NodeFS.statfsSync(path); + // Node types: bsize, blocks, bfree, bavail + const bsize = Number(s.bsize); + const total = Number(s.blocks) * bsize; + const free = Number(s.bavail) * bsize; + if (total <= 0) return null; + return { + path, + totalGb: total / 1024 ** 3, + freeGb: free / 1024 ** 3, + freePercent: (free / total) * 100, + }; + } catch { + return null; + } +} + +function readRssMb(pid: number): number { + try { + const status = NodeFS.readFileSync(`/proc/${pid}/status`, "utf8"); + const match = /^VmRSS:\s+(\d+)\s+kB/m.exec(status); + return match ? Number(match[1]) / 1024 : 0; + } catch { + return 0; + } +} + +/** utime + stime from /proc/pid/stat (clock ticks → seconds). */ +function readCpuSeconds(pid: number): number { + try { + const stat = NodeFS.readFileSync(`/proc/${pid}/stat`, "utf8"); + // comm can contain spaces/parens — split after last ") " + const idx = stat.lastIndexOf(") "); + if (idx < 0) return 0; + const fields = stat.slice(idx + 2).split(/\s+/); + const utime = Number(fields[11] ?? 0); // 14th field overall, 12th after state + const stime = Number(fields[12] ?? 0); + const ticks = + Number(NodeChildProcess.execFileSync("getconf", ["CLK_TCK"], { encoding: "utf8" }).trim()) || + 100; + return (utime + stime) / ticks; + } catch { + try { + // fields: after ") " → state ppid ... utime is index 11 (0-based) in the remainder + const stat = NodeFS.readFileSync(`/proc/${pid}/stat`, "utf8"); + const idx = stat.lastIndexOf(") "); + const fields = stat.slice(idx + 2).split(/\s+/); + return (Number(fields[11] ?? 0) + Number(fields[12] ?? 0)) / 100; + } catch { + return 0; + } + } +} + +function readCmdline(pid: number): string { + try { + return NodeFS.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").join(" ").trim(); + } catch { + return ""; + } +} + +function shortCmd(cmd: string): string { + if (cmd.includes("shared-sentry-mcp-proxy")) return "shared-sentry-mcp-proxy"; + if (cmd.includes("@sentry/mcp-server") || /\bsentry-mcp\b/.test(cmd)) return "sentry-mcp"; + const base = cmd.split(/\s+/).find((p) => p.includes("/")) ?? cmd; + return base.slice(-80); +} + +function listProcesses(): ReadonlyArray { + const out: ProcInfo[] = []; + for (const ent of NodeFS.readdirSync("/proc")) { + if (!/^\d+$/.test(ent)) continue; + const pid = Number(ent); + if (pid === process.pid) continue; + const cmd = readCmdline(pid); + if (cmd === "") continue; + out.push({ + pid, + rssMb: readRssMb(pid), + cpuSeconds: readCpuSeconds(pid), + cmd, + label: shortCmd(cmd), + }); + } + return out; +} + +function listRunaways(procs: ReadonlyArray): ReadonlyArray { + return procs.filter((p) => RUNAWAY_PATTERNS.some((rule) => rule.match(p.cmd))); +} + +// Per-tick tracker state for sustained-hotness detection. Module-level because +// it must persist across `collectHostSnapshot` calls; the logic itself lives in +// the pure `trackSustainedHotProcesses`. +let sustainState: ReadonlyMap = new Map(); + +function listFatProcesses( + procs: ReadonlyArray, + nowMs: number, + rules: ReadonlyArray, +): ReadonlyArray { + // Generic sustained high RSS / CPU alerts (never auto-kill). Our own long-lived + // services are excluded — they are expected to run hot and are handled by + // dedicated checks, not this generic catch-all. + const skip = (cmd: string) => + cmd.includes("t3code") || + cmd.includes("apps/server") || + cmd.includes("discord-bot") || + cmd.includes("shared-sentry-mcp-proxy") || + cmd.includes("codex app-server") || + cmd.includes("cloud-hypervisor") || + cmd.includes("virtiofsd"); + + const resolveRule = (proc: ProcInfo): ResolvedProcessAlertRule => { + const normalizedCmd = proc.cmd.toLowerCase(); + const normalizedLabel = proc.label.toLowerCase(); + const custom = rules.find((rule) => { + const match = rule.match.toLowerCase(); + return normalizedCmd.includes(match) || normalizedLabel.includes(match); + }); + if (custom === undefined) return DEFAULT_PROCESS_ALERT_RULE; + return { + id: custom.id, + rssMbThreshold: custom.rssMbThreshold ?? null, + cpuPercentThreshold: custom.cpuPercentThreshold ?? null, + sustainedForMs: custom.sustainedForMs, + }; + }; + + const { next, hot } = trackSustainedHotProcesses({ + prev: sustainState, + procs: procs.filter((p) => !skip(p.cmd)), + nowMs, + resolveRule, + }); + sustainState = next; + return hot; +} + +function querySqliteJson(dbPath: string, scriptBody: string, extraArgs: string[] = []): unknown { + if (!NodeFS.existsSync(dbPath)) return null; + try { + const script = ` +import json, sqlite3, sys, time +from datetime import datetime +db_path = sys.argv[1] +db = sqlite3.connect("file:" + db_path + "?mode=ro", uri=True) +${scriptBody} +`; + const raw = NodeChildProcess.execFileSync("python3", ["-c", script, dbPath, ...extraArgs], { + encoding: "utf8", + timeout: 5_000, + }); + return JSON.parse(raw); + } catch { + return null; + } +} + +/** + * Highest 0.25h × 2ⁿ milestone the turn age has reached, or `null` if still + * below the first page threshold. + * + * Examples (base 15m): 14m → null; 15–29m → 15m; 30–59m → 30m; 60–119m → 60m; + * 125m → 120m. + */ +export function longRunningTurnMilestoneMs( + ageMs: number, + baseMs: number = TURN_RUNNING_MIN_MS, +): number | null { + if (!(ageMs >= baseMs) || !(baseMs > 0)) return null; + const exp = Math.floor(Math.log2(ageMs / baseMs)); + if (!Number.isFinite(exp) || exp < 0) return null; + return baseMs * 2 ** exp; +} + +/** Next doubling milestone after the one we just paged (cap not applied). */ +export function nextLongRunningTurnMilestoneMs(milestoneMs: number): number { + return milestoneMs * 2; +} + +/** Human label for a milestone duration: `15m`, `30m`, `1h`, `2h`, … */ +export function formatLongRunningTurnMilestone(milestoneMs: number): string { + const minutes = milestoneMs / 60_000; + if (minutes < 60) return `${Math.round(minutes)}m`; + const hours = minutes / 60; + if (Number.isInteger(hours)) return `${hours}h`; + // Keep one decimal for non-integer hours (shouldn't happen on pure 2ⁿ ladder). + return `${hours}h`; +} + +/** + * Whether to page for this long-running turn given the last milestone already + * posted for its `turnId`. Milestone is derived from turn age (not wall-clock + * since last post), so bot restarts re-page at most once for the current rung. + */ +export function shouldAlertLongRunningTurn( + ageMs: number, + lastAlertedMilestoneMs: number | undefined, + baseMs: number = TURN_RUNNING_MIN_MS, +): + | { readonly alert: true; readonly milestoneMs: number } + | { readonly alert: false; readonly milestoneMs: number | null } { + const milestoneMs = longRunningTurnMilestoneMs(ageMs, baseMs); + if (milestoneMs === null) { + return { alert: false, milestoneMs: null }; + } + if (lastAlertedMilestoneMs !== undefined && milestoneMs <= lastAlertedMilestoneMs) { + return { alert: false, milestoneMs }; + } + return { alert: true, milestoneMs }; +} + +function listLongRunningTurns( + dbPath: string, + minAgeMs: number, +): ReadonlyArray<{ threadId: string; turnId: string; ageMin: number }> { + const parsed = querySqliteJson( + dbPath, + ` +min_age_ms = float(sys.argv[2]) +cur = db.execute( + "SELECT thread_id, turn_id, requested_at FROM projection_turns " + "WHERE state = 'running' AND turn_id IS NOT NULL ORDER BY requested_at ASC LIMIT 10" +) +now = time.time() +out = [] +for thread_id, turn_id, requested_at in cur: + try: + started = datetime.fromisoformat(requested_at.replace("Z", "+00:00")).timestamp() + except Exception: + started = now + age_ms = (now - started) * 1000 + if age_ms >= min_age_ms: + out.append({"threadId": thread_id, "turnId": turn_id, "ageMin": int(age_ms // 60000)}) +print(json.dumps(out)) +`, + [String(minAgeMs)], + ); + return (parsed as Array<{ threadId: string; turnId: string; ageMin: number }>) ?? []; +} + +export function listSessionErrors(dbPath: string): ReadonlyArray<{ + threadId: string; + lastError: string; + status: string | null; + updatedAt: string | null; +}> { + const parsed = querySqliteJson( + dbPath, + ` +cur = db.execute( + "SELECT thread_id, last_error, status, updated_at FROM projection_thread_sessions " + "WHERE last_error IS NOT NULL AND TRIM(last_error) != '' " + "ORDER BY updated_at DESC LIMIT 40" +) +print(json.dumps([ + {"threadId": r[0], "lastError": r[1] or "", "status": r[2], "updatedAt": r[3]} + for r in cur +])) +`, + ); + return ( + (parsed as Array<{ + threadId: string; + lastError: string; + status: string | null; + updatedAt: string | null; + }>) ?? [] + ); +} + +function listFailedSystemdUnits(): ReadonlyArray { + try { + const raw = NodeChildProcess.execFileSync( + "systemctl", + ["list-units", "--failed", "--no-legend", "--no-pager", "--plain"], + { encoding: "utf8", timeout: 5_000 }, + ); + return raw + .split("\n") + .map((line) => line.trim().split(/\s+/)[0] ?? "") + .filter((u) => u.endsWith(".service") || u.endsWith(".timer")); + } catch { + return []; + } +} + +export function collectHostSnapshot(input: { + readonly stateSqlitePath: string | undefined; + readonly nowMs: number; + readonly alertProcessRules: ReadonlyArray; +}): HostSnapshot { + const mem = readMemMb(); + const load = readLoad(); + const procs = listProcesses(); + const disks = DISK_PATHS.map(readDisk).filter((d): d is DiskInfo => d !== null); + const db = input.stateSqlitePath ?? ""; + return { + load1: load.load1, + load5: load.load5, + nproc: Math.max(1, readNproc()), + cpuPercent: sampleCpuPercent(), + memTotalMb: mem.total, + memAvailableMb: mem.available, + disks, + runaways: listRunaways(procs), + fatProcesses: listFatProcesses(procs, input.nowMs, input.alertProcessRules), + longTurns: listLongRunningTurns(db, TURN_RUNNING_MIN_MS), + sessionErrors: listSessionErrors(db), + failedUnits: listFailedSystemdUnits(), + }; +} + +// --- Fatal / bridge alert bus (callable from bridge / main) ------------------ + +type Poster = ( + key: string, + content: string, + cooldownMs?: number, + files?: ReadonlyArray, +) => Effect.Effect; + +let poster: Poster | null = null; + +/** Bridge snapshot handler failures: short enough to notice, long enough to avoid spam. */ +const BRIDGE_ALERT_COOLDOWN_MS = 3 * 60 * 1000; +const TRACE_MIME_TYPE = "text/plain;charset=utf-8"; + +export interface AlertTraceDelivery { + readonly content: string; + readonly files: ReadonlyArray; +} + +function alertTraceDelivery(content: string, filename: string, trace: string): AlertTraceDelivery { + return { + content: `${content}\n_Complete trace attached as \`${filename}\`._`, + files: [textFile(filename, trace, TRACE_MIME_TYPE)], + }; +} + +/** Identity lines shown in the short Discord alert body (not only the attachment). */ +export type AlertIdentity = { + readonly threadId?: string; + readonly channelId?: string; +}; + +function alertIdentityLines(identity?: AlertIdentity): ReadonlyArray { + if (identity === undefined) return []; + const lines: string[] = []; + if (identity.threadId !== undefined && identity.threadId.trim() !== "") { + lines.push(`thread=\`${identity.threadId}\``); + } + if (identity.channelId !== undefined && identity.channelId.trim() !== "") { + lines.push(`channel=\`${identity.channelId}\``); + } + return lines; +} + +export function fatalAlertDelivery( + title: string, + trace: string, + identity?: AlertIdentity, +): AlertTraceDelivery { + return alertTraceDelivery( + [`**FATAL: ${title}**`, ...alertIdentityLines(identity)].join("\n"), + "fatal-trace.txt", + trace, + ); +} + +export function bridgeAlertDelivery( + title: string, + trace: string, + identity?: AlertIdentity, +): AlertTraceDelivery { + return alertTraceDelivery( + [`**BRIDGE: ${title}**`, ...alertIdentityLines(identity)].join("\n"), + "bridge-trace.txt", + trace, + ); +} + +export function sessionErrorAlertDelivery(threadId: string, trace: string): AlertTraceDelivery { + const filename = `t3-session-error-${threadId}.txt`; + return alertTraceDelivery( + ["**FATAL: T3 session error**", `thread=\`${threadId}\``].join("\n"), + filename, + trace, + ); +} + +/** + * Render an Effect `Cause` (or any thrown value) for Discord / logs. + * Logging `{ cause }` alone shows `{ _id: 'Cause', failures: [ [Object] ] }`. + */ +export function formatAlertCause(cause: unknown, maxLen?: number): string { + let text: string; + try { + if (Cause.isCause(cause)) { + text = Cause.pretty(cause); + } else if (cause instanceof Error) { + text = cause.stack?.trim() || cause.message || String(cause); + } else if (typeof cause === "string") { + text = cause; + } else { + text = JSON.stringify(cause, null, 2) ?? String(cause); + } + } catch { + text = String(cause); + } + const trimmed = text.replace(/\s+$/u, "").trim(); + if (trimmed === "") return "(empty cause)"; + return maxLen !== undefined && trimmed.length > maxLen ? `${trimmed.slice(0, maxLen)}…` : trimmed; +} + +/** + * Post a **fatal** ops alert (short cooldown). Safe no-op if watchdog not started + * or channel unset. Does not require DiscordREST in the caller — uses the + * watchdog-held poster. + */ +export const postFatalAlert = ( + key: string, + title: string, + detail: string, + identity?: AlertIdentity, +) => + Effect.gen(function* () { + const p = poster; + if (p === null) { + yield* Effect.logError(`Fatal (no alerts channel): ${title}`, { detail, ...identity }); + return; + } + const delivery = fatalAlertDelivery(title, detail, identity); + yield* p(`fatal:${key}`, delivery.content, FATAL_COOLDOWN_MS, delivery.files); + }); + +/** + * Post a **bridge** ops alert (medium cooldown). Use for onThread failures, + * stream/heartbeat Discord errors, and other bridge soft-failures that leave + * Discord threads desynced while T3 still advances. + */ +export const postBridgeAlert = ( + key: string, + title: string, + detail: string, + identity?: AlertIdentity, +) => + Effect.gen(function* () { + const p = poster; + if (p === null) { + yield* Effect.logError(`Bridge alert (no alerts channel): ${title}`, { detail, ...identity }); + return; + } + const delivery = bridgeAlertDelivery(title, detail, identity); + yield* p(`bridge:${key}`, delivery.content, BRIDGE_ALERT_COOLDOWN_MS, delivery.files); + }); + +// --- Watchdog ---------------------------------------------------------------- + +/** + * Periodic guest watchdog → Discord alerts channel. + * No-op (log only) when `alertsChannelId` is unset. + */ +export const runAlertWatchdog = (botConfig: DiscordBotConfig) => + Effect.gen(function* () { + const channelId = botConfig.alertsChannelId; + if (channelId === undefined || channelId.trim() === "") { + yield* Effect.logInfo( + "Discord alerts channel unset (DISCORD_ALERTS_CHANNEL_ID); watchdog idle", + ); + return; + } + + const rest = yield* DiscordREST; + const discordConfig = yield* DiscordConfig.DiscordConfig; + const alertProcessRules = loadAlertProcessRulesFromFileSync(botConfig.alertProcessRulesPath); + const lastSent = new Map(); + /** Highest long-turn milestone already posted per `turnId` (0.25h × 2ⁿ ladder). */ + const lastTurnMilestones = new Map(); + + const postAlert: Poster = (key, content, cooldownMs = COOLDOWN_MS, files = []) => + Effect.gen(function* () { + const now = yield* Clock.currentTimeMillis; + const prev = lastSent.get(key) ?? 0; + if (now - prev < cooldownMs) return; + lastSent.set(key, now); + const body = + content.length > DISCORD_ALERT_MESSAGE_LIMIT + ? `${content.slice(0, DISCORD_ALERT_MESSAGE_LIMIT)}…` + : content; + yield* Effect.gen(function* () { + if (files.length === 0) { + yield* rest.createMessage(channelId, { content: body }); + } else { + yield* Effect.tryPromise({ + try: () => + createMessageWithAttachments({ + baseUrl: discordConfig.rest.baseUrl, + botToken: Redacted.value(discordConfig.token), + channelId, + content: body, + files, + }), + catch: (cause) => + cause instanceof DiscordUploadError + ? cause + : new DiscordUploadError(cause instanceof Error ? cause.message : String(cause)), + }); + } + yield* Effect.logInfo("Posted Discord ops alert", { + key, + channelId, + fileCount: files.length, + }); + }).pipe( + Effect.catchCause((cause) => + Effect.logError("Failed to post Discord ops alert").pipe( + Effect.andThen(Effect.logError(cause)), + ), + ), + ); + }); + + poster = postAlert; + + // Prime CPU sample so the next tick has a delta. No boot/idle chatter — + // only post when a check fails. + sampleCpuPercent(); + + yield* Effect.repeat( + Effect.gen(function* () { + const nowMs = yield* Clock.currentTimeMillis; + const snap = collectHostSnapshot({ + stateSqlitePath: botConfig.stateSqlitePath, + nowMs, + alertProcessRules, + }); + const loadLimit = snap.nproc * LOAD_RATIO; + + // --- load --- + if (snap.load1 >= loadLimit && snap.load1 >= 2) { + yield* postAlert( + "load", + [ + "**High load**", + `load1=${snap.load1.toFixed(2)} load5=${snap.load5.toFixed(2)}`, + `threshold≈${loadLimit.toFixed(2)} on ${snap.nproc} CPUs`, + `cpu≈${snap.cpuPercent?.toFixed(0) ?? "?"}%; mem avail=${snap.memAvailableMb.toFixed(0)} MiB`, + ].join("\n"), + ); + } + + // --- cpu --- + if (snap.cpuPercent !== null && snap.cpuPercent >= CPU_PERCENT_ALERT) { + yield* postAlert( + "cpu", + [ + "**High CPU**", + `cpu≈${snap.cpuPercent.toFixed(0)}% (alert ≥${CPU_PERCENT_ALERT}%)`, + `load1=${snap.load1.toFixed(2)} nproc=${snap.nproc}`, + snap.fatProcesses.length > 0 + ? `sustained:\n${snap.fatProcesses + .slice(0, 5) + .map( + (p) => + `• pid=${p.pid} rss=${p.rssMb.toFixed(0)}MiB cpu≈${p.cpuPercent.toFixed(0)}% ${p.label}`, + ) + .join("\n")}` + : "", + ] + .filter(Boolean) + .join("\n"), + ); + } + + // --- memory --- + if (snap.memAvailableMb > 0 && snap.memAvailableMb < MEM_AVAILABLE_MIN_MB) { + yield* postAlert( + "mem", + [ + "**Low memory**", + `available=${snap.memAvailableMb.toFixed(0)} MiB (min ${MEM_AVAILABLE_MIN_MB})`, + `total=${snap.memTotalMb.toFixed(0)} MiB`, + snap.runaways.length > 0 + ? `runaways: ${snap.runaways.map((s) => `pid=${s.pid} ${s.rssMb.toFixed(0)}MiB`).join(", ")}` + : "", + ] + .filter(Boolean) + .join("\n"), + ); + } + + // --- disk --- + for (const d of snap.disks) { + if (d.freePercent < DISK_FREE_MIN_PERCENT || d.freeGb < DISK_FREE_MIN_GB) { + yield* postAlert( + `disk:${d.path}`, + [ + "**Low disk space**", + `path=\`${d.path}\``, + `free=${d.freeGb.toFixed(1)} GiB (${d.freePercent.toFixed(0)}%) of ${d.totalGb.toFixed(1)} GiB`, + `thresholds: <${DISK_FREE_MIN_PERCENT}% or <${DISK_FREE_MIN_GB} GiB`, + ].join("\n"), + ); + } + } + + // --- runaway MCP (legacy stdio Sentry) — alert only, never kill --- + const runaways = snap.runaways; + if (runaways.length >= SENTRY_COUNT_ALERT) { + yield* postAlert( + "runaway-count", + [ + `**Legacy Sentry MCP stdio process(es)** (${runaways.length})`, + ...runaways.map( + (s) => + `• pid=${s.pid} rss=${s.rssMb.toFixed(0)} MiB cpuTime=${s.cpuSeconds.toFixed(0)}s ${s.label}`, + ), + "_Not auto-killed. Prefer shared proxy `shared-sentry-mcp-proxy` + `/etc/shared-mcp-setup`._", + ].join("\n"), + ); + } else { + const fat = runaways.filter((s) => s.rssMb >= SENTRY_RSS_ALERT_MB); + if (fat.length > 0) { + yield* postAlert( + "runaway-rss", + [ + "**Legacy Sentry MCP high RSS**", + ...fat.map( + (s) => + `• pid=${s.pid} rss=${s.rssMb.toFixed(0)} MiB (alert ≥${SENTRY_RSS_ALERT_MB}) ${s.label}`, + ), + "_Not auto-killed. Check agent MCP config points at http://127.0.0.1:7391/mcp._", + ].join("\n"), + ); + } + } + + // --- other stuck/fat processes (alert only) --- + const fatNonRunaway = snap.fatProcesses.filter( + (p) => !runaways.some((k) => k.pid === p.pid), + ); + if (fatNonRunaway.length > 0) { + yield* postAlert( + "stuck-proc", + [ + "**Sustained high RSS / CPU process(es)**", + ...fatNonRunaway.map( + (p) => + `• pid=${p.pid} rss=${p.rssMb.toFixed(0)}MiB cpu≈${p.cpuPercent.toFixed(0)}% ` + + `for ${Math.round(p.sustainedMs / 60_000)}m ${p.label}`, + ), + ...fatNonRunaway.map((p) => { + const parts = []; + if (p.rssMbThreshold !== null) parts.push(`RSS≥${p.rssMbThreshold.toFixed(0)}MiB`); + if (p.cpuPercentThreshold !== null) { + parts.push(`CPU≥${p.cpuPercentThreshold.toFixed(0)}% of a core`); + } + return `_rule=${p.ruleId}; sustained ≥${Math.round(p.sustainedForMs / 60_000)}m; ${parts.join(" or ")}._`; + }), + ].join("\n"), + ); + } + + // --- long T3 turns (page at 0.25h × 2ⁿ age milestones; drop finished turns) --- + const longTurnIds = new Set(snap.longTurns.map((t) => t.turnId)); + for (const turnId of lastTurnMilestones.keys()) { + if (!longTurnIds.has(turnId)) lastTurnMilestones.delete(turnId); + } + for (const turn of snap.longTurns) { + const ageMs = turn.ageMin * 60_000; + const decision = shouldAlertLongRunningTurn(ageMs, lastTurnMilestones.get(turn.turnId)); + if (!decision.alert) continue; + lastTurnMilestones.set(turn.turnId, decision.milestoneMs); + const milestoneLabel = formatLongRunningTurnMilestone(decision.milestoneMs); + const nextLabel = formatLongRunningTurnMilestone( + nextLongRunningTurnMilestoneMs(decision.milestoneMs), + ); + // Cooldown 0: cadence is the age-milestone ladder, not wall-clock spacing. + yield* postAlert( + `turn:${turn.turnId}`, + [ + "**Long-running T3 turn**", + `thread=\`${turn.threadId}\``, + `turn=\`${turn.turnId}\``, + `age≈${turn.ageMin} min · milestone ${milestoneLabel} (next ~${nextLabel}; ladder 15m×2ⁿ)`, + ].join("\n"), + 0, + ); + } + + // --- session last_error (fresh real fatals only; skip recover + sticky stale) --- + const sessionSelection = selectSessionErrorsForAlert( + snap.sessionErrors, + SESSION_ERROR_ALERT_MAX, + { + nowMs, + maxAgeMs: SESSION_ERROR_MAX_AGE_MS, + }, + ); + for (const err of sessionSelection.fatals) { + const delivery = sessionErrorAlertDelivery(err.threadId, err.lastError); + yield* postAlert( + sessionErrorAlertKey(err.threadId, err.lastError), + delivery.content, + SESSION_ERROR_FATAL_COOLDOWN_MS, + delivery.files, + ); + } + // Expected recoveries and sticky multi-day last_error rows are intentionally not + // posted — recoveries are high volume after restarts; stickies re-page forever + // without an age gate (see SESSION_ERROR_MAX_AGE_MS). + if (sessionSelection.ignoredRecoveryCount > 0 || sessionSelection.ignoredStaleCount > 0) { + yield* Effect.logDebug("Skipped non-actionable session last_error rows", { + recoveryCount: sessionSelection.ignoredRecoveryCount, + staleCount: sessionSelection.ignoredStaleCount, + }); + } + + // --- failed systemd units --- + if (snap.failedUnits.length > 0) { + yield* postAlert( + "systemd-failed", + ["**FATAL: systemd failed units**", ...snap.failedUnits.map((u) => `• \`${u}\``)].join( + "\n", + ), + FATAL_COOLDOWN_MS, + ); + } + }).pipe( + Effect.catchCause((cause) => + Effect.logError("Alert watchdog tick failed").pipe( + Effect.andThen(Effect.logError(cause)), + ), + ), + ), + Schedule.spaced(POLL), + ); + }); diff --git a/apps/discord-bot/src/features/BridgeHub.test.ts b/apps/discord-bot/src/features/BridgeHub.test.ts new file mode 100644 index 000000000000..6140113cfee3 --- /dev/null +++ b/apps/discord-bot/src/features/BridgeHub.test.ts @@ -0,0 +1,174 @@ +// @effect-diagnostics globalDateInEffect:off +/* oxlint-disable t3code/no-manual-effect-runtime-in-tests -- Legacy concurrency tests manually drive Effect fibers. */ +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import { describe, expect, it } from "vite-plus/test"; + +import { + makeBridgeHub, + type BridgeControlSlot, + type BridgeEnsureInput, + type BridgeRunner, +} from "./BridgeHub.ts"; + +const baseInput = (id: string, t3 = `t3-${id}`): BridgeEnsureInput => ({ + discordChannelId: id, + t3ThreadId: t3, + mode: "interactive", +}); + +const runnerWithControl = ( + body: (input: BridgeEnsureInput, ready: Deferred.Deferred) => Effect.Effect, +): BridgeRunner => { + return (input, ready, _control: BridgeControlSlot) => body(input, ready); +}; + +describe("BridgeHub", () => { + it("ensure starts a fiber and listActive tracks it until drop", async () => { + const runner: BridgeRunner = runnerWithControl((_input, ready) => + Effect.gen(function* () { + yield* Deferred.succeed(ready, undefined); + yield* Effect.sleep("1 minute"); + }), + ); + + await Effect.runPromise( + Effect.gen(function* () { + const hub = yield* makeBridgeHub(runner); + yield* hub.ensure(baseInput("ch-1")); + expect(yield* hub.activeCount()).toBe(1); + expect(yield* hub.listActive()).toEqual([ + expect.objectContaining({ + discordChannelId: "ch-1", + t3ThreadId: "t3-ch-1", + }), + ]); + + yield* hub.drop("ch-1"); + expect(yield* hub.activeCount()).toBe(0); + }), + ); + }); + + it("rehydrate ensure is a no-op when the same t3 thread is already bridged", async () => { + let starts = 0; + const runner: BridgeRunner = runnerWithControl((_input, ready) => + Effect.gen(function* () { + starts += 1; + yield* Deferred.succeed(ready, undefined); + yield* Effect.sleep("1 minute"); + }), + ); + + await Effect.runPromise( + Effect.gen(function* () { + const hub = yield* makeBridgeHub(runner); + yield* hub.ensure({ ...baseInput("ch-1"), mode: "rehydrate" }); + yield* hub.ensure({ ...baseInput("ch-1"), mode: "rehydrate" }); + expect(starts).toBe(1); + expect(yield* hub.activeCount()).toBe(1); + yield* hub.drop("ch-1"); + }), + ); + }); + + it("interactive ensure reuses an existing fiber for the same t3 thread", async () => { + let starts = 0; + let adopted = 0; + const sentIds: string[] = []; + const runner: BridgeRunner = (input, ready, control) => + Effect.gen(function* () { + starts += 1; + control.noteSentUserMessageIds = (ids) => + Effect.sync(() => { + sentIds.push(...ids); + }); + control.adoptWorkingAckMessageId = () => + Effect.sync(() => { + adopted += 1; + }); + yield* Deferred.succeed(ready, undefined); + yield* Effect.sleep("1 minute"); + }); + + await Effect.runPromise( + Effect.gen(function* () { + const hub = yield* makeBridgeHub(runner); + yield* hub.ensure(baseInput("ch-1")); + yield* hub.ensure({ + ...baseInput("ch-1"), + sentDiscordUserMessageIds: ["user-2"], + workingAckMessageId: "ack-2", + }); + expect(starts).toBe(1); + expect(adopted).toBe(1); + expect(sentIds).toEqual(["user-2"]); + expect(yield* hub.activeCount()).toBe(1); + yield* hub.drop("ch-1"); + }), + ); + }); + + it("replace fiber when t3ThreadId changes", async () => { + const seen: string[] = []; + const runner: BridgeRunner = runnerWithControl((input, ready) => + Effect.gen(function* () { + seen.push(input.t3ThreadId); + yield* Deferred.succeed(ready, undefined); + yield* Effect.sleep("1 minute"); + }), + ); + + await Effect.runPromise( + Effect.gen(function* () { + const hub = yield* makeBridgeHub(runner); + yield* hub.ensure(baseInput("ch-1", "t3-a")); + yield* hub.ensure(baseInput("ch-1", "t3-b")); + expect(seen).toEqual(["t3-a", "t3-b"]); + expect(yield* hub.activeCount()).toBe(1); + expect((yield* hub.listActive())[0]?.t3ThreadId).toBe("t3-b"); + yield* hub.drop("ch-1"); + }), + ); + }); + + it("dropAll clears every live bridge", async () => { + const runner: BridgeRunner = runnerWithControl((_input, ready) => + Effect.gen(function* () { + yield* Deferred.succeed(ready, undefined); + yield* Effect.sleep("1 minute"); + }), + ); + + await Effect.runPromise( + Effect.gen(function* () { + const hub = yield* makeBridgeHub(runner); + yield* hub.ensure(baseInput("a")); + yield* hub.ensure(baseInput("b")); + expect(yield* hub.activeCount()).toBe(2); + yield* hub.dropAll(); + expect(yield* hub.activeCount()).toBe(0); + }), + ); + }); + + it("getLive returns control surface for a matching channel", async () => { + const runner: BridgeRunner = (input, ready, control) => + Effect.gen(function* () { + control.noteSentUserMessageIds = () => Effect.void; + yield* Deferred.succeed(ready, undefined); + yield* Effect.sleep("1 minute"); + }); + + await Effect.runPromise( + Effect.gen(function* () { + const hub = yield* makeBridgeHub(runner); + yield* hub.ensure(baseInput("ch-1", "t3-1")); + const live = yield* hub.getLive("ch-1", "t3-1"); + expect(live?.t3ThreadId).toBe("t3-1"); + expect(yield* hub.getLive("ch-1", "other")).toBeNull(); + yield* hub.drop("ch-1"); + }), + ); + }); +}); diff --git a/apps/discord-bot/src/features/BridgeHub.ts b/apps/discord-bot/src/features/BridgeHub.ts new file mode 100644 index 000000000000..9915f9e32ffe --- /dev/null +++ b/apps/discord-bot/src/features/BridgeHub.ts @@ -0,0 +1,377 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectContext:off missingEffectError:off globalDate:off +import * as Context from "effect/Context"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; + +import { formatAlertCause, postFatalAlert } from "./Alerts.ts"; + +/** Hard cap on concurrent live Discord↔T3 bridges (design decision 4). */ +export const MAX_ACTIVE_BRIDGES = 50; + +export type BridgeEnsureMode = "interactive" | "rehydrate"; + +export type DiscordBridgePresentationMode = "full" | "final-only"; + +export type BridgeEnsureInput = { + readonly discordChannelId: string; + readonly t3ThreadId: string; + /** Pre-posted "_Working.._" message — reused as stream tip and deleted on finalize. */ + readonly workingAckMessageId?: string | null; + /** Discord-originated T3 user message ids that may appear immediately after subscribe. */ + readonly sentDiscordUserMessageIds?: ReadonlyArray; + /** Final-only avoids progress chatter for ambient conversational turns. */ + readonly presentationMode?: DiscordBridgePresentationMode; + /** + * `interactive` — mention path (may seed Working..). + * `rehydrate` — boot/reconnect restore; skips new Working.. unless needed. + */ + readonly mode?: BridgeEnsureMode; + /** + * Activity timestamp for eviction ranking (ISO). Defaults to now on ensure. + * Prefer the durable link's `lastActivityAt` when known. + */ + readonly lastActivityAt?: string; + /** + * When true, this bridge is preferred to keep under cap pressure (running/pending). + * Interactive ensures are always treated as preferred. + */ + readonly preferred?: boolean; +}; + +export type ActiveBridge = { + readonly discordChannelId: string; + readonly t3ThreadId: string; + readonly lastActivityAt: string; + readonly preferred: boolean; + readonly mode: BridgeEnsureMode; +}; + +/** Control surface filled by runBridge so mid-turn follow-ups can reuse the live fiber. */ +export type BridgeControlSlot = { + noteSentUserMessageIds: (ids: ReadonlyArray) => Effect.Effect; + adoptWorkingAckMessageId: (messageId: string) => Effect.Effect; + /** + * Force-refresh Discord thread title indicators (PR/VCS badges). + * Clears title settle cache, re-queries VCS/PR, and renames the Discord thread. + */ + refreshThreadIndicators: () => Effect.Effect; +}; + +export type RefreshThreadIndicatorsResult = + | { readonly ok: true; readonly title: string } + | { readonly ok: false; readonly error: string }; + +type BridgeEntry = { + readonly fiber: Fiber.Fiber; + readonly t3ThreadId: string; + /** Singleflight: concurrent ensure for the same channel waits on this. */ + readonly ready: Deferred.Deferred; + readonly lastActivityAt: string; + readonly preferred: boolean; + readonly mode: BridgeEnsureMode; + readonly control: BridgeControlSlot; +}; + +/** + * Starts a bridge fiber and waits until the first T3 snapshot (or failure/timeout). + * Injected so BridgeHub does not import the full ResponseBridge module graph. + * Requirements (T3Session, DiscordREST, …) come from the ambient ensure call context. + */ +export type BridgeRunner = ( + input: BridgeEnsureInput, + ready: Deferred.Deferred, + controlSlot: BridgeControlSlot, +) => Effect.Effect; + +export interface LiveDiscordBridge { + readonly t3ThreadId: string; + readonly noteSentUserMessageIds: (ids: ReadonlyArray) => Effect.Effect; + readonly adoptWorkingAckMessageId: (messageId: string) => Effect.Effect; + readonly refreshThreadIndicators: () => Effect.Effect; +} + +export interface BridgeHubService { + readonly ensure: (input: BridgeEnsureInput) => Effect.Effect; + readonly drop: (discordChannelId: string) => Effect.Effect; + /** Interrupt every live bridge fiber (T3 reconnect / ops). Durable links stay. */ + readonly dropAll: () => Effect.Effect; + readonly listActive: () => Effect.Effect>; + readonly activeCount: () => Effect.Effect; + /** Update activity timestamp used for eviction ranking. */ + readonly touch: (discordChannelId: string, at?: string) => Effect.Effect; + readonly getLive: ( + discordChannelId: string, + t3ThreadId?: string, + ) => Effect.Effect; +} + +export class BridgeHub extends Context.Service()( + "@t3tools/discord-bot/features/BridgeHub", +) {} + +function nowIso(): string { + return new Date().toISOString(); +} + +/** + * Pick the best eviction victim under cap pressure. + * Prefer non-preferred (idle) bridges with oldest lastActivityAt. + * Falls back to oldest preferred when every active bridge is preferred. + */ +export function pickEvictionVictim( + active: ReadonlyArray, + exceptChannelId: string, +): ActiveBridge | null { + const candidates = active.filter((entry) => entry.discordChannelId !== exceptChannelId); + if (candidates.length === 0) return null; + const idle = candidates.filter((entry) => !entry.preferred); + const pool = idle.length > 0 ? idle : candidates; + return [...pool].sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt))[0] ?? null; +} + +/** + * In-memory registry of live bridge fibers with singleflight ensure / drop / cap eviction. + * + * Same-thread interactive ensure **reuses** the live fiber (preserves mid-turn stream tips). + * Rehydrate ensure is a no-op when the same t3ThreadId is already live. + * Different t3ThreadId always replaces the fiber. + */ +export const makeBridgeHub = (runBridge: BridgeRunner) => + Effect.gen(function* () { + const bridges = yield* Ref.make(new Map()); + + const dropInternal = (discordChannelId: string) => + Effect.gen(function* () { + const entry = yield* Ref.modify(bridges, (map) => { + const current = map.get(discordChannelId); + if (current === undefined) return [undefined, map] as const; + const copy = new Map(map); + copy.delete(discordChannelId); + return [current, copy] as const; + }); + if (entry === undefined) return; + yield* Fiber.interrupt(entry.fiber).pipe(Effect.ignore); + }); + + const listActiveInternal = () => + Ref.get(bridges).pipe( + Effect.map((map) => + [...map.entries()].map(([discordChannelId, entry]): ActiveBridge => ({ + discordChannelId, + t3ThreadId: entry.t3ThreadId, + lastActivityAt: entry.lastActivityAt, + preferred: entry.preferred, + mode: entry.mode, + })), + ), + ); + + const enforceCap = (exceptChannelId: string) => + Effect.gen(function* () { + // Leave room for the bridge we are about to start. + while (true) { + const active = yield* listActiveInternal(); + if (active.length < MAX_ACTIVE_BRIDGES) return; + const victim = pickEvictionVictim(active, exceptChannelId); + if (victim === null) { + yield* Effect.logWarning("BridgeHub at hard capacity with no eviction victim", { + active: active.length, + cap: MAX_ACTIVE_BRIDGES, + exceptChannelId, + }); + return; + } + yield* Effect.logWarning("BridgeHub evicting bridge under capacity pressure", { + victim: victim.discordChannelId, + victimT3: victim.t3ThreadId, + lastActivityAt: victim.lastActivityAt, + preferred: victim.preferred, + active: active.length, + cap: MAX_ACTIVE_BRIDGES, + }); + yield* dropInternal(victim.discordChannelId); + } + }); + + const ensure = (input: BridgeEnsureInput): Effect.Effect => + Effect.gen(function* () { + const mode = input.mode ?? "interactive"; + const preferred = input.preferred ?? mode === "interactive"; + const activityAt = input.lastActivityAt ?? nowIso(); + const existing = yield* Ref.get(bridges).pipe( + Effect.map((map) => map.get(input.discordChannelId)), + ); + + // Same T3 thread already bridging: reuse live fiber (mid-turn steers + rehydrate). + if (existing !== undefined && existing.t3ThreadId === input.t3ThreadId) { + yield* Effect.logInfo("BridgeHub.ensure reusing live fiber", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + mode, + }); + yield* Ref.update(bridges, (map) => { + const current = map.get(input.discordChannelId); + if (current === undefined) return map; + const copy = new Map(map); + copy.set(input.discordChannelId, { + ...current, + lastActivityAt: activityAt, + preferred: preferred || current.preferred, + mode, + }); + return copy; + }); + if ( + input.sentDiscordUserMessageIds !== undefined && + input.sentDiscordUserMessageIds.length > 0 + ) { + yield* existing.control.noteSentUserMessageIds(input.sentDiscordUserMessageIds); + } + if ( + input.workingAckMessageId !== undefined && + input.workingAckMessageId !== null && + input.workingAckMessageId !== "" + ) { + yield* existing.control.adoptWorkingAckMessageId(input.workingAckMessageId); + } + yield* Deferred.await(existing.ready).pipe( + Effect.timeout("15 seconds"), + Effect.catch(() => Effect.void), + ); + return; + } + + if (existing !== undefined) { + yield* Effect.logInfo("BridgeHub.ensure interrupting previous fiber", { + discordChannelId: input.discordChannelId, + previousT3ThreadId: existing.t3ThreadId, + nextT3ThreadId: input.t3ThreadId, + mode, + }); + yield* dropInternal(input.discordChannelId); + } + + yield* enforceCap(input.discordChannelId); + + const ready = yield* Deferred.make(); + const controlSlot: BridgeControlSlot = { + noteSentUserMessageIds: () => Effect.void, + adoptWorkingAckMessageId: () => Effect.void, + refreshThreadIndicators: () => + Effect.succeed({ ok: false as const, error: "Bridge control not ready yet" }), + }; + + const fiber = yield* runBridge(input, ready, controlSlot).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + const pretty = formatAlertCause(cause); + yield* Effect.logError("Discord bridge fiber failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: pretty, + }); + yield* postFatalAlert( + `bridge:${input.discordChannelId}`, + "Discord bridge fiber failed", + `channel=\`${input.discordChannelId}\` thread=\`${input.t3ThreadId}\`\n${pretty}`, + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + yield* Deferred.succeed(ready, undefined).pipe(Effect.ignore); + }).pipe(Effect.asVoid), + ), + Effect.ensuring( + Ref.update(bridges, (map) => { + const current = map.get(input.discordChannelId); + if (current === undefined || current.ready !== ready) return map; + const copy = new Map(map); + copy.delete(input.discordChannelId); + return copy; + }), + ), + // forkDetach: mention handler returns after startTurn; forkChild would kill the + // bridge mid-upload and leave Working.. + partial attachments behind. + Effect.forkDetach, + ); + + yield* Ref.update(bridges, (map) => { + const copy = new Map(map); + copy.set(input.discordChannelId, { + fiber, + t3ThreadId: input.t3ThreadId, + ready, + lastActivityAt: activityAt, + preferred, + mode, + control: controlSlot, + }); + return copy; + }); + + yield* Effect.logInfo("BridgeHub fiber started; waiting for first snapshot", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + mode, + }); + + // Do not return until subscription is live — otherwise startTurn can finish + // before any events are observed (fast providers). + yield* Deferred.await(ready).pipe( + Effect.timeout("15 seconds"), + Effect.catch((error) => + Effect.logError("Timed out / failed waiting for T3 thread subscription snapshot", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + error: String(error), + }), + ), + ); + yield* Effect.logInfo("BridgeHub subscription ready (snapshot received)", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + }); + }) as Effect.Effect; + + return BridgeHub.of({ + ensure, + drop: dropInternal, + dropAll: () => + Effect.gen(function* () { + const active = yield* listActiveInternal(); + for (const entry of active) { + yield* dropInternal(entry.discordChannelId); + } + }), + listActive: listActiveInternal, + activeCount: () => Ref.get(bridges).pipe(Effect.map((map) => map.size)), + touch: (discordChannelId, at) => + Ref.update(bridges, (map) => { + const current = map.get(discordChannelId); + if (current === undefined) return map; + const copy = new Map(map); + copy.set(discordChannelId, { + ...current, + lastActivityAt: at ?? nowIso(), + }); + return copy; + }), + getLive: (discordChannelId, t3ThreadId) => + Ref.get(bridges).pipe( + Effect.map((map) => { + const entry = map.get(discordChannelId); + if (entry === undefined) return null; + if (t3ThreadId !== undefined && entry.t3ThreadId !== t3ThreadId) return null; + return { + t3ThreadId: entry.t3ThreadId, + noteSentUserMessageIds: entry.control.noteSentUserMessageIds, + adoptWorkingAckMessageId: entry.control.adoptWorkingAckMessageId, + refreshThreadIndicators: entry.control.refreshThreadIndicators, + } satisfies LiveDiscordBridge; + }), + ), + }); + }); + +export const layer = (runBridge: BridgeRunner) => Layer.effect(BridgeHub, makeBridgeHub(runBridge)); diff --git a/apps/discord-bot/src/features/ChannelInfoPin.ts b/apps/discord-bot/src/features/ChannelInfoPin.ts new file mode 100644 index 000000000000..08b3098833ac --- /dev/null +++ b/apps/discord-bot/src/features/ChannelInfoPin.ts @@ -0,0 +1,236 @@ +// @effect-diagnostics globalFetch:off globalFetchInEffect:off unknownInEffectCatch:off anyUnknownInErrorContext:off outdatedApi:off +import type { ModelSelection, ServerProvider } from "@t3tools/contracts"; +import { DiscordConfig } from "dfx"; +import * as Effect from "effect/Effect"; +import * as Redacted from "effect/Redacted"; +import * as Result from "effect/Result"; + +import { preferredModelSelection, type DiscordBotConfig } from "../config.ts"; +import { + CHANNEL_INFO_PIN_MARKER, + LEGACY_CHANNEL_INFO_PIN_MARKERS, + renderChannelInfoPin, + resolveGitHubUrlForWorkspace, +} from "../presentation/channelInfoPin.ts"; +import { SUPPRESS_EMBEDS_FLAG } from "../presentation/suppressEmbeds.ts"; + +/** Detect the bot's own channel-info pin, including pre-rebrand (legacy) markers. */ +const isChannelInfoPin = (content: string | undefined): boolean => { + if (content === undefined) return false; + if (content.includes(CHANNEL_INFO_PIN_MARKER)) return true; + return LEGACY_CHANNEL_INFO_PIN_MARKERS.some((marker) => content.includes(marker)); +}; + +interface DiscordMessageSummary { + readonly id: string; + readonly content?: string; +} + +export interface ChannelInfoPinMessageRef { + readonly channelId: string; + readonly messageId: string; +} + +async function discordApiJson(input: { + readonly baseUrl: string; + readonly botToken: string; + readonly path: string; + readonly method?: string; + readonly body?: unknown; +}): Promise { + const response = await globalThis.fetch(`${input.baseUrl.replace(/\/+$/u, "")}${input.path}`, { + method: input.method ?? "GET", + headers: { + Authorization: `Bot ${input.botToken}`, + "Content-Type": "application/json", + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + ...(input.body === undefined ? {} : { body: JSON.stringify(input.body) }), + }); + if (!response.ok) { + const body = await response.text().catch(() => ""); + throw new Error( + `Discord API ${input.method ?? "GET"} ${input.path} failed (${response.status}): ${body}`, + ); + } + if (response.status === 204) { + return undefined as T; + } + return (await response.json()) as T; +} + +async function discordApiVoid(input: { + readonly baseUrl: string; + readonly botToken: string; + readonly path: string; + readonly method: string; +}): Promise { + const response = await globalThis.fetch(`${input.baseUrl.replace(/\/+$/u, "")}${input.path}`, { + method: input.method, + headers: { + Authorization: `Bot ${input.botToken}`, + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + }); + if (!response.ok && response.status !== 204) { + const body = await response.text().catch(() => ""); + throw new Error( + `Discord API ${input.method} ${input.path} failed (${response.status}): ${body}`, + ); + } +} + +export const ensureChannelInfoPin = (input: { + readonly channelId: string; + readonly workspaceRoot: string; + readonly providers: ReadonlyArray; + readonly projectDefaultModelSelection?: ModelSelection | null; + readonly botConfig: DiscordBotConfig; +}) => + Effect.gen(function* () { + const discordConfig = yield* DiscordConfig.DiscordConfig; + const botToken = Redacted.value(discordConfig.token); + const baseUrl = discordConfig.rest.baseUrl; + const githubUrl = yield* Effect.tryPromise({ + try: () => resolveGitHubUrlForWorkspace(input.workspaceRoot), + catch: (cause) => cause, + }).pipe(Effect.orElseSucceed(() => null)); + const supportedProviders = input.providers + .filter((provider) => provider.models.length > 0) + .toSorted((left, right) => String(left.instanceId).localeCompare(String(right.instanceId))); + const availableProviders = input.providers.filter( + (provider) => + provider.enabled && + provider.installed && + provider.availability !== "unavailable" && + provider.models.length > 0, + ); + const defaultModelSelection = + availableProviders.length === 0 + ? null + : preferredModelSelection({ + config: input.botConfig, + providers: availableProviders, + projectDefault: input.projectDefaultModelSelection ?? null, + }); + const desiredContent = renderChannelInfoPin({ + githubUrl, + workspaceRoot: input.workspaceRoot, + providers: supportedProviders, + defaultModelSelection, + }); + + const pinned = yield* Effect.tryPromise({ + try: () => + discordApiJson>({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins`, + }), + catch: (cause) => cause, + }); + + const infoPins = pinned.filter((message) => isChannelInfoPin(message.content)); + const existing = infoPins[0] ?? null; + const stale = infoPins.slice(1); + let pinMessageId = existing?.id ?? null; + + if (existing !== null) { + if ((existing.content ?? "") !== desiredContent) { + const updated = yield* Effect.tryPromise({ + try: () => + discordApiJson({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/messages/${existing.id}`, + method: "PATCH", + body: { content: desiredContent, flags: SUPPRESS_EMBEDS_FLAG }, + }), + catch: (cause) => cause, + }).pipe(Effect.result); + if (Result.isFailure(updated)) { + // Content was historically over 2000 chars; replace the pin instead of failing help. + yield* Effect.logWarning("Channel info pin PATCH failed; recreating pin message", { + channelId: input.channelId, + existingMessageId: existing.id, + contentLength: desiredContent.length, + error: String(updated.failure), + }); + const created = yield* Effect.tryPromise({ + try: () => + discordApiJson<{ readonly id: string }>({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/messages`, + method: "POST", + body: { content: desiredContent, flags: SUPPRESS_EMBEDS_FLAG }, + }), + catch: (cause) => cause, + }); + pinMessageId = created.id; + yield* Effect.tryPromise({ + try: () => + discordApiVoid({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins/${created.id}`, + method: "PUT", + }), + catch: (cause) => cause, + }); + yield* Effect.tryPromise({ + try: () => + discordApiVoid({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins/${existing.id}`, + method: "DELETE", + }), + catch: (cause) => cause, + }).pipe(Effect.catch(() => Effect.void)); + } + } + } else { + const created = yield* Effect.tryPromise({ + try: () => + discordApiJson<{ readonly id: string }>({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/messages`, + method: "POST", + body: { content: desiredContent, flags: SUPPRESS_EMBEDS_FLAG }, + }), + catch: (cause) => cause, + }); + pinMessageId = created.id; + yield* Effect.tryPromise({ + try: () => + discordApiVoid({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins/${created.id}`, + method: "PUT", + }), + catch: (cause) => cause, + }); + } + + for (const message of stale) { + if (message.id === pinMessageId) continue; + yield* Effect.tryPromise({ + try: () => + discordApiVoid({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins/${message.id}`, + method: "DELETE", + }), + catch: (cause) => cause, + }).pipe(Effect.catch(() => Effect.void)); + } + + return { + channelId: input.channelId, + messageId: pinMessageId ?? "", + } satisfies ChannelInfoPinMessageRef; + }); diff --git a/apps/discord-bot/src/features/DiscordDelivery.test.ts b/apps/discord-bot/src/features/DiscordDelivery.test.ts new file mode 100644 index 000000000000..cf64a281ba79 --- /dev/null +++ b/apps/discord-bot/src/features/DiscordDelivery.test.ts @@ -0,0 +1,750 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + assistantMessagesForDelivery, + beginDeliveryEpoch, + decideAssistantDelivery, + decideHeartbeat, + deliveryTextFromAssistants, + excludeFinalizedAssistants, + initialDeliveryEpochState, + isGrownFinalizedText, + retainUnfinalizedStreamText, + shouldRecreateTip, + unfinalizedPriorAssistantForCatchUp, + type DeliveryEpochState, +} from "./DiscordDelivery.ts"; + +const msg = ( + id: string, + role: "user" | "assistant", + text: string, + turnId: string | null = null, +) => ({ id, role, text, turnId }); + +/** + * Drive idle delivery to finalize. + * Short status lines use settle grace (stream then finalize); substantial answers + * finalize on the first idle snapshot (avoids Working.. under full finals). + */ +const settleFinalize = ( + state: DeliveryEpochState, + input: { + readonly turnId: string | null; + readonly assistants: ReadonlyArray<{ readonly id: string; readonly text: string }>; + readonly messages?: ReadonlyArray<{ + readonly id: string; + readonly role: string; + readonly turnId: string | null; + readonly text: string; + }>; + }, +) => { + const first = decideAssistantDelivery({ + state, + turnId: input.turnId, + turnInProgress: false, + assistants: input.assistants, + ...(input.messages !== undefined ? { messages: input.messages } : {}), + streaming: false, + presentationFull: true, + }); + if (first.intent._tag === "finalize") { + return first; + } + expect(first.intent._tag).toBe("stream"); + expect(first.state.settleReady).toBe(true); + return decideAssistantDelivery({ + state: first.state, + turnId: input.turnId, + turnInProgress: false, + assistants: input.assistants, + ...(input.messages !== undefined ? { messages: input.messages } : {}), + streaming: false, + presentationFull: true, + }); +}; + +describe("assistantMessagesForDelivery", () => { + it("reproduces 2nd-message-after-restart: stale completed latestTurn + new user → empty", () => { + // Turn 1 completed; user 2 arrives; orchestration still reports latestTurn = turn-1. + const messages = [ + msg("u1", "user", "verify bot up to date", "t1"), + msg("a1", "assistant", "Yes — the running bot is up to date.\n\n| Check | Result |", "t1"), + msg("u2", "user", "perfect. Seems better now", null), + ]; + const assistants = assistantMessagesForDelivery({ + messages, + turnId: "t1", + turnInProgress: false, + hasLatestTurn: true, + }); + expect(assistants).toEqual([]); + expect(deliveryTextFromAssistants(assistants, "answer")).toBe(""); + }); + + it("keeps mid-turn pre-steer assistants while the turn is still running", () => { + const messages = [ + msg("u1", "user", "start", "t1"), + msg("a-pre", "assistant", "long findings…", "t1"), + msg("u-steer", "user", "also check X", null), + ]; + const assistants = assistantMessagesForDelivery({ + messages, + turnId: "t1", + turnInProgress: true, + hasLatestTurn: true, + }); + expect(assistants.map((a) => a.id)).toEqual(["a-pre"]); + }); + + it("returns empty when turn id advanced but no assistants yet", () => { + const messages = [ + msg("u1", "user", "first", "t1"), + msg("a1", "assistant", "first answer", "t1"), + msg("u2", "user", "second", "t2"), + ]; + expect( + assistantMessagesForDelivery({ + messages, + turnId: "t2", + turnInProgress: true, + hasLatestTurn: true, + }), + ).toEqual([]); + }); + + it("time-query race: new turnId in progress, new user not in snapshot yet → empty when prior was finalized", () => { + // Production: startTurn advanced latestTurn before the new user message appeared. + // afterLastUser would otherwise return a1 (PR #102 body) and re-stream it. + const messages = [ + msg("u1", "user", "show me what you got", "t1"), + msg("a1", "assistant", "PR #102 is already merged…", "t1"), + ]; + expect( + assistantMessagesForDelivery({ + messages, + turnId: "t2", + turnInProgress: true, + hasLatestTurn: true, + lastFinalizedAssistantId: "a1", + }), + ).toEqual([]); + }); + + it("comment-recover race: new turn in progress, no lastFinalized yet → still empty (no prior final under Working)", () => { + // Production: bridge recovered after a comment; startTurn opened t2 before durable + // lastFinalizedAssistantId was available. Falling back to afterLastUser re-streamed + // the previous final as `_Working.._` + Stop under the full prior answer. + const messages = [ + msg("u1", "user", "rebase and adversarial PR review", "t1"), + msg( + "a1", + "assistant", + "PR #1901 is rebased, green locally, and mergeable…\n\n## Done\n1. Rebased…", + "t1", + ), + ]; + expect( + assistantMessagesForDelivery({ + messages, + turnId: "t2", + turnInProgress: true, + hasLatestTurn: true, + // Intentionally omit lastFinalizedAssistantId — must not leak a1. + }), + ).toEqual([]); + }); + + it("drops multi-bubble prior turn when only the last id was finalized", () => { + const messages = [ + msg("u1", "user", "first", "t1"), + msg("a0", "assistant", "findings…", "t1"), + msg("a1", "assistant", "PR #102 is already merged…", "t1"), + msg("u2", "user", "what's the time", "t2"), + msg("a2", "assistant", "08:51 UTC", "t2"), + ]; + const assistants = assistantMessagesForDelivery({ + messages, + turnId: "t2", + turnInProgress: false, + hasLatestTurn: true, + lastFinalizedAssistantId: "a1", + }); + expect(assistants.map((a) => a.id)).toEqual(["a2"]); + expect(deliveryTextFromAssistants(assistants, "answer")).toBe("08:51 UTC"); + }); + + it("stale lastFinalized outside tip does not block newer after-last-user answer (dead Working tip)", () => { + // Production a3b2b737…: durable lastFinalized pointed at an older bubble that had + // rolled out of the retained tip. Drop-all on missing cursor zeroed deliveryAssistants + // so Discord stayed on `_Working.._` after the agent finished ("Yep — here"). + const messages = [ + msg("u1", "user", "yes proceed, use english copy", "t1"), + msg("a1", "assistant", "Sorry for the lag — finished and pushed. PR #872…", "t1"), + msg("u2", "user", "u there?", "t2"), + msg("a2", "assistant", "Yep — here. What do you need?", "t2"), + ]; + const assistants = assistantMessagesForDelivery({ + messages, + turnId: "t2", + turnInProgress: false, + hasLatestTurn: true, + lastFinalizedAssistantId: "assistant:ancient-not-in-retained-tip:segment:3", + }); + expect(assistants.map((a) => a.id)).toEqual(["a2"]); + expect(deliveryTextFromAssistants(assistants, "answer")).toBe("Yep — here. What do you need?"); + }); + + it("stale lastFinalized outside tip still allows in-progress stream of current turn", () => { + const messages = [ + msg("u1", "user", "implement backoffice.access", "t1"), + msg("a1", "assistant", "Implementing clean migration logic…", "t1"), + ]; + const assistants = assistantMessagesForDelivery({ + messages, + turnId: "t1", + turnInProgress: true, + hasLatestTurn: true, + lastFinalizedAssistantId: "assistant:ancient-not-in-retained-tip:segment:3", + }); + expect(assistants.map((a) => a.id)).toEqual(["a1"]); + }); +}); + +describe("unfinalizedPriorAssistantForCatchUp", () => { + it("recovers the prior turn answer when queue drain advanced latestTurn", () => { + // Empasa: parked follow-up started turn 2 before Discord finalized turn 1. + const messages = [ + msg("u1", "user", "why did the shard manager not recover", "t1"), + msg( + "a1", + "assistant", + "Shard-lock recovery is still a bug in this Effect version; later ones auto-recover.", + "t1", + ), + msg("u2", "user", "so everything has recovered now, labels are printing?", "t2"), + ]; + const prior = unfinalizedPriorAssistantForCatchUp({ + messages, + currentTurnId: "t2", + lastFinalizedAssistantId: null, + }); + expect(prior?.id).toBe("a1"); + expect(prior?.turnId).toBe("t1"); + expect( + assistantMessagesForDelivery({ + messages, + turnId: "t2", + turnInProgress: true, + hasLatestTurn: true, + }), + ).toEqual([]); + }); + + it("does not replay a prior answer Discord already finalized", () => { + const messages = [ + msg("u1", "user", "first", "t1"), + msg("a1", "assistant", "first answer already posted to Discord", "t1"), + msg("u2", "user", "second", "t2"), + ]; + expect( + unfinalizedPriorAssistantForCatchUp({ + messages, + currentTurnId: "t2", + lastFinalizedAssistantId: "a1", + lastFinalizedText: "first answer already posted to Discord", + }), + ).toBeNull(); + }); + + it("ignores the in-progress turn's own assistants", () => { + const messages = [ + msg("u1", "user", "first", "t1"), + msg("a1", "assistant", "I'll trace the shard-lock unhealthy path.", "t1"), + ]; + expect( + unfinalizedPriorAssistantForCatchUp({ + messages, + currentTurnId: "t1", + lastFinalizedAssistantId: null, + }), + ).toBeNull(); + }); + + it("still recovers the prior T3 answer when the queued turn already has assistants", () => { + const messages = [ + msg("u1", "user", "what's happened here?", "t1"), + msg( + "a1", + "assistant", + "Those five stay on PickListe because print-ack never flips Gedruckt. Orders 21307727–709 are the warehouse copies.", + "t1", + ), + msg("u2", "user", "do adversarial reviews of PR 2278", "t2"), + msg("a2", "assistant", "I'll run adversarial reviews of PR 2278.", "t2"), + ]; + const prior = unfinalizedPriorAssistantForCatchUp({ + messages, + currentTurnId: "t2", + lastFinalizedAssistantId: null, + }); + expect(prior?.id).toBe("a1"); + expect(prior?.text).toContain("Gedruckt"); + }); + + it("reposts a grown prior answer after a premature short-status finalize", () => { + const status = + "Those five are still on PickListe with Gedruckt at 0. I'll check how that tab is derived."; + const full = [ + status, + "", + "Print-ack never flips Gedruckt, so the tab keeps showing 0. Warehouse copies for 21307727, 21307693, 21307681, 21307732, and 21307709 already printed. Honeycomb shows the label jobs completed; the UI query still reads the unacked pick rows.", + ].join("\n"); + const messages = [ + msg("u1", "user", "what's happened here?", "t1"), + msg("a1", "assistant", full, "t1"), + msg("u2", "user", "do adversarial reviews of PR 2278", "t2"), + ]; + const prior = unfinalizedPriorAssistantForCatchUp({ + messages, + currentTurnId: "t2", + lastFinalizedAssistantId: "a1", + lastFinalizedText: status, + }); + expect(prior?.id).toBe("a1"); + expect(prior?.text).toContain("Honeycomb shows the label jobs completed"); + }); +}); + +describe("retainUnfinalizedStreamText", () => { + it("keeps the prior stream body when a new epoch enters awaiting", () => { + expect( + retainUnfinalizedStreamText({ + phase: "awaiting", + streamText: "", + priorLastAssistantText: + "Shard-lock recovery is still a bug in this Effect version; later ones auto-recover.", + }), + ).toBe("Shard-lock recovery is still a bug in this Effect version; later ones auto-recover."); + }); + + it("does not keep a Working placeholder", () => { + expect( + retainUnfinalizedStreamText({ + phase: "awaiting", + streamText: "", + priorLastAssistantText: "_Working.._", + }), + ).toBe(""); + }); + + it("uses live stream text while streaming", () => { + expect( + retainUnfinalizedStreamText({ + phase: "streaming", + streamText: "Yes. Printing is live.", + priorLastAssistantText: "I'll trace the shard-lock unhealthy path.", + }), + ).toBe("Yes. Printing is live."); + }); +}); + +describe("excludeFinalizedAssistants", () => { + it("keeps only assistants after the finalized bubble in message order", () => { + const messages = [ + msg("u1", "user", "x"), + msg("a1", "assistant", "old"), + msg("a2", "assistant", "new"), + ]; + expect( + excludeFinalizedAssistants({ + messages, + assistants: [ + { id: "a1", text: "old" }, + { id: "a2", text: "new" }, + ], + lastFinalizedAssistantId: "a1", + }).map((a) => a.id), + ).toEqual(["a2"]); + }); + + it("keeps retained-window assistants when lastFinalized is outside the window", () => { + // Missing cursor cannot be ordered vs the tip (stale-behind vs ahead). Dropping the + // whole tip deadlocked live Discord threads on Working. Keep non-matching ids; + // reconnect re-seed is owned by DiscordThreadFollower resume-after. + const messages = [ + msg("u-old", "user", "implement sibling threads"), + msg("a-old", "assistant", "Done. PR #156 …"), + ]; + expect( + excludeFinalizedAssistants({ + messages, + assistants: [{ id: "a-old", text: "Done. PR #156 …" }], + lastFinalizedAssistantId: "a-later-not-in-window", + }).map((a) => a.id), + ).toEqual(["a-old"]); + }); + + it("still gates exact lastFinalized id when that id is the only candidate", () => { + // Cursor missing from messages list, but candidate id equals lastFinalized → drop + // unless text grew (growth reopen is covered elsewhere). + expect( + excludeFinalizedAssistants({ + messages: [msg("u1", "user", "x")], + assistants: [{ id: "a1", text: "already posted" }], + lastFinalizedAssistantId: "a1", + lastFinalizedText: "already posted", + }), + ).toEqual([]); + }); + + it("keeps same id when text grew past lastFinalizedText", () => { + expect( + isGrownFinalizedText("Checking PR and CI status now.", "Checking PR and CI status now."), + ).toBe(false); + expect( + isGrownFinalizedText( + "Checking PR and CI status now.\n\nDone and waiting on CI with full details about the PR.", + "Checking PR and CI status now.", + ), + ).toBe(true); + }); +}); + +describe("decideAssistantDelivery epoch FSM", () => { + it("after finalize, further stream/finalize of the same assistant is noop (no final+Working mess)", () => { + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const assistants = [{ id: "a1", text: "Good to hear.\n\nThe main issues…" }]; + + const fin = settleFinalize(state, { turnId: "t1", assistants }); + expect(fin.intent._tag).toBe("finalize"); + state = fin.state; + expect(state.phase).toBe("finalized"); + + // Same bubble only — must not reopen Working with the body. + const lateStream = decideAssistantDelivery({ + state, + turnId: "t1", + turnInProgress: true, + assistants, + streaming: true, + presentationFull: true, + }); + expect(lateStream.intent).toEqual({ _tag: "noop", reason: "epoch-finalized" }); + + const lateFinal = decideAssistantDelivery({ + state, + turnId: "t1", + turnInProgress: false, + assistants, + streaming: false, + presentationFull: true, + }); + expect(lateFinal.intent).toEqual({ _tag: "noop", reason: "epoch-finalized" }); + }); + + it("settle grace: first idle snapshot streams, second finalizes", () => { + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const assistants = [{ id: "a1", text: "Checking PR and CI status now." }]; + const first = decideAssistantDelivery({ + state, + turnId: "t1", + turnInProgress: false, + assistants, + streaming: false, + presentationFull: true, + }); + expect(first.intent._tag).toBe("stream"); + expect(first.state.settleReady).toBe(true); + expect(first.state.phase).toBe("streaming"); + + const second = decideAssistantDelivery({ + state: first.state, + turnId: "t1", + turnInProgress: false, + assistants, + streaming: false, + presentationFull: true, + }); + expect(second.intent._tag).toBe("finalize"); + }); + + it("skipSettleGrace finalizes on the first idle snapshot (rehydrate catch-up)", () => { + // Regression: idle-link rehydrate of a completed turn streamed the full answer as + // Working.. · N tool calls and waited for a second snapshot that never arrived. + const state = beginDeliveryEpoch(initialDeliveryEpochState()); + const assistants = [ + { + id: "a1", + text: "PR #1971 ready for review\n\nThis PR extracted pure plans…", + }, + ]; + const decision = decideAssistantDelivery({ + state, + turnId: "t1", + turnInProgress: false, + assistants, + streaming: false, + presentationFull: true, + skipSettleGrace: true, + }); + expect(decision.intent._tag).toBe("finalize"); + if (decision.intent._tag === "finalize") { + expect(decision.intent.text).toContain("PR #1971"); + } + expect(decision.state.phase).toBe("finalized"); + }); + + it("substantial settled answers finalize on first idle snapshot (no Working under full final)", () => { + // Recovery after a comment: previous turn body is huge and settled. Streaming it + // with Working.. + Stop under the answer is not allowed. + const state = beginDeliveryEpoch(initialDeliveryEpochState()); + const assistants = [ + { + id: "a1", + text: [ + "PR #1901 is rebased, green locally, and mergeable (no conflicts).", + "", + "## Done", + "1. Rebased onto latest origin/main (20 commits).", + "2. Conflict resolution in e2e specs (PR-side Engagement fixtures).", + "3. Rebase breakage fixed across PausePicking and API e2e paths.", + "4. pnpm validate:changed green (1,246 tests).", + "5. Pushed (45d366a70).", + ].join("\n"), + }, + ]; + const decision = decideAssistantDelivery({ + state, + turnId: "t1", + turnInProgress: false, + assistants, + streaming: false, + presentationFull: true, + }); + expect(decision.intent._tag).toBe("finalize"); + if (decision.intent._tag === "finalize") { + expect(decision.intent.text).toContain("PR #1901"); + expect(decision.intent.text).not.toMatch(/Working/i); + } + expect(decision.state.phase).toBe("finalized"); + }); + + it("reopens after premature finalize when a later assistant bubble is the real answer", () => { + // Production: finalized "Checking PR and CI status now." (30 chars), then + // "Done and waiting on CI…" never posted because epoch-finalized blocked it. + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const messages = [ + msg("u1", "user", "where do we stand?", "t1"), + msg("a1", "assistant", "Checking PR and CI status now.", "t1"), + ]; + const status = settleFinalize(state, { + turnId: "t1", + assistants: [{ id: "a1", text: "Checking PR and CI status now." }], + messages, + }); + expect(status.intent._tag).toBe("finalize"); + state = status.state; + expect(state.lastFinalizedAssistantId).toBe("a1"); + + const withAnswer = [ + ...messages, + msg("a2", "assistant", "Done and waiting on CI.\n\n- Fix shipped in code\n- PR open", "t1"), + ]; + const reopened = settleFinalize(state, { + turnId: "t1", + assistants: [ + { id: "a1", text: "Checking PR and CI status now." }, + { + id: "a2", + text: "Done and waiting on CI.\n\n- Fix shipped in code\n- PR open", + }, + ], + messages: withAnswer, + }); + expect(reopened.intent._tag).toBe("finalize"); + if (reopened.intent._tag === "finalize") { + expect(reopened.intent.assistantId).toBe("a2"); + expect(reopened.intent.text).toContain("Done and waiting on CI"); + expect(reopened.intent.text).not.toContain("Checking PR"); + } + expect(reopened.state.lastFinalizedAssistantId).toBe("a2"); + }); + + it("heartbeat is noop after finalize (prevents Working tip under final post)", () => { + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const fin = settleFinalize(state, { + turnId: "t1", + assistants: [{ id: "a1", text: "Good to hear." }], + }); + state = fin.state; + + expect( + decideHeartbeat({ + state, + turnInProgress: false, + hasOpenTip: false, + }), + ).toEqual({ _tag: "noop", reason: "heartbeat-inactive-phase" }); + + // Even if tip ids were lost and turn still looks running, do not recreate. + expect( + shouldRecreateTip({ + state, + updateFailed: true, + turnInProgress: true, + }), + ).toBe(false); + }); + + it("new epoch after Working ack allows a fresh stream (not prior final text)", () => { + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const first = settleFinalize(state, { + turnId: "t1", + assistants: [{ id: "a1", text: "Yes — the running bot is up to date." }], + }); + state = first.state; + expect(state.lastFinalizedAssistantId).toBe("a1"); + + // 2nd user message → new Working ack → new epoch. + state = beginDeliveryEpoch(state, { turnId: "t2" }); + expect(state.phase).toBe("awaiting"); + expect(state.streamText).toBe(""); + expect(state.epoch).toBe(2); + + // Stale snapshot still showing a1 while awaiting t2 (hold Working, never re-post). + const hold = decideAssistantDelivery({ + state, + turnId: "t1", // stale + turnInProgress: false, + assistants: [{ id: "a1", text: "Yes — the running bot is up to date." }], + streaming: false, + presentationFull: true, + }); + expect(hold.intent._tag).toBe("hold"); + expect(hold.intent).toMatchObject({ reason: "assistant-already-finalized" }); + + // Real new-turn content. + const stream = decideAssistantDelivery({ + state, + turnId: "t2", + turnInProgress: true, + assistants: [{ id: "a2", text: "Glad it is better." }], + streaming: true, + presentationFull: true, + }); + expect(stream.intent._tag).toBe("stream"); + if (stream.intent._tag === "stream") { + expect(stream.intent.text).toBe("Glad it is better."); + expect(stream.intent.assistantId).toBe("a2"); + } + }); + + it("time-query race: turnInProgress must not re-stream already-finalized prior answer", () => { + // Logs 2026-07-21: hold → stream a1 (PR#102) while turnInProgress for new turn → + // finalize PR#102; real time answer never posted (epoch already finalized). + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const prior = settleFinalize(state, { + turnId: "t1", + assistants: [{ id: "a1", text: "PR #102 is already merged…" }], + }); + state = beginDeliveryEpoch(prior.state, { turnId: "t2" }); + + const messages = [ + msg("u1", "user", "show me what you got", "t1"), + msg("a1", "assistant", "PR #102 is already merged…", "t1"), + ]; + + // Snapshot before new user lands; only prior assistant available. + const blocked = decideAssistantDelivery({ + state, + turnId: "t2", + turnInProgress: true, + assistants: [{ id: "a1", text: "PR #102 is already merged…" }], + messages, + streaming: true, + presentationFull: true, + }); + expect(blocked.intent._tag).toBe("hold"); + expect(blocked.intent).toMatchObject({ reason: "assistant-already-finalized" }); + expect(blocked.state.phase).not.toBe("finalized"); + + // Real time answer after new user + new assistant. + const withTime = [ + ...messages, + msg("u2", "user", "what's the time", "t2"), + msg("a2", "assistant", "08:51 UTC", "t2"), + ]; + const stream = decideAssistantDelivery({ + state, + turnId: "t2", + turnInProgress: true, + assistants: [{ id: "a2", text: "08:51 UTC" }], + messages: withTime, + streaming: true, + presentationFull: true, + }); + expect(stream.intent._tag).toBe("stream"); + if (stream.intent._tag === "stream") { + expect(stream.intent.text).toBe("08:51 UTC"); + expect(stream.intent.assistantId).toBe("a2"); + } + + const fin = settleFinalize(stream.state, { + turnId: "t2", + assistants: [{ id: "a2", text: "08:51 UTC" }], + messages: withTime, + }); + expect(fin.intent._tag).toBe("finalize"); + if (fin.intent._tag === "finalize") { + expect(fin.intent.text).toBe("08:51 UTC"); + } + }); + + it("awaiting with no assistants holds (Working dots only)", () => { + const state = beginDeliveryEpoch(initialDeliveryEpochState()); + const decision = decideAssistantDelivery({ + state, + turnId: "t2", + turnInProgress: true, + assistants: [], + streaming: true, + presentationFull: true, + }); + expect(decision.intent._tag).toBe("hold"); + + const hb = decideHeartbeat({ + state: decision.state, + turnInProgress: true, + hasOpenTip: true, + }); + expect(hb._tag).toBe("heartbeat"); + if (hb._tag === "heartbeat") { + expect(hb.tipBody).toBe(""); + } + }); + + it("streaming epoch heartbeat may show stream text, never after finalize", () => { + let state = beginDeliveryEpoch(initialDeliveryEpochState()); + const streamed = decideAssistantDelivery({ + state, + turnId: "t1", + turnInProgress: true, + assistants: [{ id: "a1", text: "partial…" }], + streaming: true, + presentationFull: true, + }); + state = streamed.state; + const hb = decideHeartbeat({ + state, + turnInProgress: true, + hasOpenTip: true, + }); + expect(hb).toEqual({ + _tag: "heartbeat", + tipBody: "partial…", + epoch: 1, + }); + }); +}); diff --git a/apps/discord-bot/src/features/DiscordDelivery.ts b/apps/discord-bot/src/features/DiscordDelivery.ts new file mode 100644 index 000000000000..7a63fca46814 --- /dev/null +++ b/apps/discord-bot/src/features/DiscordDelivery.ts @@ -0,0 +1,626 @@ +/** + * Structural Discord assistant delivery state machine. + * + * Band-aid flags (seededWorkingAckPending, finalizedTurnId, lastAssistantText) grew into + * conflicting rules. This module is the single source of truth for *whether* Discord may + * stream, finalize, or heartbeat — keyed by a monotonic **epoch** that advances on each + * new user Working ack (and only then). + * + * Phases per epoch: + * awaiting → Working tip exists, no assistant body for this epoch yet + * streaming → tip may show current-turn progress + * finalized → final message posted; **no** further stream/heartbeat until epoch bumps + * (unless a later assistant / grown text reopens — see settle grace) + * + * Effect integration stays in ResponseBridge; this file is pure and fully unit-tested. + */ + +export type DeliveryPhase = "idle" | "awaiting" | "streaming" | "finalized"; + +export type DeliveryEpochState = { + /** Monotonic; advances only on a new user Working ack. */ + readonly epoch: number; + readonly phase: DeliveryPhase; + /** Turn id bound to this epoch once known. */ + readonly turnId: string | null; + /** Assistant id currently (or last) streamed in this epoch. */ + readonly assistantId: string | null; + /** Last text applied to the stream tip this epoch (never used after finalized). */ + readonly streamText: string; + /** + * Assistant id whose final answer was posted for this epoch (or the previous one + * until a new epoch begins). Survives epoch bump as `lastFinalizedAssistantId`. + */ + readonly finalizedAssistantId: string | null; + /** Durable-style memory of the last assistant we successfully finalized (any epoch). */ + readonly lastFinalizedAssistantId: string | null; + /** + * Text of the last successful Discord final (any epoch). Used to reopen when the + * **same** assistant id grows after a premature finalize (status line → full answer). + */ + readonly lastFinalizedText: string | null; + /** + * Settle grace: multi-step agents often flip turn idle for one snapshot between a + * short status bubble and the real answer. Require one settled confirmation before + * finalize so we do not lock the epoch on "Checking PR…" style status lines. + */ + readonly settleReady: boolean; +}; + +export type DeliveryIntent = + | { readonly _tag: "noop"; readonly reason: string } + | { readonly _tag: "hold"; readonly reason: string } + | { + readonly _tag: "stream"; + readonly text: string; + readonly turnId: string | null; + readonly assistantId: string; + readonly epoch: number; + } + | { + readonly _tag: "finalize"; + readonly text: string; + readonly turnId: string | null; + readonly assistantId: string; + readonly epoch: number; + } + | { + readonly _tag: "heartbeat"; + /** Empty string → Working dots only. Never a prior final answer after finalize. */ + readonly tipBody: string; + readonly epoch: number; + }; + +export const initialDeliveryEpochState = ( + seed?: Partial, +): DeliveryEpochState => ({ + epoch: seed?.epoch ?? 0, + phase: seed?.phase ?? "idle", + turnId: seed?.turnId ?? null, + assistantId: seed?.assistantId ?? null, + streamText: seed?.streamText ?? "", + finalizedAssistantId: seed?.finalizedAssistantId ?? null, + lastFinalizedAssistantId: seed?.lastFinalizedAssistantId ?? null, + lastFinalizedText: seed?.lastFinalizedText ?? null, + settleReady: seed?.settleReady ?? false, +}); + +/** + * New user turn (Discord Working ack). Bumps epoch and enters awaiting. + * Clears stream body so heartbeat cannot repaint the previous final answer. + */ +export function beginDeliveryEpoch( + state: DeliveryEpochState, + input?: { readonly turnId?: string | null }, +): DeliveryEpochState { + return { + epoch: state.epoch + 1, + phase: "awaiting", + turnId: input?.turnId ?? null, + assistantId: null, + streamText: "", + finalizedAssistantId: null, + lastFinalizedAssistantId: state.lastFinalizedAssistantId, + lastFinalizedText: state.lastFinalizedText, + settleReady: false, + }; +} + +/** + * Drop assistants at or before the last Discord-finalized bubble. + * + * Race this prevents: new epoch + turnInProgress, but the snapshot still only has + * prior-turn assistants (new user not in messages yet, or forTurn empty → afterLastUser + * falls back to them). Without this filter we re-stream/re-finalize the previous answer + * (e.g. "what's the time" re-posting PR #102). + * + * Multi-bubble prior turns: we only persist the last finalized id, so filtering by + * message order (not just exact id match) drops the whole prior answer set. + * + * Same-id growth: if the finalized bubble's text grew past lastFinalizedText, keep it + * so a premature status finalize can be replaced by the real answer on the same id. + * + * Cursor outside retained window: when `lastFinalizedAssistantId` is set but not present + * in the message list, we **cannot** order the watermark vs the retained tip. + * Treating the whole tip as already delivered (drop-all) deadlocks live threads whose + * durable cursor points at an older bubble that rolled out of the tip — Discord stays + * on `_Working.._` forever (`deliveryAssistants: 0`, `awaiting-first-assistant`). + * + * Missing cursor therefore only gates the exact finalized id (growth reopen); all other + * assistant ids are kept. Reconnect re-post of old finals is handled by the thread + * follower (`resume-after` skips warm re-seed) and by turnId / after-last-user selection + * in `assistantMessagesForDelivery`. + */ +export function excludeFinalizedAssistants< + T extends { readonly id: string; readonly text?: string }, +>(input: { + readonly messages: ReadonlyArray<{ readonly id: string }>; + readonly assistants: ReadonlyArray; + readonly lastFinalizedAssistantId: string | null; + readonly lastFinalizedText?: string | null; +}): ReadonlyArray { + const { messages, assistants, lastFinalizedAssistantId } = input; + const lastFinalizedText = input.lastFinalizedText ?? null; + if (lastFinalizedAssistantId === null || assistants.length === 0) return assistants; + + const finalizedIdx = messages.findIndex((message) => message.id === lastFinalizedAssistantId); + if (finalizedIdx < 0) { + // Cursor not in this tip/candidate list — keep new ids; only gate exact match. + return assistants.filter((assistant) => { + if (assistant.id !== lastFinalizedAssistantId) return true; + return isGrownFinalizedText(assistant.text ?? "", lastFinalizedText); + }); + } + return assistants.filter((assistant) => { + const idx = messages.findIndex((message) => message.id === assistant.id); + if (idx > finalizedIdx) return true; + if (assistant.id === lastFinalizedAssistantId) { + return isGrownFinalizedText(assistant.text ?? "", lastFinalizedText); + } + return false; + }); +} + +/** True when current text is a clear expansion of a prior premature final. */ +export function isGrownFinalizedText( + currentText: string, + lastFinalizedText: string | null, +): boolean { + const current = currentText.trimEnd(); + if (current === "") return false; + if (lastFinalizedText === null) return false; + const prior = lastFinalizedText.trimEnd(); + if (prior === "") return current.length >= 40; + if (current === prior) return false; + // Grown body: longer by a meaningful margin, or prior was a short status prefix. + if (current.length >= Math.max(prior.length + 40, Math.ceil(prior.length * 1.5))) { + return true; + } + if ( + prior.length <= 120 && + current.length > prior.length && + current.startsWith(prior.slice(0, 20)) + ) { + return true; + } + return false; +} + +/** + * Assistants that may appear on Discord for this snapshot. + * + * Structural rules (in order): + * 1. Prefer turnId match when the turn is still running (mid-turn steer keeps pre-steer). + * 2. If a newer **user** message sits after every turnId-matched assistant and the turn + * is **not** running, treat that as the next Discord turn starting with a stale + * latestTurn — return only assistants after that user (usually empty). + * 3. If turnId is set but no assistants match and the turn is **running**, return empty + * (never after-last-user prior bodies — that re-streams the previous final under + * `_Working.._` when a comment recovers the bridge before the new user lands). + * 4. If turnId is set, no assistants match, and the turn is **settled**, prefer + * after-last-user for catch-up finalize (filter via lastFinalized). + * 5. Fall back to after-last-user only when messages lack turn ids entirely. + * 6. Always drop assistants at/before `lastFinalizedAssistantId` in message order + * (unless same-id text grew past lastFinalizedText). + */ +export function assistantMessagesForDelivery(input: { + readonly messages: ReadonlyArray<{ + readonly id: string; + readonly role: string; + readonly turnId: string | null; + readonly text: string; + }>; + readonly turnId: string | null; + readonly turnInProgress: boolean; + readonly hasLatestTurn: boolean; + /** Durable id of the last assistant Discord successfully finalized (any epoch). */ + readonly lastFinalizedAssistantId?: string | null; + readonly lastFinalizedText?: string | null; +}): ReadonlyArray<{ + readonly id: string; + readonly role: string; + readonly turnId: string | null; + readonly text: string; +}> { + const { messages, turnId, turnInProgress, hasLatestTurn } = input; + const lastFinalizedAssistantId = input.lastFinalizedAssistantId ?? null; + const lastFinalizedText = input.lastFinalizedText ?? null; + void hasLatestTurn; + + let lastUserIdx = -1; + for (let index = messages.length - 1; index >= 0; index -= 1) { + if (messages[index]?.role === "user") { + lastUserIdx = index; + break; + } + } + const afterLastUser = (lastUserIdx >= 0 ? messages.slice(lastUserIdx + 1) : messages).filter( + (message) => message.role === "assistant", + ); + + let selected: ReadonlyArray<{ + readonly id: string; + readonly role: string; + readonly turnId: string | null; + readonly text: string; + }>; + + if (turnId !== null) { + const forTurn = messages.filter( + (message) => message.role === "assistant" && message.turnId === turnId, + ); + if (forTurn.length > 0) { + const lastForTurn = forTurn[forTurn.length - 1]!; + const lastForTurnIdx = messages.findLastIndex((message) => message.id === lastForTurn.id); + // Stale latestTurn after a completed turn: a newer user message means a new Discord + // turn is starting — never re-surface the completed turn's body. + if (lastUserIdx > lastForTurnIdx && !turnInProgress) { + selected = afterLastUser; + } else { + selected = forTurn; + } + } else if (turnInProgress) { + // New turn has no assistants yet. Never fall back to prior-turn afterLastUser + // bodies — that re-streams the previous final under _Working.._ + Stop when a + // comment recovers the bridge before the new user message is in the snapshot + // (or before lastFinalizedAssistantId is known). Hold empty until this turn + // produces its own assistant content. + selected = []; + } else { + // Settled catch-up: after-last-user only (usually the previous answer for finalize). + // Finalized filter below strips already-delivered bubbles. + selected = afterLastUser; + } + } else { + selected = afterLastUser; + } + + return excludeFinalizedAssistants({ + messages, + assistants: selected, + lastFinalizedAssistantId, + lastFinalizedText, + }); +} + +/** + * Prior-turn assistant Discord still owes a final for. + * + * Queue drain can advance `latestTurn` to the parked follow-up before Discord + * posted the previous T3 answer (or after a premature short-status finalize). + * {@link assistantMessagesForDelivery} hides that body on purpose (must not + * stream it under the next Working tip). Callers catch-up-finalize it as its + * own Discord final even when the next turn already has assistants. + */ +export function unfinalizedPriorAssistantForCatchUp(input: { + readonly messages: ReadonlyArray<{ + readonly id: string; + readonly role: string; + readonly turnId: string | null; + readonly text: string; + }>; + readonly currentTurnId: string | null; + readonly lastFinalizedAssistantId: string | null; + readonly lastFinalizedText?: string | null; +}): { + readonly id: string; + readonly text: string; + readonly turnId: string | null; +} | null { + const { messages, currentTurnId } = input; + const lastFinalizedText = input.lastFinalizedText ?? null; + let prior: { + readonly id: string; + readonly text: string; + readonly turnId: string | null; + } | null = null; + for (const message of messages) { + if (message.role !== "assistant") continue; + if (currentTurnId !== null && message.turnId === currentTurnId) continue; + const text = message.text.trimEnd(); + if (text === "" || (/^_Working/i.test(text) && text.length < 40)) continue; + prior = { id: message.id, text: message.text, turnId: message.turnId }; + } + if (prior === null) return null; + + const remaining = excludeFinalizedAssistants({ + messages, + assistants: [prior], + lastFinalizedAssistantId: input.lastFinalizedAssistantId, + lastFinalizedText, + }); + return remaining[0] ?? null; +} + +/** + * Keep a substantial unfinalized stream body when the epoch enters awaiting + * (fresh Working / next turn with no assistants yet). Wiping it here used to + * drop the prior answer on queue drain before the next turn streamed. + */ +export function retainUnfinalizedStreamText(input: { + readonly phase: DeliveryPhase; + readonly streamText: string; + readonly priorLastAssistantText: string; +}): string { + if (input.phase === "streaming" && input.streamText.trim() !== "") { + return input.streamText; + } + const prior = input.priorLastAssistantText.trim(); + const awaitingOrEmptyStream = + input.phase === "awaiting" || (input.phase === "streaming" && input.streamText.trim() === ""); + if (awaitingOrEmptyStream && prior !== "" && !(/^_Working/i.test(prior) && prior.length < 40)) { + return input.priorLastAssistantText; + } + if (input.phase === "awaiting") return ""; + if (input.phase === "streaming") return input.streamText; + return input.priorLastAssistantText; +} + +export function deliveryTextFromAssistants( + assistants: ReadonlyArray<{ readonly text: string }>, + mode: "progress" | "answer", +): string { + const texts = assistants + .map((message) => message.text.trimEnd()) + .filter((text) => text.trim() !== ""); + if (texts.length === 0) return ""; + if (mode === "progress" || texts.length === 1) return texts.join("\n\n").trimEnd(); + + // Mirror finalAnswerText: prefer last bubble unless it is a short trailer after Findings. + const last = texts[texts.length - 1]!; + const longest = texts.reduce((a, b) => (a.length >= b.length ? a : b)); + const SHORT_TRAILER_MAX_CHARS = 400; + if ( + longest.length >= 800 && + last.length < SHORT_TRAILER_MAX_CHARS && + last.length < longest.length * 0.35 + ) { + return longest; + } + return last; +} + +/** + * Decide what Discord may do for this thread snapshot. + * + * Hard invariants: + * - Never stream/finalize assistants at/before lastFinalizedAssistantId — even while + * turnInProgress (unless same-id text grew past lastFinalizedText). + * - Heartbeat after finalize is always noop. + * - `finalized` epoch reopens when a **new** assistant appears after lastFinalized, or + * the finalized bubble's text grew into a real answer. + * - Settle grace: first idle snapshot with content streams/holds; second idle snapshot + * finalizes (avoids locking on multi-step status lines). + */ +export function decideAssistantDelivery(input: { + readonly state: DeliveryEpochState; + readonly turnId: string | null; + readonly turnInProgress: boolean; + readonly assistants: ReadonlyArray<{ + readonly id: string; + readonly text: string; + }>; + readonly streaming: boolean; + readonly presentationFull: boolean; + /** + * Full thread message order (optional). When provided with lastFinalizedAssistantId, + * drops every assistant at/before that bubble — not only the exact id. + */ + readonly messages?: ReadonlyArray<{ readonly id: string }>; + /** + * When true, skip the two-snapshot settle grace and finalize on the first idle snapshot. + * Used for rehydrate/catch-up of already-settled turns so Discord does not leave a + * permanent `_Working.. · N tool calls_` tip waiting for a second snapshot that never + * arrives on idle threads. + */ + readonly skipSettleGrace?: boolean; +}): { readonly state: DeliveryEpochState; readonly intent: DeliveryIntent } { + const { turnId, turnInProgress, streaming, presentationFull } = input; + const skipSettleGrace = input.skipSettleGrace === true; + + // Drop already-finalized bubbles first (works for both open and reopened epochs). + const assistants = excludeFinalizedAssistants({ + messages: input.messages ?? input.assistants, + assistants: input.assistants, + lastFinalizedAssistantId: input.state.lastFinalizedAssistantId, + lastFinalizedText: input.state.lastFinalizedText, + }); + + // After a premature finalize, late assistants after lastFinalized reopen delivery. + let state = input.state; + if (state.phase === "finalized") { + if (assistants.length === 0) { + return { + state, + intent: { _tag: "noop", reason: "epoch-finalized" }, + }; + } + // Reopen same epoch so stream/finalize can post the real answer without a new Working ack. + state = { + ...state, + phase: turnInProgress || streaming ? "streaming" : "awaiting", + streamText: "", + assistantId: null, + finalizedAssistantId: null, + settleReady: false, + }; + } + + // In-progress work always resets settle grace. + if (turnInProgress || streaming) { + state = { ...state, settleReady: false }; + } + + const assistantId = assistants.at(-1)?.id ?? null; + const progressText = deliveryTextFromAssistants(assistants, "progress"); + const answerText = deliveryTextFromAssistants(assistants, "answer"); + + // Only already-finalized content was available (filtered out). Hold while the turn + // is running / awaiting; when settled, noop without posting. + if (assistants.length === 0 && input.assistants.length > 0) { + if (turnInProgress || streaming || state.phase === "awaiting") { + return { + state: { + ...state, + phase: state.phase === "idle" ? "awaiting" : state.phase, + turnId: turnId ?? state.turnId, + settleReady: false, + }, + intent: { _tag: "hold", reason: "assistant-already-finalized" }, + }; + } + return { + state, + intent: { _tag: "noop", reason: "assistant-already-finalized" }, + }; + } + + // Awaiting Working: no assistant body for this epoch yet → hold. + if (state.phase === "awaiting" && assistants.length === 0) { + return { + state: { ...state, turnId: turnId ?? state.turnId, settleReady: false }, + intent: { _tag: "hold", reason: "awaiting-first-assistant" }, + }; + } + + if (!presentationFull && streaming) { + return { state, intent: { _tag: "noop", reason: "final-only-suppress-stream" } }; + } + + if (streaming || turnInProgress) { + if (assistants.length === 0) { + return { + state: { + ...state, + phase: state.phase === "idle" ? "awaiting" : state.phase, + turnId: turnId ?? state.turnId, + settleReady: false, + }, + intent: { _tag: "hold", reason: "in-progress-no-assistant-text" }, + }; + } + if (assistantId === null) { + return { state, intent: { _tag: "noop", reason: "missing-assistant-id" } }; + } + const next: DeliveryEpochState = { + ...state, + phase: "streaming", + turnId: turnId ?? state.turnId, + assistantId, + streamText: progressText, + settleReady: false, + }; + return { + state: next, + intent: { + _tag: "stream", + text: progressText, + turnId: next.turnId, + assistantId, + epoch: state.epoch, + }, + }; + } + + // Turn settled. + if (assistants.length === 0 || answerText.trim() === "") { + return { + state, + intent: { _tag: "noop", reason: "settled-without-content" }, + }; + } + if (assistantId === null) { + return { state, intent: { _tag: "noop", reason: "missing-assistant-id" } }; + } + + // Settle grace: first idle snapshot with *short* content keeps streaming the tip body + // and arms settleReady (status lines like "Checking PR…" often grow into a real answer). + // Substantial settled answers finalize immediately — otherwise recovery/rehydrate streams + // the full previous final under `_Working.._` + Stop for one+ snapshots (or forever if a + // new turn starts before the second idle tick). + // Skip grace entirely on rehydrate/catch-up (`skipSettleGrace`) when no second snapshot. + const SETTLE_GRACE_MAX_CHARS = 250; + if ( + !state.settleReady && + !skipSettleGrace && + answerText.trim().length <= SETTLE_GRACE_MAX_CHARS + ) { + const next: DeliveryEpochState = { + ...state, + phase: "streaming", + turnId: turnId ?? state.turnId, + assistantId, + streamText: answerText, + settleReady: true, + }; + return { + state: next, + intent: { + _tag: "stream", + text: answerText, + turnId: next.turnId, + assistantId, + epoch: state.epoch, + }, + }; + } + + const next: DeliveryEpochState = { + ...state, + phase: "finalized", + turnId: turnId ?? state.turnId, + assistantId, + streamText: "", + finalizedAssistantId: assistantId, + lastFinalizedAssistantId: assistantId, + lastFinalizedText: answerText, + settleReady: false, + }; + return { + state: next, + intent: { + _tag: "finalize", + text: answerText, + turnId: next.turnId, + assistantId, + epoch: state.epoch, + }, + }; +} + +/** + * Heartbeat may only pulse while awaiting/streaming for the current epoch. + * Never recreates Working after finalize (that produced final + Working duplicates). + */ +export function decideHeartbeat(input: { + readonly state: DeliveryEpochState; + readonly turnInProgress: boolean; + readonly hasOpenTip: boolean; +}): Extract { + const { state, turnInProgress } = input; + if (state.phase === "finalized" || state.phase === "idle") { + return { _tag: "noop", reason: "heartbeat-inactive-phase" }; + } + if (!turnInProgress && state.phase !== "awaiting" && !state.settleReady) { + return { _tag: "noop", reason: "heartbeat-turn-idle" }; + } + // Awaiting: dots only. Streaming / settle-grace: may show streamText (current epoch only). + const tipBody = state.phase === "awaiting" ? "" : state.streamText; + // Note: the `finalized` phase is already short-circuited to a noop at the top of this + // function, so no post-finalize recreate guard is reachable here. + return { _tag: "heartbeat", tipBody, epoch: state.epoch }; +} + +/** + * Whether a stream tip update failure should create a replacement tip. + * Never after the epoch is finalized. + */ +export function shouldRecreateTip(input: { + readonly state: DeliveryEpochState; + readonly updateFailed: boolean; + readonly turnInProgress: boolean; +}): boolean { + if (!input.updateFailed) return false; + if (!input.turnInProgress && !input.state.settleReady) return false; + return input.state.phase === "awaiting" || input.state.phase === "streaming"; +} diff --git a/apps/discord-bot/src/features/DiscordQueuedPromptRegistry.test.ts b/apps/discord-bot/src/features/DiscordQueuedPromptRegistry.test.ts new file mode 100644 index 000000000000..985e31f7da26 --- /dev/null +++ b/apps/discord-bot/src/features/DiscordQueuedPromptRegistry.test.ts @@ -0,0 +1,130 @@ +import { MessageId, ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + createDiscordQueuedPromptRegistry, + formatSteernowEmptyQueueMessage, + resolveSteernowMessageIds, +} from "./DiscordQueuedPromptRegistry.ts"; + +describe("DiscordQueuedPromptRegistry", () => { + it("remembers entries by Discord message and thread", () => { + const registry = createDiscordQueuedPromptRegistry(); + const entry = { + discordChannelId: "channel-1", + discordMessageId: "discord-1", + t3ThreadId: ThreadId.make("thread-1"), + t3MessageId: MessageId.make("msg-1"), + authorUserId: "user-1", + }; + registry.remember(entry); + expect(registry.getByDiscordMessageId("discord-1")).toEqual(entry); + expect(registry.listForThread(ThreadId.make("thread-1"))).toEqual([entry]); + }); + + it("forgets by Discord message id and by T3 message id", () => { + const registry = createDiscordQueuedPromptRegistry(); + registry.remember({ + discordChannelId: "channel-1", + discordMessageId: "discord-1", + t3ThreadId: ThreadId.make("thread-1"), + t3MessageId: MessageId.make("msg-1"), + authorUserId: null, + }); + registry.remember({ + discordChannelId: "channel-1", + discordMessageId: "discord-2", + t3ThreadId: ThreadId.make("thread-1"), + t3MessageId: MessageId.make("msg-2"), + authorUserId: null, + }); + + expect(registry.forgetDiscordMessage("discord-1")?.t3MessageId).toBe("msg-1"); + expect(registry.getByDiscordMessageId("discord-1")).toBeNull(); + expect(registry.listForThread(ThreadId.make("thread-1"))).toHaveLength(1); + + expect( + registry.forgetT3Message(ThreadId.make("thread-1"), MessageId.make("msg-2")) + ?.discordMessageId, + ).toBe("discord-2"); + expect(registry.listForThread(ThreadId.make("thread-1"))).toEqual([]); + }); + + it("clears an entire thread", () => { + const registry = createDiscordQueuedPromptRegistry(); + registry.remember({ + discordChannelId: "channel-1", + discordMessageId: "discord-1", + t3ThreadId: ThreadId.make("thread-1"), + t3MessageId: MessageId.make("msg-1"), + authorUserId: null, + }); + const cleared = registry.clearThread(ThreadId.make("thread-1")); + expect(cleared).toHaveLength(1); + expect(registry.listForThread(ThreadId.make("thread-1"))).toEqual([]); + }); +}); + +describe("resolveSteernowMessageIds", () => { + it("prefers the server queue when present", () => { + const result = resolveSteernowMessageIds({ + serverQueued: [ + { messageId: MessageId.make("server-1") }, + { messageId: MessageId.make("server-2") }, + ], + localPending: [{ t3MessageId: MessageId.make("local-1") }], + detailLoaded: true, + }); + expect(result).toEqual({ + messageIds: [MessageId.make("server-1"), MessageId.make("server-2")], + source: "server", + snapshotMissing: false, + }); + }); + + it("falls back to the local registry when the server queue is empty", () => { + const result = resolveSteernowMessageIds({ + serverQueued: [], + localPending: [ + { t3MessageId: MessageId.make("local-1") }, + { t3MessageId: MessageId.make("local-1") }, + { t3MessageId: MessageId.make("local-2") }, + ], + detailLoaded: false, + }); + expect(result).toEqual({ + messageIds: [MessageId.make("local-1"), MessageId.make("local-2")], + source: "local", + snapshotMissing: true, + }); + }); + + it("reports empty with snapshotMissing when both sources are empty and detail failed", () => { + expect( + resolveSteernowMessageIds({ + serverQueued: [], + localPending: [], + detailLoaded: false, + }), + ).toEqual({ + messageIds: [], + source: "empty", + snapshotMissing: true, + }); + }); +}); + +describe("formatSteernowEmptyQueueMessage", () => { + it("mentions steer path when the queue is truly empty", () => { + const text = formatSteernowEmptyQueueMessage({ snapshotMissing: false }); + expect(text).toContain("Nothing is queued"); + expect(text).toContain("/agent steer"); + expect(text).toContain("/agent steernow"); + }); + + it("mentions snapshot failure when the HTTP detail is missing", () => { + const text = formatSteernowEmptyQueueMessage({ snapshotMissing: true }); + expect(text).toContain("thread snapshot unavailable"); + expect(text).toContain("/agent steer"); + }); +}); diff --git a/apps/discord-bot/src/features/DiscordQueuedPromptRegistry.ts b/apps/discord-bot/src/features/DiscordQueuedPromptRegistry.ts new file mode 100644 index 000000000000..af358b04ce77 --- /dev/null +++ b/apps/discord-bot/src/features/DiscordQueuedPromptRegistry.ts @@ -0,0 +1,163 @@ +import type { MessageId, ThreadId } from "@t3tools/contracts"; + +/** + * Tracks Discord user messages that are parked in the server follow-up queue so + * we can badge them (📥), remove on delete, and flush via /omegent steernow. + * + * In-memory only: process restart drops badges (server queue remains authoritative). + */ +export type PendingQueuedPrompt = { + readonly discordChannelId: string; + readonly discordMessageId: string; + readonly t3ThreadId: ThreadId; + readonly t3MessageId: MessageId; + readonly authorUserId: string | null; +}; + +/** Discord unicode used as the "queued" badge on the user's message. */ +export const QUEUED_PROMPT_REACTION_EMOJI = "📥"; + +/** + * Resolve which message ids `/omegent steernow` should inject. + * + * Prefer the server queue (authoritative after restart). Fall back to the + * in-memory Discord registry when the HTTP snapshot is missing/lagging so a + * just-queued mid-turn follow-up is still steerable. + */ +export function resolveSteernowMessageIds(input: { + readonly serverQueued: ReadonlyArray<{ readonly messageId: MessageId }>; + readonly localPending: ReadonlyArray<{ readonly t3MessageId: MessageId }>; + /** True when `fetchThreadDetail` returned a snapshot (even if queue empty). */ + readonly detailLoaded: boolean; +}): { + readonly messageIds: ReadonlyArray; + readonly source: "server" | "local" | "empty"; + readonly snapshotMissing: boolean; +} { + if (input.serverQueued.length > 0) { + // Dedupe while preserving server order. + const seen = new Set(); + const messageIds: MessageId[] = []; + for (const entry of input.serverQueued) { + const key = String(entry.messageId); + if (seen.has(key)) continue; + seen.add(key); + messageIds.push(entry.messageId); + } + return { messageIds, source: "server", snapshotMissing: false }; + } + + if (input.localPending.length > 0) { + const seen = new Set(); + const messageIds: MessageId[] = []; + for (const entry of input.localPending) { + const key = String(entry.t3MessageId); + if (seen.has(key)) continue; + seen.add(key); + messageIds.push(entry.t3MessageId); + } + return { + messageIds, + source: "local", + snapshotMissing: !input.detailLoaded, + }; + } + + return { + messageIds: [], + source: "empty", + snapshotMissing: !input.detailLoaded, + }; +} + +/** User-facing reply when steernow has nothing to inject. */ +export function formatSteernowEmptyQueueMessage(input: { + readonly snapshotMissing: boolean; +}): string { + if (input.snapshotMissing) { + return [ + "Could not load the server queue (thread snapshot unavailable), and nothing is parked in this bot process.", + "Use `/agent steer prompt:…` (or `@Omegent --steer …`) to inject mid-turn, then try `/agent steernow` again if you park follow-ups.", + ].join(" "); + } + return [ + "Nothing is queued on this thread.", + "Mid-turn follow-ups park with 📥 by default — then `/agent steernow` flushes them.", + "To inject immediately, use `/agent steer prompt:…` or `@Omegent --steer …`.", + ].join(" "); +} + +export function createDiscordQueuedPromptRegistry() { + const byDiscordMessageId = new Map(); + const byT3ThreadId = new Map>(); + + const remember = (entry: PendingQueuedPrompt): void => { + byDiscordMessageId.set(entry.discordMessageId, entry); + const key = String(entry.t3ThreadId); + const set = byT3ThreadId.get(key) ?? new Set(); + set.add(entry.discordMessageId); + byT3ThreadId.set(key, set); + }; + + const forgetDiscordMessage = (discordMessageId: string): PendingQueuedPrompt | null => { + const entry = byDiscordMessageId.get(discordMessageId); + if (entry === undefined) return null; + byDiscordMessageId.delete(discordMessageId); + const key = String(entry.t3ThreadId); + const set = byT3ThreadId.get(key); + if (set !== undefined) { + set.delete(discordMessageId); + if (set.size === 0) byT3ThreadId.delete(key); + } + return entry; + }; + + const forgetT3Message = ( + t3ThreadId: ThreadId, + t3MessageId: MessageId, + ): PendingQueuedPrompt | null => { + const key = String(t3ThreadId); + const set = byT3ThreadId.get(key); + if (set === undefined) return null; + for (const discordMessageId of set) { + const entry = byDiscordMessageId.get(discordMessageId); + if (entry !== undefined && entry.t3MessageId === t3MessageId) { + return forgetDiscordMessage(discordMessageId); + } + } + return null; + }; + + const listForThread = (t3ThreadId: ThreadId): ReadonlyArray => { + const set = byT3ThreadId.get(String(t3ThreadId)); + if (set === undefined) return []; + const out: PendingQueuedPrompt[] = []; + for (const discordMessageId of set) { + const entry = byDiscordMessageId.get(discordMessageId); + if (entry !== undefined) out.push(entry); + } + return out; + }; + + const getByDiscordMessageId = (discordMessageId: string): PendingQueuedPrompt | null => + byDiscordMessageId.get(discordMessageId) ?? null; + + const clearThread = (t3ThreadId: ThreadId): ReadonlyArray => { + const listed = listForThread(t3ThreadId); + for (const entry of listed) { + forgetDiscordMessage(entry.discordMessageId); + } + return listed; + }; + + return { + remember, + forgetDiscordMessage, + forgetT3Message, + listForThread, + getByDiscordMessageId, + clearThread, + }; +} + +export type DiscordQueuedPromptRegistry = ReturnType; diff --git a/apps/discord-bot/src/features/DiscordThreadTurnCoordinator.test.ts b/apps/discord-bot/src/features/DiscordThreadTurnCoordinator.test.ts new file mode 100644 index 000000000000..5049aab1b973 --- /dev/null +++ b/apps/discord-bot/src/features/DiscordThreadTurnCoordinator.test.ts @@ -0,0 +1,107 @@ +import { it } from "@effect/vitest"; +import { describe, expect } from "vite-plus/test"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; + +import { makeDiscordThreadTurnCoordinator } from "./DiscordThreadTurnCoordinator.ts"; + +describe("DiscordThreadTurnCoordinator", () => { + it.live("prevents overlapping first-link creation for the same Discord thread", () => + Effect.scoped( + Effect.gen(function* () { + const coordinator = yield* makeDiscordThreadTurnCoordinator; + const linked = yield* Ref.make(false); + const createdCount = yield* Ref.make(0); + const firstStarted = yield* Deferred.make(); + const releaseFirst = yield* Deferred.make(); + const secondFinished = yield* Deferred.make(); + + const handleMention = (isFirst: boolean) => + coordinator.withLock( + "discord-thread-1", + Effect.gen(function* () { + if (yield* Ref.get(linked)) return; + yield* Ref.update(createdCount, (count) => count + 1); + if (isFirst) { + yield* Deferred.succeed(firstStarted, undefined); + yield* Deferred.await(releaseFirst); + } + yield* Ref.set(linked, true); + }), + ); + + yield* Effect.forkChild(handleMention(true)); + yield* Deferred.await(firstStarted); + yield* Effect.forkChild( + handleMention(false).pipe( + Effect.ensuring(Deferred.succeed(secondFinished, undefined).pipe(Effect.orDie)), + ), + ); + yield* Effect.yieldNow; + + expect(yield* Ref.get(createdCount)).toBe(1); + + yield* Deferred.succeed(releaseFirst, undefined); + yield* Deferred.await(secondFinished); + + expect(yield* Ref.get(createdCount)).toBe(1); + }), + ), + ); + + it.live("does not serialize unrelated Discord threads", () => + Effect.scoped( + Effect.gen(function* () { + const coordinator = yield* makeDiscordThreadTurnCoordinator; + const firstStarted = yield* Deferred.make(); + const releaseFirst = yield* Deferred.make(); + const secondRan = yield* Ref.make(false); + + yield* Effect.forkChild( + coordinator.withLock( + "discord-thread-1", + Deferred.succeed(firstStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseFirst)), + ), + ), + ); + yield* Deferred.await(firstStarted); + + yield* coordinator.withLock("discord-thread-2", Ref.set(secondRan, true)); + expect(yield* Ref.get(secondRan)).toBe(true); + + yield* Deferred.succeed(releaseFirst, undefined); + }), + ), + ); + + it.live("can reject work immediately when a thread lock is occupied", () => + Effect.scoped( + Effect.gen(function* () { + const coordinator = yield* makeDiscordThreadTurnCoordinator; + const firstStarted = yield* Deferred.make(); + const releaseFirst = yield* Deferred.make(); + + yield* Effect.forkChild( + coordinator.withLock( + "discord-thread-1", + Deferred.succeed(firstStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseFirst)), + ), + ), + ); + yield* Deferred.await(firstStarted); + + const result = yield* coordinator.tryWithLock( + "discord-thread-1", + Effect.succeed("unexpected"), + ); + expect(Option.isNone(result)).toBe(true); + + yield* Deferred.succeed(releaseFirst, undefined); + }), + ), + ); +}); diff --git a/apps/discord-bot/src/features/DiscordThreadTurnCoordinator.ts b/apps/discord-bot/src/features/DiscordThreadTurnCoordinator.ts new file mode 100644 index 000000000000..8e603eb6123a --- /dev/null +++ b/apps/discord-bot/src/features/DiscordThreadTurnCoordinator.ts @@ -0,0 +1,45 @@ +import * as Effect from "effect/Effect"; +import type * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; +import * as Semaphore from "effect/Semaphore"; + +export interface DiscordThreadTurnCoordinator { + readonly withLock: ( + discordThreadId: string, + effect: Effect.Effect, + ) => Effect.Effect; + readonly tryWithLock: ( + discordThreadId: string, + effect: Effect.Effect, + ) => Effect.Effect, E, R>; +} + +/** + * Serializes mention handling per Discord thread. In particular, a follow-up + * mention must not race the first mention between link lookup and persistence. + */ +export const makeDiscordThreadTurnCoordinator = Effect.gen(function* () { + const locksRef = yield* Ref.make>(new Map()); + + const getLock = (discordThreadId: string) => + Effect.gen(function* () { + const existing = (yield* Ref.get(locksRef)).get(discordThreadId); + if (existing !== undefined) return existing; + + const created = yield* Semaphore.make(1); + return yield* Ref.modify(locksRef, (locks) => { + const current = locks.get(discordThreadId); + if (current !== undefined) return [current, locks] as const; + const next = new Map(locks); + next.set(discordThreadId, created); + return [created, next] as const; + }); + }); + + return { + withLock: (discordThreadId, effect) => + Effect.flatMap(getLock(discordThreadId), (lock) => lock.withPermit(effect)), + tryWithLock: (discordThreadId, effect) => + Effect.flatMap(getLock(discordThreadId), (lock) => lock.withPermitsIfAvailable(1)(effect)), + } satisfies DiscordThreadTurnCoordinator; +}); diff --git a/apps/discord-bot/src/features/LinkedTurnRouter.ts b/apps/discord-bot/src/features/LinkedTurnRouter.ts new file mode 100644 index 000000000000..4119f50da302 --- /dev/null +++ b/apps/discord-bot/src/features/LinkedTurnRouter.ts @@ -0,0 +1,312 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectContext:off globalDate:off globalErrorInEffectFailure:off outdatedApi:off +import type { UploadChatAttachment } from "@t3tools/contracts"; +import { DiscordREST } from "dfx"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Result from "effect/Result"; + +import type { DiscordBotConfig } from "../config.ts"; +import { workingMessageFields } from "../presentation/messages.ts"; +import { + buildFirstTurnPrompt, + looksLikeSentryContext, + type DiscordMessageLike, +} from "../presentation/threadContext.ts"; +import { ProjectAliasStore } from "../projectAliases.ts"; +import { ThreadLinkStore } from "../store/ThreadLinkStore.ts"; +import { T3Session } from "../t3/T3Session.ts"; +import { discordSourceHint } from "../t3/sourceHint.ts"; +import { bridgeThreadToDiscord } from "./ResponseBridge.ts"; + +export interface LinkedTurnFlags { + readonly provider?: string | undefined; + readonly model?: string | undefined; + readonly base?: string | undefined; + readonly local?: boolean | undefined; + readonly plan?: boolean | undefined; +} + +export interface LinkedTurnSource { + readonly sourceKind: "discord" | "teams"; + readonly sourceThreadId: string; +} + +export interface LinkedTurnPromptContext { + readonly kind: "discord"; + readonly topic: string | null | undefined; + readonly mentionMessage?: DiscordMessageLike | undefined; + readonly starter?: DiscordMessageLike | null | undefined; +} + +export interface LinkedTurnInput { + readonly source: LinkedTurnSource; + readonly discordThreadId: string; + readonly discordParentChannelId: string; + readonly discordGuildId: string; + readonly projectShortName: string; + readonly prompt: string; + readonly flags: LinkedTurnFlags; + readonly stickyModelOnContinue?: boolean | undefined; + readonly attachments?: ReadonlyArray | undefined; + readonly announceLines: ReadonlyArray; + readonly promptContext?: + | LinkedTurnPromptContext + | { + readonly kind: "raw"; + readonly value: string; + } + | undefined; +} + +export interface TransportNeutralLinkedTurnInput { + readonly source: LinkedTurnSource; + /** Stable delivery/conversation id. Stored in the legacy discordThreadId field for v2 links. */ + readonly externalConversationId: string; + readonly externalParentId: string; + readonly externalTenantId: string; + readonly projectShortName: string; + readonly prompt: string; + readonly flags: LinkedTurnFlags; + readonly stickyModelOnContinue?: boolean | undefined; + readonly attachments?: ReadonlyArray | undefined; + readonly promptContext?: LinkedTurnInput["promptContext"]; +} + +/** + * Shared start/continue path for Discord mentions and Teams intake. + * Ported from aaaomega/t3code-pvt#1 and adapted to the current ThreadLinkStore + bridge APIs. + */ +export const resolveProjectFromShortName = Effect.fn("resolveProjectFromShortName")(function* ( + projectShortName: string, +) { + const aliases = yield* ProjectAliasStore; + const t3 = yield* T3Session; + + const alias = aliases.resolve(projectShortName); + if (alias === null) { + return yield* Effect.fail( + `Unknown project alias '${projectShortName}'. Add it to the bot aliases file (T3_PROJECT_ALIASES_PATH).` as const, + ); + } + const project = yield* t3.findProjectByWorkspaceRoot(alias.workspaceRoot); + if (project === null) { + return yield* Effect.fail( + `No T3 project registered at ${alias.workspaceRoot} (alias '${projectShortName}'). Add the project in T3 first.` as const, + ); + } + + return { alias, project }; +}); + +/** + * Transport-neutral T3 start/continue path. Discord and Teams own their presentation and + * delivery lifecycle, while this function owns project resolution, model selection, T3 + * orchestration, and the durable source-conversation link. + */ +export const startOrContinueT3Turn = Effect.fn("startOrContinueT3Turn")(function* ( + config: DiscordBotConfig, + input: TransportNeutralLinkedTurnInput, +) { + const t3 = yield* T3Session; + const links = yield* ThreadLinkStore; + const attachments = input.attachments ?? []; + const hasExplicitModelFlags = + input.flags.provider !== undefined || input.flags.model !== undefined; + const resolved = yield* resolveProjectFromShortName(input.projectShortName); + const existing = yield* links.getBySourceThread( + input.source.sourceKind, + input.source.sourceThreadId, + ); + + if (existing !== null) { + const continueModelSelection = + input.stickyModelOnContinue === true && !hasExplicitModelFlags + ? undefined + : yield* t3.resolveModelSelection({ + project: resolved.project, + ...(input.flags.provider === undefined + ? {} + : { overrideInstanceId: input.flags.provider }), + ...(input.flags.model === undefined ? {} : { overrideModel: input.flags.model }), + }); + const mentionAuthor = + input.promptContext?.kind === "discord" ? input.promptContext.mentionMessage?.author : null; + const sourceHint = + input.source.sourceKind === "discord" + ? discordSourceHint({ + authorId: mentionAuthor?.id, + authorUsername: mentionAuthor?.username, + guildId: input.externalTenantId, + channelId: input.externalParentId, + discordThreadId: input.externalConversationId, + }) + : undefined; + yield* t3.startTurn({ + threadId: existing.t3ThreadId, + prompt: input.prompt, + ...(continueModelSelection === undefined ? {} : { modelSelection: continueModelSelection }), + ...(input.flags.plan ? { interactionMode: "plan" as const } : {}), + ...(attachments.length > 0 ? { attachments } : {}), + ...(sourceHint === undefined ? {} : { sourceHint }), + }); + return { threadId: existing.t3ThreadId, isNew: false } as const; + } + + const modelSelection = yield* t3.resolveModelSelection({ + project: resolved.project, + ...(input.flags.provider === undefined ? {} : { overrideInstanceId: input.flags.provider }), + ...(input.flags.model === undefined ? {} : { overrideModel: input.flags.model }), + }); + const enrichedPrompt = resolveInitialPrompt({ + config, + projectShortName: input.projectShortName, + workspaceRoot: resolved.project.workspaceRoot, + prompt: input.prompt, + promptContext: input.promptContext, + guildId: input.externalTenantId, + discordThreadId: input.externalConversationId, + }); + const mentionAuthor = + input.promptContext?.kind === "discord" ? input.promptContext.mentionMessage?.author : null; + const sourceHint = + input.source.sourceKind === "discord" + ? discordSourceHint({ + authorId: mentionAuthor?.id, + authorUsername: mentionAuthor?.username, + guildId: input.externalTenantId, + channelId: input.externalParentId, + discordThreadId: input.externalConversationId, + }) + : undefined; + const { threadId } = yield* t3.startTurnWithWorktree({ + project: resolved.project, + prompt: enrichedPrompt, + modelSelection, + interactionMode: input.flags.plan ? "plan" : "default", + baseBranch: input.flags.base ?? config.t3DefaultBaseBranch, + local: input.flags.local ?? false, + ...(attachments.length > 0 ? { attachments } : {}), + ...(sourceHint === undefined ? {} : { sourceHint }), + }); + + yield* links.put({ + sourceKind: input.source.sourceKind, + sourceThreadId: input.source.sourceThreadId, + discordThreadId: input.externalConversationId, + t3ThreadId: threadId, + projectId: resolved.project.id, + channelId: input.externalParentId, + guildId: input.externalTenantId, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + }); + return { threadId, isNew: true } as const; +}); + +function resolveInitialPrompt(input: { + readonly config: DiscordBotConfig; + readonly projectShortName: string; + readonly workspaceRoot: string; + readonly prompt: string; + readonly promptContext: LinkedTurnInput["promptContext"]; + readonly guildId: string; + readonly discordThreadId: string; +}): string { + if (input.promptContext?.kind === "raw") { + return input.promptContext.value; + } + + if (input.promptContext?.kind === "discord") { + const starter = input.promptContext.starter ?? input.promptContext.mentionMessage ?? null; + const sentryBootstrap = looksLikeSentryContext({ + starter, + mentionPrompt: input.prompt, + }); + if (sentryBootstrap || starter !== null) { + return buildFirstTurnPrompt({ + starter, + mentionMessage: input.promptContext.mentionMessage, + mentionPrompt: input.prompt, + projectShortName: input.projectShortName, + workspaceRoot: input.workspaceRoot, + honeycombTraceUrlTemplate: input.config.honeycombTraceUrlTemplate, + jiraBrowseBaseUrl: input.config.jiraBrowseBaseUrl, + guildId: input.guildId, + discordThreadId: input.discordThreadId, + }); + } + } + + return input.prompt; +} + +export const startOrContinueLinkedTurn = Effect.fn("startOrContinueLinkedTurn")(function* ( + config: DiscordBotConfig, + input: LinkedTurnInput, +) { + const rest = yield* DiscordREST; + const links = yield* ThreadLinkStore; + const existing = yield* links.getBySourceThread( + input.source.sourceKind, + input.source.sourceThreadId, + ); + if (existing !== null) { + const workingAckResult = yield* rest + .createMessage(input.discordThreadId, { + ...workingMessageFields("_Working.._", existing.t3ThreadId), + }) + .pipe( + Effect.map((message) => message.id as string), + Effect.tap((messageId) => Effect.logInfo("Posted Working.. ack", { messageId })), + Effect.result, + ); + if (Result.isFailure(workingAckResult)) { + yield* Effect.logError("Failed to post Working.. ack"); + yield* Effect.logError(workingAckResult.failure); + } + const workingAckMessageId = Result.isSuccess(workingAckResult) + ? workingAckResult.success + : null; + + yield* bridgeThreadToDiscord({ + discordChannelId: input.discordThreadId, + t3ThreadId: existing.t3ThreadId, + workingAckMessageId, + }); + } + + const turn = yield* startOrContinueT3Turn(config, { + source: input.source, + externalConversationId: input.discordThreadId, + externalParentId: input.discordParentChannelId, + externalTenantId: input.discordGuildId, + projectShortName: input.projectShortName, + prompt: input.prompt, + flags: input.flags, + ...(input.stickyModelOnContinue === undefined + ? {} + : { stickyModelOnContinue: input.stickyModelOnContinue }), + ...(input.attachments === undefined ? {} : { attachments: input.attachments }), + ...(input.promptContext === undefined ? {} : { promptContext: input.promptContext }), + }); + const threadId = turn.threadId; + + const webLink = + config.webUiBaseUrl === undefined + ? null + : `${config.webUiBaseUrl.replace(/\/$/u, "")}/?thread=${threadId}`; + + if (turn.isNew) { + yield* rest.createMessage(input.discordThreadId, { + content: [...input.announceLines, webLink === null ? null : `Open in Omegent: ${webLink}`] + .filter((line): line is string => line !== null && line.trim().length > 0) + .join("\n"), + }); + } + + yield* bridgeThreadToDiscord({ + discordChannelId: input.discordThreadId, + t3ThreadId: threadId, + }); + + return threadId; +}); diff --git a/apps/discord-bot/src/features/MentionRouter.test.ts b/apps/discord-bot/src/features/MentionRouter.test.ts new file mode 100644 index 000000000000..a962af35928a --- /dev/null +++ b/apps/discord-bot/src/features/MentionRouter.test.ts @@ -0,0 +1,380 @@ +// @effect-diagnostics nodeBuiltinImport:off - existence contract reads router source on disk. +import * as NodeFS from "node:fs"; +import { ProjectId, ProviderDriverKind, ProviderInstanceId, ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Ref from "effect/Ref"; +import { it as effectIt } from "@effect/vitest"; + +import { T3_CONNECT_WAIT_REACTION_EMOJI } from "../t3/T3Session.ts"; +import { + createHandledDiscordMessageTracker, + findDiscordLinkForT3Target, + getContinuedConversationModelChangeError, + isIncompleteDiscordLink, + isTransientDiscordDispatchError, + shouldShowThreadBootstrapReaction, + makeDiscordMessageDispatchQueue, + retryTransientDiscordOperation, +} from "./MentionRouter.ts"; + +const mentionRouterSource = NodeFS.readFileSync( + new URL("./MentionRouter.ts", import.meta.url), + "utf8", +); + +describe("T3 connect-wait queue", () => { + it("waits for T3 readiness on bridged turns instead of bouncing immediately", () => { + expect(mentionRouterSource).toContain("waitForT3ReadyForInbound"); + expect(mentionRouterSource).toContain('reason: "startBridgedTurn"'); + expect(mentionRouterSource).toContain("t3.waitUntilReady()"); + expect(mentionRouterSource).toContain(T3_CONNECT_WAIT_REACTION_EMOJI); + }); +}); + +describe("today-recap slash command", () => { + it("registers /omegent today-recap and posts the recap in the invoking channel", () => { + expect(mentionRouterSource).toContain('"today-recap": Effect.gen(function* () {'); + expect(mentionRouterSource).toContain("runTodayRecapTurn"); + expect(mentionRouterSource).toContain("buildTodayRecapPrompt"); + expect(mentionRouterSource).toContain("extractLatestAssistantText"); + expect(mentionRouterSource).toContain("updateOriginalWebhookMessage"); + expect(mentionRouterSource).toContain("formatTodayRecapWorking"); + expect(mentionRouterSource).toContain("chunkTodayRecapContent"); + expect(mentionRouterSource).toContain("today-recap T3 thread started"); + expect(mentionRouterSource).toContain('state === "error"'); + expect(mentionRouterSource).not.toContain("openTodayRecapThread"); + expect(mentionRouterSource).not.toContain("rest.createThread(input.projectChannelId"); + }); +}); + +describe("shouldShowThreadBootstrapReaction", () => { + it("marks channel prompts that need a Discord/T3 thread bootstrap", () => { + expect( + shouldShowThreadBootstrapReaction({ + inThread: false, + intentKind: "prompt", + hasPromptOrAttachment: true, + }), + ).toBe(true); + expect( + shouldShowThreadBootstrapReaction({ + inThread: false, + intentKind: "today-recap", + hasPromptOrAttachment: true, + }), + ).toBe(true); + }); + + it("does not mark existing threads, commands, or empty mentions", () => { + expect( + shouldShowThreadBootstrapReaction({ + inThread: true, + intentKind: "prompt", + hasPromptOrAttachment: true, + }), + ).toBe(false); + expect( + shouldShowThreadBootstrapReaction({ + inThread: false, + intentKind: "help", + hasPromptOrAttachment: true, + }), + ).toBe(false); + expect( + shouldShowThreadBootstrapReaction({ + inThread: false, + intentKind: "prompt", + hasPromptOrAttachment: false, + }), + ).toBe(false); + }); + + it("wires 👀 addition to channel intake and removal to initial-pin success", () => { + expect(mentionRouterSource).toContain( + ".addMyMessageReaction(\n pendingReadyReaction.channelId", + ); + expect(mentionRouterSource).toContain( + "Effect.tap(() =>\n input.pendingReadyReaction === undefined", + ); + expect(mentionRouterSource).toContain( + ".deleteMyMessageReaction(\n input.pendingReadyReaction.channelId", + ); + expect(mentionRouterSource).toContain("const discordThread = yield* openOrReuseThread("); + }); +}); + +describe("createHandledDiscordMessageTracker", () => { + it("marks handled messages and evicts the oldest ids beyond the limit", () => { + const tracker = createHandledDiscordMessageTracker(2); + + tracker.mark("message-1"); + tracker.mark("message-2"); + + expect(tracker.has("message-1")).toBe(true); + expect(tracker.has("message-2")).toBe(true); + + tracker.mark("message-3"); + + expect(tracker.has("message-1")).toBe(false); + expect(tracker.has("message-2")).toBe(true); + expect(tracker.has("message-3")).toBe(true); + }); + + it("claims a message id only once so create/update races cannot double-route", () => { + const tracker = createHandledDiscordMessageTracker(8); + + expect(tracker.claim("message-1")).toBe(true); + expect(tracker.claim("message-1")).toBe(false); + expect(tracker.has("message-1")).toBe(true); + + tracker.mark("message-2"); + expect(tracker.claim("message-2")).toBe(false); + }); +}); + +describe("makeDiscordMessageDispatchQueue", () => { + effectIt.effect("keeps same-channel events FIFO while other channels remain independent", () => + Effect.scoped( + Effect.gen(function* () { + const queue = yield* makeDiscordMessageDispatchQueue(); + const releaseFirst = yield* Deferred.make(); + const firstStarted = yield* Deferred.make(); + const handled = yield* Ref.make>([]); + const record = (value: string) => Ref.update(handled, (values) => [...values, value]); + + yield* queue.enqueue({ + channelId: "channel-a", + handle: Deferred.succeed(firstStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseFirst)), + Effect.andThen(record("first")), + ), + }); + yield* Deferred.await(firstStarted); + yield* queue.enqueue({ channelId: "channel-a", handle: record("second") }); + yield* queue.enqueue({ channelId: "channel-b", handle: record("other-channel") }); + yield* queue.drainKey("channel-b"); + + expect(yield* Ref.get(handled)).toEqual(["other-channel"]); + + yield* Deferred.succeed(releaseFirst, undefined); + yield* queue.drainKey("channel-a"); + expect(yield* Ref.get(handled)).toEqual(["other-channel", "first", "second"]); + }), + ), + ); + + effectIt.effect("retries transient failures without allowing overtaking", () => + Effect.scoped( + Effect.gen(function* () { + const queue = yield* makeDiscordMessageDispatchQueue([0, 0]); + const attempts = yield* Ref.make(0); + const handled = yield* Ref.make>([]); + const transient = { reason: { _tag: "TransportError" } }; + + yield* queue.enqueue({ + channelId: "channel-a", + handle: Ref.updateAndGet(attempts, (value) => value + 1).pipe( + Effect.flatMap((attempt) => + attempt < 3 ? Effect.fail(transient) : Ref.update(handled, (v) => [...v, "first"]), + ), + ), + }); + yield* queue.enqueue({ + channelId: "channel-a", + handle: Ref.update(handled, (values) => [...values, "second"]), + }); + yield* queue.drainKey("channel-a"); + + expect(yield* Ref.get(attempts)).toBe(3); + expect(yield* Ref.get(handled)).toEqual(["first", "second"]); + }), + ), + ); + + effectIt.effect("drops a permanent failure and continues the channel queue", () => + Effect.scoped( + Effect.gen(function* () { + const queue = yield* makeDiscordMessageDispatchQueue([0, 0]); + const handled = yield* Ref.make>([]); + + yield* queue.enqueue({ + channelId: "channel-a", + handle: Effect.fail({ _tag: "ErrorResponse", response: { status: 404 } }), + }); + yield* queue.enqueue({ + channelId: "channel-a", + handle: Ref.update(handled, (values) => [...values, "after-deletion"]), + }); + yield* queue.drainKey("channel-a"); + + expect(yield* Ref.get(handled)).toEqual(["after-deletion"]); + }), + ), + ); + + effectIt.effect("contains defects so they cannot strand later channel work", () => + Effect.scoped( + Effect.gen(function* () { + const queue = yield* makeDiscordMessageDispatchQueue([]); + const handled = yield* Ref.make(false); + yield* queue.enqueue({ channelId: "channel-a", handle: Effect.die("broken handler") }); + yield* queue.enqueue({ channelId: "channel-a", handle: Ref.set(handled, true) }); + yield* queue.drainKey("channel-a"); + expect(yield* Ref.get(handled)).toBe(true); + }), + ), + ); +}); + +describe("isTransientDiscordDispatchError", () => { + it("distinguishes retryable transport/server errors from permanent Discord responses", () => { + expect(isTransientDiscordDispatchError({ reason: { _tag: "TransportError" } })).toBe(true); + expect(isTransientDiscordDispatchError({ response: { status: 503 } })).toBe(true); + expect(isTransientDiscordDispatchError({ _tag: "RatelimitedResponse" })).toBe(true); + expect( + isTransientDiscordDispatchError({ _tag: "ErrorResponse", response: { status: 404 } }), + ).toBe(false); + expect( + isTransientDiscordDispatchError({ _tag: "ErrorResponse", response: { status: 403 } }), + ).toBe(false); + }); +}); + +describe("retryTransientDiscordOperation", () => { + effectIt.effect("replays a transient operation but never replays a permanent one", () => + Effect.gen(function* () { + const transientAttempts = yield* Ref.make(0); + const value = yield* retryTransientDiscordOperation( + Ref.updateAndGet(transientAttempts, (attempt) => attempt + 1).pipe( + Effect.flatMap((attempt) => + attempt === 1 + ? Effect.fail({ response: { status: 503 } }) + : Effect.succeed("recovered"), + ), + ), + [0], + ); + expect(value).toBe("recovered"); + expect(yield* Ref.get(transientAttempts)).toBe(2); + + const permanentAttempts = yield* Ref.make(0); + yield* retryTransientDiscordOperation( + Ref.update(permanentAttempts, (attempt) => attempt + 1).pipe( + Effect.andThen(Effect.fail({ response: { status: 404 } })), + ), + [0, 0], + ).pipe(Effect.flip); + expect(yield* Ref.get(permanentAttempts)).toBe(1); + }), + ); +}); + +describe("isIncompleteDiscordLink", () => { + it("is incomplete when the thread-info pin was never stored", () => { + expect(isIncompleteDiscordLink({})).toBe(true); + expect(isIncompleteDiscordLink({ infoDiscordMessageId: undefined })).toBe(true); + expect(isIncompleteDiscordLink({ infoDiscordMessageId: "" })).toBe(true); + }); + + it("is complete when a pin message id exists", () => { + expect(isIncompleteDiscordLink({ infoDiscordMessageId: "msg-1" })).toBe(false); + }); +}); + +it("reuses a Discord link for the same canonical worktree", () => { + const linkedThreadId = ThreadId.make("linked-thread"); + const targetThreadId = ThreadId.make("github-thread"); + const link = { + discordThreadId: "discord-thread", + t3ThreadId: linkedThreadId, + projectId: ProjectId.make("project"), + channelId: "channel", + guildId: "guild", + createdAt: "2026-07-19T00:00:00.000Z", + updatedAt: "2026-07-19T00:00:00.000Z", + lastActivityAt: "2026-07-19T00:00:00.000Z", + status: "active" as const, + lastSeenTurnId: null, + lastFinalizedAssistantId: null, + lastThreadSnapshotSequence: null, + lastDeliveredSequence: null, + }; + expect( + findDiscordLinkForT3Target({ + links: [link], + threads: [ + { id: linkedThreadId, worktreePath: "/Worktrees/PR-42/" }, + { id: targetThreadId, worktreePath: "/worktrees/pr-42" }, + ], + target: { id: targetThreadId, worktreePath: "/worktrees/pr-42" }, + }), + ).toBe(link); +}); + +describe("getContinuedConversationModelChangeError", () => { + const providers = [ + { + driver: ProviderDriverKind.make("codex"), + instanceId: ProviderInstanceId.make("codex"), + }, + { + driver: ProviderDriverKind.make("claudeAgent"), + instanceId: ProviderInstanceId.make("claudeAgent"), + }, + { + driver: ProviderDriverKind.make("grok"), + instanceId: ProviderInstanceId.make("grok"), + requiresNewThreadForModelChange: true, + }, + ]; + + it("allows switching models mid-conversation within the same provider", () => { + expect( + getContinuedConversationModelChangeError({ + providers, + currentModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + nextModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.5", + }, + }), + ).toBeNull(); + }); + + it("rejects switching providers mid-conversation", () => { + expect( + getContinuedConversationModelChangeError({ + providers, + currentModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + nextModelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "claude-opus-4-6", + }, + }), + ).toContain("within the same provider"); + }); + + it("rejects Grok model switches mid-conversation", () => { + expect( + getContinuedConversationModelChangeError({ + providers, + currentModelSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + nextModelSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-other", + }, + }), + ).toContain("does not allow switching models"); + }); +}); diff --git a/apps/discord-bot/src/features/MentionRouter.ts b/apps/discord-bot/src/features/MentionRouter.ts new file mode 100644 index 000000000000..e75d27e6e615 --- /dev/null +++ b/apps/discord-bot/src/features/MentionRouter.ts @@ -0,0 +1,4292 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectContext:off globalDate:off globalErrorInEffectFailure:off outdatedApi:off globalFetchInEffect:off +import { + MessageId, + type ModelSelection, + type OrchestrationThread, + type ServerProvider, + type ThreadId, + type UploadChatAttachment, +} from "@t3tools/contracts"; +import { DISCORD_LINK_REQUEST_MARKER } from "@t3tools/shared/providerModelSelection"; +import { makeKeyedDrainableWorker } from "@t3tools/shared/KeyedDrainableWorker"; +import { Discord, DiscordREST, Ix } from "dfx"; +import { DiscordGateway, InteractionsRegistry } from "dfx/gateway"; +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Result from "effect/Result"; +import * as Schema from "effect/Schema"; + +export interface DiscordMessageDispatch { + readonly channelId: string; + readonly handle: Effect.Effect; +} + +const DISCORD_MESSAGE_RETRY_DELAYS_MS = [250, 1_000, 3_000] as const; + +function errorRecord(error: unknown): Readonly> | null { + return typeof error === "object" && error !== null + ? (error as Readonly>) + : null; +} + +/** Retry transport failures and retryable HTTP responses, never deleted/forbidden resources. */ +export function isTransientDiscordDispatchError(error: unknown): boolean { + const outer = errorRecord(error); + if (outer === null) return false; + if (outer._tag === "RatelimitedResponse") return true; + + const reason = errorRecord(outer.reason); + if (reason?._tag === "RequestError" || reason?._tag === "TransportError") return true; + + const response = errorRecord(outer.response) ?? errorRecord(reason?.response); + const status = response?.status; + return ( + typeof status === "number" && + (status === 408 || status === 425 || status === 429 || status >= 500) + ); +} + +export function retryTransientDiscordOperation( + handle: Effect.Effect, + retryDelaysMs: ReadonlyArray, + attempt = 0, +): Effect.Effect { + return handle.pipe( + Effect.catch((error) => + isTransientDiscordDispatchError(error) && attempt < retryDelaysMs.length + ? Effect.sleep(`${retryDelaysMs[attempt] ?? 0} millis`).pipe( + Effect.andThen(retryTransientDiscordOperation(handle, retryDelaysMs, attempt + 1)), + ) + : Effect.fail(error), + ), + ); +} + +/** + * Discord's gateway dispatches events concurrently. Serialize the complete + * message lifecycle per channel so slower hydration for an earlier message + * cannot let a later create, update, or delete overtake it. + */ +export const makeDiscordMessageDispatchQueue = ( + retryDelaysMs: ReadonlyArray = DISCORD_MESSAGE_RETRY_DELAYS_MS, +) => + makeKeyedDrainableWorker({ + key: (dispatch) => dispatch.channelId, + process: (dispatch) => + retryTransientDiscordOperation(dispatch.handle, retryDelaysMs).pipe( + Effect.catchCause((cause) => + Effect.logError("Discord message dispatch failed; continuing channel queue", { + channelId: dispatch.channelId, + cause, + }), + ), + ), + }); + +import type { DiscordBotConfig } from "../config.ts"; +import { + appendDiscordAttachmentPromptBlock, + ATTACHMENT_ONLY_PROMPT, + downloadDiscordAttachmentsToWorkspace, +} from "../presentation/discordInboundFiles.ts"; +import { + downloadDiscordImagesAsUploadAttachments, + filterDiscordImageAttachments, + IMAGE_ONLY_PROMPT, + type DiscordInboundAttachment, +} from "../presentation/discordInboundImages.ts"; +import { + bridgedTurnTopicResolutionError, + missingProjectBindingMessage, + parseMentionFlags, + parseMentionIntent, + parseTopicShortName, + projectTopicFromParentLookup, + normalizeWorkspacePath, + resolveDiscordFollowUpDelivery, + shouldPostWorkingAckForContinue, + type ProjectTopicLookup, +} from "../presentation/mentions.ts"; +import { + extractJiraIssueKeysFromDiscordMessage, + jiraIssueKeysAfterExcludingSentryFalsePositives, + jiraIssueKeysMaskedBySentryFromMessages, +} from "../presentation/jiraLinks.ts"; +import { extractPullRequestUrlsFromDiscordMessage } from "../presentation/prLinks.ts"; +import { + extractSentryIssueUrlsFromDiscordMessage, + mergeSentryIssueUrls, +} from "../presentation/sentryLinks.ts"; +import { isThreadInfoPinContent } from "../presentation/threadInfoPin.ts"; +import { + resolveUniqueT3ThreadIdForWorkItems, + serverWorkItemsPathFromStateSqlite, +} from "../store/ServerWorkItemJoin.ts"; +import { + assignPullRequestAssignees, + formatAssignSlashReply, + resolveAssignGithubLogin, +} from "../presentation/prAssign.ts"; +import { + idleMessageFields, + stripBotMention, + truncateTitle, + turnContinueCustomId, + turnStopCustomId, + workingMessageFields, +} from "../presentation/messages.ts"; +import { + COMPACT_POLL_INTERVAL_MS, + COMPACT_WAIT_TIMEOUT_MS, + extractLatestContextWindowStats, + formatCompactionStatsReply, + hasNewContextCompaction, +} from "../presentation/compactContext.ts"; +import { + formatAskSlashAck, + isThreadTalkSlashAction, + OMEGENT_SLASH_COMMAND, + OMEGENT_SLASH_COMMAND_ALIAS, + OMEGENT_SLASH_COMMAND_NAME, + slashDefer, + slashReply, + threadTalkSlashReply, +} from "../presentation/slashCommands.ts"; +import { + buildTodayRecapPrompt, + chunkTodayRecapContent, + extractLatestAssistantText, + formatTodayRecapThreadTitle, + formatTodayRecapWorking, + TODAY_RECAP_TURN_POLL_MS, + TODAY_RECAP_TURN_TIMEOUT_MS, + utcDateStamp, +} from "../presentation/todayRecap.ts"; +import { extractT3ThreadId } from "../presentation/t3ThreadRef.ts"; +import { + buildDiscordTurnPrompt, + buildFirstTurnPrompt, + looksLikeSentryContext, + type DiscordMessageLike, +} from "../presentation/threadContext.ts"; +import { classifyDiscordAgentAccess, IdentityMapStore } from "../identityMap.ts"; +import { discordSourceHint } from "../t3/sourceHint.ts"; +import { ProjectAliasStore } from "../projectAliases.ts"; +import { type ThreadLink, ThreadLinkStore } from "../store/ThreadLinkStore.ts"; +import { newMessageId } from "../t3/ids.ts"; +import { + T3_CONNECT_WAIT_REACTION_EMOJI, + T3_STILL_CONNECTING_MESSAGE, + T3Session, + T3SessionError, +} from "../t3/T3Session.ts"; +import { formatAlertCause } from "./Alerts.ts"; +import { ensureChannelInfoPin } from "./ChannelInfoPin.ts"; +import { makeDiscordThreadTurnCoordinator } from "./DiscordThreadTurnCoordinator.ts"; +import { + createDiscordQueuedPromptRegistry, + formatSteernowEmptyQueueMessage, + QUEUED_PROMPT_REACTION_EMOJI, + resolveSteernowMessageIds, +} from "./DiscordQueuedPromptRegistry.ts"; +import { BridgeHub } from "./BridgeHub.ts"; +import { bridgeThreadToDiscord, getLiveDiscordBridge } from "./ResponseBridge.ts"; +import { upsertThreadInfoPin } from "./ThreadInfoPin.ts"; +import { + formatUnmentionedDiscordPrompt, + parseThreadTalkCommand, + threadTalkEnabled, +} from "./ThreadTalkPolicy.ts"; + +/** Marker service so the process must acquire the mention router layer. */ +export class DiscordBotRunning extends Context.Service< + DiscordBotRunning, + { readonly botUserId: string } +>()("@t3tools/discord-bot/features/MentionRouter/DiscordBotRunning") {} + +export const THREAD_BOOTSTRAP_REACTION_EMOJI = "👀"; + +export function shouldShowThreadBootstrapReaction(input: { + readonly inThread: boolean; + readonly intentKind: ReturnType["kind"]; + readonly hasPromptOrAttachment: boolean; +}): boolean { + return ( + !input.inThread && + (input.intentKind === "prompt" || input.intentKind === "today-recap") && + input.hasPromptOrAttachment + ); +} + +class DiscordImageDownloadError extends Schema.TaggedError()( + "DiscordImageDownloadError", + { cause: Schema.Defect() }, +) {} + +class DiscordAttachmentStageError extends Schema.TaggedError()( + "DiscordAttachmentStageError", + { cause: Schema.Defect() }, +) {} + +const MAX_HANDLED_MESSAGE_IDS = 2048; + +export function createHandledDiscordMessageTracker(limit = MAX_HANDLED_MESSAGE_IDS) { + const handled = new Set(); + const insertionOrder: string[] = []; + + const record = (messageId: string): boolean => { + if (handled.has(messageId)) return false; + handled.add(messageId); + insertionOrder.push(messageId); + while (insertionOrder.length > limit) { + const oldest = insertionOrder.shift(); + if (oldest !== undefined) handled.delete(oldest); + } + return true; + }; + + return { + has(messageId: string) { + return handled.has(messageId); + }, + /** Record that a message id was handled (idempotent). */ + mark(messageId: string) { + record(messageId); + }, + /** + * Atomically claim a Discord message id for routing. + * Returns false when another create/update path already claimed it. + */ + claim(messageId: string) { + return record(messageId); + }, + }; +} + +function isThreadChannel(type: number | undefined): boolean { + return type === 10 || type === 11 || type === 12; +} + +function mentionsBotInContent(content: string, botUserId: string): boolean { + return content.includes(`<@${botUserId}>`) || content.includes(`<@!${botUserId}>`); +} + +function mentionsBotInEvent( + event: { + readonly content?: string | null; + readonly mentions?: ReadonlyArray<{ readonly id?: string }> | null; + }, + botUserId: string, +): boolean { + if (mentionsBotInContent(event.content ?? "", botUserId)) return true; + return event.mentions?.some((user) => user.id === botUserId) ?? false; +} + +function discordMessageFromEvent(event: { + readonly id: string; + readonly content?: string | null | undefined; + readonly channel_id?: string | undefined; + readonly author?: + | { + readonly id?: string | undefined; + readonly username?: string | undefined; + readonly global_name?: string | null | undefined; + readonly bot?: boolean | undefined; + } + | undefined; + readonly member?: { readonly nick?: string | null | undefined } | undefined; + readonly embeds?: DiscordMessageLike["embeds"]; + readonly timestamp?: string | undefined; +}): DiscordMessageLike { + return { + id: event.id, + content: event.content, + author: { + id: event.author?.id, + username: event.author?.username, + displayName: + event.member?.nick ?? event.author?.global_name ?? event.author?.username ?? undefined, + bot: event.author?.bot, + }, + embeds: event.embeds, + timestamp: event.timestamp, + ...(typeof event.channel_id === "string" ? { channelId: event.channel_id } : {}), + }; +} + +function hasInterruptibleTurn( + thread: { + readonly latestTurn?: { readonly state?: string | null } | null; + readonly session?: { readonly status?: string | null } | null; + } | null, +): boolean { + return ( + thread?.latestTurn?.state === "running" || + thread?.session?.status === "running" || + thread?.session?.status === "starting" + ); +} + +function discordMessageUrl( + guildId: string | null | undefined, + channelId: string, + messageId: string, +): string { + return `https://discord.com/channels/${guildId ?? "@me"}/${channelId}/${messageId}`; +} + +type DiscordMessagePayload = { + readonly id: string; + readonly content?: string | null | undefined; + readonly channel_id?: string | undefined; + readonly author?: + | { + readonly id?: string | undefined; + readonly username?: string | undefined; + readonly global_name?: string | null | undefined; + readonly bot?: boolean | undefined; + } + | undefined; + readonly member?: { readonly nick?: string | null | undefined } | undefined; + readonly embeds?: DiscordMessageLike["embeds"]; + readonly timestamp?: string | undefined; +}; + +/** + * Resolve the message the user replied to / referenced. + * Gateway often includes `referenced_message` for REPLY; otherwise fetch via REST + * using `message_reference` so Sentry embeds and other context reach the agent. + */ +function resolveReferencedMessage(input: { + readonly event: { + readonly channel_id: string; + readonly guild_id?: string | null | undefined; + readonly referenced_message?: DiscordMessagePayload | null | undefined; + readonly message_reference?: + | { + readonly message_id?: string | null | undefined; + readonly channel_id?: string | null | undefined; + readonly guild_id?: string | null | undefined; + } + | null + | undefined; + }; + readonly rest: { + // Discord REST message shape is wider than DiscordMessagePayload; map at the boundary. + readonly getMessage: ( + channelId: string, + messageId: string, + ) => Effect.Effect; + }; +}): Effect.Effect<{ message: DiscordMessageLike; url: string } | null> { + return Effect.gen(function* () { + const gatewayRef = input.event.referenced_message; + if (gatewayRef !== null && gatewayRef !== undefined && typeof gatewayRef.id === "string") { + const channelId = + typeof gatewayRef.channel_id === "string" + ? gatewayRef.channel_id + : (input.event.message_reference?.channel_id ?? input.event.channel_id); + const guildId = input.event.message_reference?.guild_id ?? input.event.guild_id ?? null; + return { + message: discordMessageFromEvent({ + ...gatewayRef, + channel_id: channelId, + }), + url: discordMessageUrl(guildId, channelId, gatewayRef.id), + }; + } + + const refId = input.event.message_reference?.message_id; + if (refId === null || refId === undefined || refId === "") { + return null; + } + const channelId = input.event.message_reference?.channel_id ?? input.event.channel_id; + const guildId = input.event.message_reference?.guild_id ?? input.event.guild_id ?? null; + const fetched = yield* input.rest.getMessage(channelId, refId).pipe( + Effect.map((message): DiscordMessageLike => + discordMessageFromEvent({ + ...message, + channel_id: typeof message.channel_id === "string" ? message.channel_id : channelId, + }), + ), + Effect.catch((error) => + Effect.logWarning("Failed to fetch referenced Discord message", { + channelId, + messageId: refId, + error: String(error), + }).pipe(Effect.as(null as DiscordMessageLike | null)), + ), + ); + if (fetched === null) return null; + return { + message: fetched, + url: discordMessageUrl(guildId, channelId, refId), + }; + }); +} + +function discordChannelUrl(guildId: string | null | undefined, channelId: string): string { + return `https://discord.com/channels/${guildId ?? "@me"}/${channelId}`; +} + +function t3WebThreadUrl(webUiBaseUrl: string | undefined, threadId: string): string | null { + if (webUiBaseUrl === undefined) return null; + return `${webUiBaseUrl.replace(/\/$/u, "")}/?thread=${threadId}`; +} + +function jiraKeysFromMessages( + ...messages: ReadonlyArray< + DiscordMessageLike | null | undefined | { readonly content?: string | null } + > +): ReadonlyArray { + const keys: string[] = []; + for (const message of messages) { + if (message === null || message === undefined) continue; + if (isThreadInfoPinContent(message.content ?? null)) continue; + keys.push(...extractJiraIssueKeysFromDiscordMessage(message)); + } + return keys; +} + +function sentryUrlsFromMessages( + ...messages: ReadonlyArray< + DiscordMessageLike | null | undefined | { readonly content?: string | null } + > +): ReadonlyArray { + const urls: string[] = []; + for (const message of messages) { + if (message === null || message === undefined) continue; + if (isThreadInfoPinContent(message.content ?? null)) continue; + urls.push(...extractSentryIssueUrlsFromDiscordMessage(message)); + } + return urls; +} + +function prUrlsFromMessages( + ...messages: ReadonlyArray< + DiscordMessageLike | null | undefined | { readonly content?: string | null } + > +): ReadonlyArray { + const urls: string[] = []; + for (const message of messages) { + if (message === null || message === undefined) continue; + urls.push(...extractPullRequestUrlsFromDiscordMessage(message)); + } + return urls; +} + +export function findDiscordLinkForT3Target(input: { + readonly links: ReadonlyArray; + readonly threads: ReadonlyArray<{ + readonly id: ThreadId; + readonly worktreePath: string | null; + }>; + readonly target: { readonly id: ThreadId; readonly worktreePath: string | null }; +}): ThreadLink | undefined { + const direct = input.links.find((link) => link.t3ThreadId === input.target.id); + if (direct !== undefined || input.target.worktreePath === null) return direct; + const targetWorktree = normalizeWorkspacePath(input.target.worktreePath); + return input.links.find((link) => { + const linkedThread = input.threads.find((thread) => thread.id === link.t3ThreadId); + return ( + linkedThread?.worktreePath !== null && + linkedThread?.worktreePath !== undefined && + normalizeWorkspacePath(linkedThread.worktreePath) === targetWorktree + ); + }); +} + +/** + * Durable link exists but setup never finished (e.g. slash `/link` died after + * `links.put` before bridge/pin). Re-link / re-attach should complete setup. + * + * Detected via missing thread-info pin id — not snapshot sequence (idle links + * often keep a null sequence until the first live bridge snapshot). + */ +export function isIncompleteDiscordLink(link: { + readonly infoDiscordMessageId?: string | undefined; +}): boolean { + return link.infoDiscordMessageId === undefined || link.infoDiscordMessageId.length === 0; +} + +/** + * `@Omegent` in Discord is ambiguous: it can resolve to the bot USER (`<@id>`) or to the + * app's managed ROLE (`<@&id>`), which render near-identically in the picker. Only the + * user form populates `mentions`, so a role ping used to be silently ignored. + * + * We match ONLY the app's own managed role -- the one Discord auto-creates, identified by + * `tags.bot_id === botUserId`. Matching any role the bot merely belongs to would make it + * respond to every `@engineers` message, which is much worse than the original bug. + */ +function botManagedRoleIdFrom( + roles: ReadonlyArray<{ + readonly id?: string; + readonly tags?: { readonly bot_id?: string | undefined } | null | undefined; + }>, + botUserId: string, +): string | null { + return roles.find((role) => role.tags?.bot_id === botUserId)?.id ?? null; +} + +export function getContinuedConversationModelChangeError(input: { + readonly providers: ReadonlyArray< + Pick + >; + readonly currentModelSelection: ModelSelection; + readonly nextModelSelection: ModelSelection; +}): string | null { + if ( + input.currentModelSelection.instanceId === input.nextModelSelection.instanceId && + input.currentModelSelection.model === input.nextModelSelection.model + ) { + return null; + } + + const currentProvider = input.providers.find( + (provider) => provider.instanceId === input.currentModelSelection.instanceId, + ); + const nextProvider = input.providers.find( + (provider) => provider.instanceId === input.nextModelSelection.instanceId, + ); + + if ( + currentProvider?.driver !== undefined && + nextProvider?.driver !== undefined && + currentProvider.driver !== nextProvider.driver + ) { + return "This Discord conversation can only switch models within the same provider. Start a new Discord thread to switch providers."; + } + + if ( + currentProvider?.requiresNewThreadForModelChange === true || + nextProvider?.requiresNewThreadForModelChange === true + ) { + return "This provider does not allow switching models after the conversation has started. Start a new Discord thread to use that model."; + } + + return null; +} + +type BridgedTurnInput = { + readonly discordThreadId: string; + readonly channelId: string; + readonly guildId: string; + readonly prompt: string; + readonly flags: ReturnType; + readonly topic: string | null | undefined; + /** True when parent-channel topic could not be fetched (Discord outage / API error). */ + readonly parentUnavailable?: boolean; + readonly parentChannelId: string | null; + readonly mentionMessage?: DiscordMessageLike; + /** Message the user replied to when addressing the bot (gateway or REST). */ + readonly referencedMessage?: DiscordMessageLike | null; + readonly referencedMessageUrl?: string; + readonly discordAttachments?: ReadonlyArray; + readonly attachments?: ReadonlyArray; + readonly presentationMode?: "full" | "final-only"; + /** Original channel mention carrying 👀 until the linked thread-info pin is ready. */ + readonly pendingReadyReaction?: { + readonly channelId: string; + readonly messageId: string; + }; +}; + +const make = (botConfig: DiscordBotConfig) => + Effect.gen(function* () { + const gateway = yield* DiscordGateway; + const rest = yield* DiscordREST; + const t3 = yield* T3Session; + const links = yield* ThreadLinkStore; + const aliases = yield* ProjectAliasStore; + const identityMap = yield* IdentityMapStore; + const registry = yield* InteractionsRegistry; + const bridgeHub = yield* BridgeHub; + const turnCoordinator = yield* makeDiscordThreadTurnCoordinator; + const queuedPrompts = createDiscordQueuedPromptRegistry(); + + const markDiscordPromptQueued = (input: { + readonly discordChannelId: string; + readonly discordMessageId: string; + readonly t3ThreadId: ThreadId; + readonly t3MessageId: MessageId; + readonly authorUserId: string | null; + }) => + Effect.gen(function* () { + queuedPrompts.remember(input); + yield* rest + .addMyMessageReaction( + input.discordChannelId, + input.discordMessageId, + QUEUED_PROMPT_REACTION_EMOJI, + ) + .pipe( + (operation) => + retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.catch((error) => + Effect.logWarning("Failed to add queued badge reaction", { + discordMessageId: input.discordMessageId, + error: String(error), + }), + ), + ); + }); + + const clearQueuedBadge = (entry: { + readonly discordChannelId: string; + readonly discordMessageId: string; + }) => + rest + .deleteMyMessageReaction( + entry.discordChannelId, + entry.discordMessageId, + QUEUED_PROMPT_REACTION_EMOJI, + ) + .pipe( + (operation) => retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.catch(() => Effect.void), + ); + + // Mentions use the bot *user* id, not the application id. + const me = yield* rest.getMyUser(); + const botUserId = me.id; + yield* Effect.logInfo("Discord bot identity", { + botUserId, + username: me.username, + }); + + // Prove the sharder is alive (non-empty after READY). + yield* Effect.forkScoped( + Effect.gen(function* () { + yield* Effect.sleep("3 seconds"); + const shards = yield* gateway.shards; + yield* Effect.logInfo("Discord shard status", { + shardCount: shards.size, + }); + }), + ); + + /** + * Retry briefly on transient Discord REST failures (outages, 5xx, rate-limit blips). + * Three attempts with short backoff (~200ms, ~400ms) before treating the parent as unavailable. + */ + const getChannelWithRetry = (channelId: string) => + Effect.gen(function* () { + let lastFailure: unknown; + for (let attempt = 0; attempt < 3; attempt += 1) { + const result = yield* rest.getChannel(channelId).pipe(Effect.result); + if (Result.isSuccess(result)) return result.success; + lastFailure = result.failure; + if (attempt < 2) { + yield* Effect.sleep(`${200 * (attempt + 1)} millis` as const); + } + } + return yield* Effect.fail(lastFailure); + }); + + /** + * Resolve project-binding topic for a channel or thread. + * Retries parent GET; never confuses a failed parent fetch with a missing `t3-*` tag. + */ + const resolveProjectTopic = (channel: { + readonly type?: number | undefined; + readonly parent_id?: string | null | undefined; + readonly topic?: string | null | undefined; + }): Effect.Effect => + Effect.gen(function* () { + const inThread = isThreadChannel(channel.type); + const parentId = + inThread && typeof channel.parent_id === "string" ? channel.parent_id : null; + if (parentId === null) { + return projectTopicFromParentLookup({ + channel, + parentId: null, + parent: null, + }); + } + const parentResult = yield* getChannelWithRetry(parentId).pipe(Effect.result); + if (Result.isFailure(parentResult)) { + const cause = String(parentResult.failure); + yield* Effect.logWarning("Failed to fetch parent channel for project topic", { + parentId, + cause, + }); + return projectTopicFromParentLookup({ + channel, + parentId, + parent: { ok: false, cause }, + }); + } + return projectTopicFromParentLookup({ + channel, + parentId, + parent: { ok: true, channel: parentResult.success }, + }); + }); + + /** + * Park inbound work until T3 has a live shell (boot / post-restart reconnect). + * Reacts with ⏳ on the triggering Discord message so the human sees the queue + * instead of a "try again later" bounce. + */ + const waitForT3ReadyForInbound = (input: { + readonly discordChannelId: string; + readonly discordMessageId?: string; + readonly reason: string; + }) => + Effect.gen(function* () { + const ready = yield* t3.isReady(); + if (ready) return; + + const messageId = input.discordMessageId; + if (messageId !== undefined && messageId.length > 0) { + yield* rest + .addMyMessageReaction(input.discordChannelId, messageId, T3_CONNECT_WAIT_REACTION_EMOJI) + .pipe( + Effect.catch((error) => + Effect.logWarning("Failed to add T3 connect-wait reaction", { + discordChannelId: input.discordChannelId, + discordMessageId: messageId, + error: String(error), + }), + ), + ); + } + + yield* Effect.logInfo("Queuing Discord work until T3 is ready", { + discordChannelId: input.discordChannelId, + discordMessageId: messageId ?? null, + reason: input.reason, + }); + + yield* t3.waitUntilReady().pipe( + Effect.tapError((error) => + Effect.logWarning("Timed out waiting for T3 readiness", { + discordChannelId: input.discordChannelId, + reason: input.reason, + error: String(error), + }), + ), + ); + + if (messageId !== undefined && messageId.length > 0) { + yield* rest + .deleteMyMessageReaction( + input.discordChannelId, + messageId, + T3_CONNECT_WAIT_REACTION_EMOJI, + ) + .pipe( + Effect.catch((error) => + Effect.logWarning("Failed to clear T3 connect-wait reaction", { + discordChannelId: input.discordChannelId, + discordMessageId: messageId, + error: String(error), + }), + ), + ); + } + }); + + const resolveProjectFromTopic = (topic: string | null | undefined) => + Effect.gen(function* () { + const shortName = parseTopicShortName(topic); + if (shortName === null) { + return yield* Effect.fail("Channel topic has no t3- tag." as const); + } + const alias = aliases.resolve(shortName); + if (alias === null) { + return yield* Effect.fail( + `Unknown project alias '${shortName}'. Add it to the bot aliases file (T3_PROJECT_ALIASES_PATH).` as const, + ); + } + let project = yield* t3.findProjectByWorkspaceRoot(alias.workspaceRoot); + if (project === null) { + const ready = yield* t3.isReady(); + if (!ready) { + // Wait for shell fill / reconnect, then re-resolve the alias once. + // Map the session error to a string so topic-resolution stays string-typed. + const waited = yield* t3.waitUntilReady().pipe(Effect.result); + if (Result.isFailure(waited)) { + return yield* Effect.fail(T3_STILL_CONNECTING_MESSAGE); + } + project = yield* t3.findProjectByWorkspaceRoot(alias.workspaceRoot); + } + } + if (project === null) { + return yield* Effect.fail( + `No T3 project registered at ${alias.workspaceRoot} (alias '${shortName}'). Add the project in T3 first.` as const, + ); + } + return { shortName, alias, project }; + }); + + const refreshChannelInfoPin = (channelId: string, topic: string | null | undefined) => + Effect.gen(function* () { + const shortName = parseTopicShortName(topic); + if (shortName === null) return null; + const alias = aliases.resolve(shortName); + if (alias === null) return null; + const project = yield* t3.findProjectByWorkspaceRoot(alias.workspaceRoot); + const serverConfig = yield* t3.serverConfig(); + return yield* ensureChannelInfoPin({ + channelId, + workspaceRoot: alias.workspaceRoot, + providers: serverConfig?.providers ?? [], + projectDefaultModelSelection: project?.defaultModelSelection ?? null, + botConfig, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to refresh channel info pin", { + channelId, + shortName, + error: String(error), + }).pipe(Effect.as(null)), + ), + ); + }); + + /** Resolve project binding for slash/mention help with specific failure reasons. */ + const resolveHelpChannelBinding = (channelId: string, topic: string | null | undefined) => + Effect.gen(function* () { + const shortName = parseTopicShortName(topic); + if (shortName === null) { + return { + kind: "no-topic" as const, + }; + } + const alias = aliases.resolve(shortName); + if (alias === null) { + return { + kind: "unknown-alias" as const, + shortName, + }; + } + let project = yield* t3.findProjectByWorkspaceRoot(alias.workspaceRoot); + if (project === null) { + const ready = yield* t3.isReady(); + if (!ready) { + // Slash help must answer inside Discord's interaction window (no defer here). + // Wait only a short beat for shell race; otherwise report connecting. + const waited = yield* t3.waitUntilReady({ timeoutMs: 2_500 }).pipe(Effect.result); + if (Result.isFailure(waited)) { + return { + kind: "t3-connecting" as const, + shortName, + workspaceRoot: alias.workspaceRoot, + }; + } + project = yield* t3.findProjectByWorkspaceRoot(alias.workspaceRoot); + } + } + if (project === null) { + return { + kind: "no-project" as const, + shortName, + workspaceRoot: alias.workspaceRoot, + }; + } + const serverConfig = yield* t3.serverConfig(); + const pin = yield* ensureChannelInfoPin({ + channelId, + workspaceRoot: alias.workspaceRoot, + providers: serverConfig?.providers ?? [], + projectDefaultModelSelection: project.defaultModelSelection ?? null, + botConfig, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to refresh channel info pin", { + channelId, + shortName, + error: String(error), + }).pipe(Effect.as(null)), + ), + ); + if (pin === null) { + return { + kind: "pin-failed" as const, + shortName, + workspaceRoot: alias.workspaceRoot, + }; + } + return { + kind: "ok" as const, + shortName, + pin, + }; + }); + + /** + * Request provider context compact and wait briefly for token stats. + * Always returns a user-facing public reply (stats or error). + */ + const runContextCompact = (t3ThreadId: ThreadId) => + Effect.gen(function* () { + const beforeDetail = yield* t3.fetchThreadDetail(t3ThreadId); + const beforeActivities = beforeDetail?.thread.activities ?? []; + const before = extractLatestContextWindowStats(beforeActivities); + const beforeMarkerId = + before?.activityId ?? + (beforeActivities.length > 0 + ? (beforeActivities[beforeActivities.length - 1]?.id ?? null) + : null); + + yield* t3.compact(t3ThreadId); + + const startedAt = yield* Clock.currentTimeMillis; + let after = before; + let compacted = false; + while ((yield* Clock.currentTimeMillis) - startedAt < COMPACT_WAIT_TIMEOUT_MS) { + yield* Effect.sleep(`${COMPACT_POLL_INTERVAL_MS} millis`); + const detail = yield* t3.fetchThreadDetail(t3ThreadId); + const activities = detail?.thread.activities ?? []; + after = extractLatestContextWindowStats(activities) ?? after; + if ( + hasNewContextCompaction(activities, beforeMarkerId) || + (before !== null && after !== null && after.usedTokens < before.usedTokens) + ) { + compacted = true; + break; + } + } + + return formatCompactionStatsReply({ + before, + after, + compacted, + }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + formatCompactionStatsReply({ + before: null, + after: null, + compacted: false, + error: error instanceof Error ? error.message : String(error), + }), + ), + ), + ); + + /** + * For public threads created from a message, Discord uses the starter message id + * as the thread id. Prefer parent channel + thread id; fall back to oldest thread msgs. + */ + const loadThreadStarter = (input: { + readonly discordThreadId: string; + readonly parentChannelId: string | null; + /** When the mention itself started the thread, use it as starter. */ + readonly mentionMessage?: DiscordMessageLike; + }) => + Effect.gen(function* () { + if (input.parentChannelId !== null) { + const fromParent = yield* rest + .getMessage(input.parentChannelId, input.discordThreadId) + .pipe( + Effect.map((message): DiscordMessageLike => message), + Effect.orElseSucceed(() => null as DiscordMessageLike | null), + ); + if (fromParent !== null) return fromParent; + } + + const listed = yield* rest + .listMessages(input.discordThreadId, { limit: 5, after: "0" }) + .pipe(Effect.orElseSucceed(() => [] as ReadonlyArray)); + // listMessages returns newest-first by default; with after:0 we get oldest available. + const oldest = listed.at(-1) ?? listed[0]; + if (oldest !== undefined) return oldest; + + return input.mentionMessage ?? null; + }); + + const startBridgedTurnUnlocked = (input: BridgedTurnInput) => + Effect.gen(function* () { + // Fail-closed identity gate: empty map or unmapped requester → no agent turn. + // Applies to @mentions, slash /ask, and automatic thread-talk continues. + const access = classifyDiscordAgentAccess({ + people: identityMap.list(), + discordId: input.mentionMessage?.author?.id ?? null, + discordUsername: input.mentionMessage?.author?.username ?? null, + discordDisplayName: input.mentionMessage?.author?.displayName ?? null, + }); + if (!access.allowed) { + yield* Effect.logWarning("Rejected Discord agent turn from unmapped identity", { + discordThreadId: input.discordThreadId, + authorId: input.mentionMessage?.author?.id ?? null, + authorUsername: input.mentionMessage?.author?.username ?? null, + reason: access.reason, + }); + yield* rest.createMessage(input.discordThreadId, { + content: access.userMessage, + ...(typeof input.mentionMessage?.id === "string" + ? { message_reference: { message_id: input.mentionMessage.id } } + : {}), + }); + return; + } + + // Boot/reconnect race: Discord is often READY before guest T3 has a shell. + // Queue (wait) here instead of bouncing "try again in a few seconds". + yield* waitForT3ReadyForInbound({ + discordChannelId: input.discordThreadId, + ...(typeof input.mentionMessage?.id === "string" + ? { discordMessageId: input.mentionMessage.id } + : {}), + reason: "startBridgedTurn", + }); + + // Only --provider / --model count as an explicit model change. Bare mentions must + // NOT re-apply bot defaults (codex/gpt-5.4) on continue — Grok (and others) refuse + // mid-thread model switches with "cannot switch models after the conversation has started". + const hasExplicitModelFlags = + input.flags.provider !== undefined || input.flags.model !== undefined; + const attachments = input.attachments ?? []; + const parentUnavailable = input.parentUnavailable === true; + + let existing = yield* links.getByDiscordThreadId(input.discordThreadId); + + // First-time Discord channel: if Jira/PR work items already map to a unique T3 thread + // (Jira webhook create, GitHub bridge, or another Discord link), join that session + // instead of forking a second agent world. + if (existing === null) { + const joinStarter = yield* loadThreadStarter({ + discordThreadId: input.discordThreadId, + parentChannelId: input.parentChannelId, + ...(input.mentionMessage === undefined ? {} : { mentionMessage: input.mentionMessage }), + }); + const joinJiraKeys = jiraKeysFromMessages( + joinStarter, + input.mentionMessage, + input.referencedMessage, + { content: input.prompt }, + ); + const joinPrUrls = prUrlsFromMessages( + joinStarter, + input.mentionMessage, + input.referencedMessage, + { content: input.prompt }, + ); + if (joinJiraKeys.length > 0 || joinPrUrls.length > 0) { + const allLinks = yield* links.list(); + const joinThreadId = resolveUniqueT3ThreadIdForWorkItems({ + jiraIssueKeys: joinJiraKeys, + prUrls: joinPrUrls, + discordLinks: allLinks, + serverWorkItemsPath: serverWorkItemsPathFromStateSqlite(botConfig.stateSqlitePath), + }); + if (joinThreadId !== null) { + const joinShell = yield* t3.getThreadShell(joinThreadId); + if (joinShell !== null) { + yield* Effect.logInfo("Joining existing T3 thread via work-item identity", { + discordThreadId: input.discordThreadId, + t3ThreadId: joinThreadId, + jiraIssueKeys: joinJiraKeys, + prUrls: joinPrUrls, + }); + yield* links.put({ + discordThreadId: input.discordThreadId, + t3ThreadId: joinThreadId, + projectId: joinShell.projectId, + channelId: input.channelId, + guildId: input.guildId, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + sentDiscordUserMessageIds: [], + jiraIssueKeys: joinJiraKeys, + prUrls: joinPrUrls, + }); + existing = yield* links.getByDiscordThreadId(input.discordThreadId); + } + } + } + } + + // Topic is preferred; during Discord outages fall back to the project already on the + // Discord↔T3 link so continue turns still work instead of "no t3- tag". + const fromTopic = yield* resolveProjectFromTopic(input.topic).pipe(Effect.result); + const resolved = yield* Effect.gen(function* () { + if (Result.isSuccess(fromTopic)) return fromTopic.success; + + if (existing !== null) { + const project = yield* t3.getProjectShell(existing.projectId); + if (project !== null) { + yield* Effect.logWarning( + "Channel topic unavailable; continuing with project from existing Discord link", + { + discordThreadId: input.discordThreadId, + projectId: existing.projectId, + parentUnavailable, + topicError: fromTopic.failure, + }, + ); + return { + shortName: parseTopicShortName(input.topic) ?? "linked", + alias: { + shortName: parseTopicShortName(input.topic) ?? "linked", + workspaceRoot: project.workspaceRoot, + }, + project, + }; + } + } + + const error = bridgedTurnTopicResolutionError({ + topicError: fromTopic.failure, + parentUnavailable, + hasExistingLink: existing !== null, + recoveredFromLink: false, + }); + return yield* Effect.fail( + (error ?? fromTopic.failure) as typeof fromTopic.failure | string, + ); + }); + + if (existing !== null) { + const rest = yield* DiscordREST; + const currentThread = yield* t3.getThreadShell(existing.t3ThreadId); + const stagedFiles = yield* Effect.tryPromise({ + try: () => + downloadDiscordAttachmentsToWorkspace({ + attachments: input.discordAttachments ?? [], + discordThreadId: input.discordThreadId, + messageId: input.mentionMessage?.id ?? "message", + }), + catch: (cause) => new DiscordAttachmentStageError({ cause }), + }); + const promptWithAttachments = appendDiscordAttachmentPromptBlock({ + prompt: input.prompt, + attachments: stagedFiles.saved, + }); + // Re-load thread starter so co-author trailers stay available mid-thread. + const continueStarter = yield* loadThreadStarter({ + discordThreadId: input.discordThreadId, + parentChannelId: input.parentChannelId, + ...(input.mentionMessage === undefined ? {} : { mentionMessage: input.mentionMessage }), + }); + const continueWorkItemMessages = [ + continueStarter, + input.mentionMessage, + input.referencedMessage, + { content: input.prompt }, + ]; + // Re-inject durable thread Jira keys so later turns (e.g. create PR) still see them. + // Drop Sentry short ids that were previously stored as Jira (SCANNER-313 etc.). + const turnJiraIssueKeys = jiraIssueKeysAfterExcludingSentryFalsePositives( + existing.jiraIssueKeys, + jiraKeysFromMessages(...continueWorkItemMessages), + jiraIssueKeysMaskedBySentryFromMessages(continueWorkItemMessages), + ); + const turnSentryIssueUrls = mergeSentryIssueUrls( + existing.sentryIssueUrls, + sentryUrlsFromMessages(...continueWorkItemMessages), + ); + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: promptWithAttachments, + requester: input.mentionMessage, + starter: continueStarter, + referencedMessage: input.referencedMessage, + referencedMessageUrl: input.referencedMessageUrl, + jiraIssueKeys: turnJiraIssueKeys, + sentryIssueUrls: turnSentryIssueUrls, + jiraBrowseBaseUrl: botConfig.jiraBrowseBaseUrl, + guildId: input.guildId, + discordThreadId: input.discordThreadId, + t3ThreadId: existing.t3ThreadId, + webUiBaseUrl: botConfig.webUiBaseUrl, + }); + if (stagedFiles.skipped.length > 0) { + yield* Effect.logWarning("Skipped some Discord file attachments", { + skipped: stagedFiles.skipped, + }); + } + const turnAlreadyRunning = hasInterruptibleTurn(currentThread); + const followUpDelivery = resolveDiscordFollowUpDelivery(input.flags); + const liveBridge = yield* getLiveDiscordBridge( + input.discordThreadId, + existing.t3ThreadId, + ); + // Mid-turn follow-up on a live bridge: keep steering via startTurn, but do not + // post a fresh Working.. tip or restart the bridge (that used to freeze old + // stream messages as "stale" and drop mid-turn Discord history). + const reuseLiveBridge = turnAlreadyRunning && liveBridge !== null; + yield* links.touch(input.discordThreadId).pipe(Effect.ignore); + + yield* Effect.logInfo("Resolved existing Discord↔T3 thread link", { + discordThreadId: input.discordThreadId, + t3ThreadId: existing.t3ThreadId, + projectId: existing.projectId, + createdAt: existing.createdAt, + persistedTaskDiscordMessageId: existing.taskDiscordMessageId ?? null, + persistedStreamDiscordMessageIds: existing.streamDiscordMessageIds ?? [], + currentThreadTitle: currentThread?.title ?? null, + currentThreadSessionStatus: currentThread?.session?.status ?? null, + currentThreadTurnState: currentThread?.latestTurn?.state ?? null, + turnAlreadyRunning, + reuseLiveBridge, + }); + yield* Effect.logInfo("Continuing linked T3 thread", { + discordThreadId: input.discordThreadId, + t3ThreadId: existing.t3ThreadId, + explicitModelFlags: hasExplicitModelFlags, + imageAttachments: attachments.length, + stagedAttachments: stagedFiles.saved.length, + turnAlreadyRunning, + reuseLiveBridge, + }); + + // Interactive continues post a fresh Working.. tip, including mid-turn + // steers (live bridge adopts it: freezes the old tip, streams under the new + // one). Parked follow-ups must not — adopting would freeze the in-flight + // answer and the queued turn's final would replace it. + const workingAckMessageId = shouldPostWorkingAckForContinue({ + presentationMode: input.presentationMode, + turnAlreadyRunning, + followUpDelivery, + }) + ? yield* rest + .createMessage(input.discordThreadId, { + ...workingMessageFields("_Working.._", existing.t3ThreadId), + }) + .pipe( + Effect.map((msg) => msg.id as string), + Effect.tap((messageId) => + Effect.logInfo("Posted Working.. ack", { + messageId, + midTurnSteer: reuseLiveBridge, + }), + ), + Effect.result, + Effect.flatMap((result) => { + if (Result.isSuccess(result)) return Effect.succeed(result.success); + return Effect.logError("Failed to post Working.. ack").pipe( + Effect.andThen(Effect.logError(result.failure)), + Effect.as(null), + ); + }), + ) + : null; + const pendingDiscordUserMessageId = newMessageId(); + + // Ensure bridge (reuses live fiber for same thread; only restarts when needed). + yield* bridgeThreadToDiscord({ + discordChannelId: input.discordThreadId, + t3ThreadId: existing.t3ThreadId, + workingAckMessageId, + sentDiscordUserMessageIds: [pendingDiscordUserMessageId], + ...(input.presentationMode === undefined + ? {} + : { presentationMode: input.presentationMode }), + }); + yield* Effect.logInfo("Discord bridge ensure-started; dispatching startTurn", { + t3ThreadId: existing.t3ThreadId, + reuseLiveBridge, + }); + + // Omit modelSelection unless the user explicitly asked to switch — startTurn then + // keeps thread.modelSelection (see T3Session.startTurn). + const continueModelSelection = hasExplicitModelFlags + ? yield* t3.resolveModelSelection({ + project: resolved.project, + stickyModelSelection: currentThread?.modelSelection ?? null, + ...(input.flags.provider === undefined + ? {} + : { overrideInstanceId: input.flags.provider }), + ...(input.flags.model === undefined ? {} : { overrideModel: input.flags.model }), + }) + : undefined; + if (currentThread?.modelSelection !== undefined && continueModelSelection !== undefined) { + const serverConfig = yield* t3.serverConfig(); + const error = getContinuedConversationModelChangeError({ + providers: serverConfig?.providers ?? [], + currentModelSelection: currentThread.modelSelection, + nextModelSelection: continueModelSelection, + }); + if (error !== null) { + return yield* Effect.fail(new T3SessionError(error)); + } + } + + const startedTurn = yield* t3 + .startTurn({ + threadId: existing.t3ThreadId, + prompt, + messageId: pendingDiscordUserMessageId, + ...(continueModelSelection === undefined + ? {} + : { modelSelection: continueModelSelection }), + // Only --plan forces plan mode; bare mentions keep the thread's interaction mode. + ...(input.flags.plan ? { interactionMode: "plan" as const } : {}), + ...(attachments.length > 0 ? { attachments } : {}), + sourceHint: discordSourceHint({ + authorId: input.mentionMessage?.author?.id, + authorUsername: input.mentionMessage?.author?.username, + guildId: input.guildId, + channelId: input.channelId, + discordThreadId: input.discordThreadId, + }), + }) + .pipe( + Effect.tap(({ messageId }) => + Effect.gen(function* () { + yield* links.setSentDiscordUserMessageIds(input.discordThreadId, [ + ...(existing.sentDiscordUserMessageIds ?? []), + messageId, + pendingDiscordUserMessageId, + ]); + // Always feed the real (and optimistic) user message id into the live + // bridge. We seed a placeholder before startTurn so the bridge is ready + // immediately; if T3 returns a different id (or we only updated the + // durable store), the bridge would treat this Discord turn as external + // input, mirror it back, and freeze the Working tip under that post. + const bridge = + liveBridge ?? + (yield* getLiveDiscordBridge(input.discordThreadId, existing.t3ThreadId)); + if (bridge !== null) { + yield* bridge.noteSentUserMessageIds([messageId, pendingDiscordUserMessageId]); + } + }), + ), + ); + // Server parks busy-thread follow-ups. Default Discord policy is **queue** + // (badge with 📥; delete user message to remove; /omegent steernow to flush). + // `--steer` / `/omegent steer` inject immediately after startTurn. + const t3MessageId = MessageId.make(startedTurn.messageId); + if (followUpDelivery === "steer" && turnAlreadyRunning) { + const steered = yield* t3 + .steerQueuedMessage({ + threadId: existing.t3ThreadId, + messageId: t3MessageId, + }) + .pipe( + Effect.tap(() => + Effect.logInfo("Steered mid-turn Discord follow-up into active turn", { + t3ThreadId: existing.t3ThreadId, + messageId: startedTurn.messageId, + }), + ), + Effect.as(true), + Effect.catch((error) => + Effect.logWarning( + "Steer after startTurn failed; message may remain server-queued", + { + t3ThreadId: existing.t3ThreadId, + messageId: startedTurn.messageId, + error: String(error), + }, + ).pipe(Effect.as(false)), + ), + ); + // If steer raced pending turn-start (or similar), keep the Discord-side + // registry + 📥 badge so /omegent steernow can flush without waiting on + // a lagging HTTP thread snapshot. + if (!steered) { + const discordMessageId = + typeof input.mentionMessage?.id === "string" ? input.mentionMessage.id : null; + if (discordMessageId !== null) { + const authorUserId = + typeof input.mentionMessage?.author?.id === "string" + ? input.mentionMessage.author.id + : null; + yield* markDiscordPromptQueued({ + discordChannelId: input.discordThreadId, + discordMessageId, + t3ThreadId: existing.t3ThreadId, + t3MessageId, + authorUserId, + }); + } + } + } else if (followUpDelivery === "queue" && turnAlreadyRunning) { + const discordMessageId = + typeof input.mentionMessage?.id === "string" ? input.mentionMessage.id : null; + if (discordMessageId !== null) { + const authorUserId = + typeof input.mentionMessage?.author?.id === "string" + ? input.mentionMessage.author.id + : null; + yield* markDiscordPromptQueued({ + discordChannelId: input.discordThreadId, + discordMessageId, + t3ThreadId: existing.t3ThreadId, + t3MessageId, + authorUserId, + }); + } + } + yield* Effect.logInfo("startTurn dispatched", { + t3ThreadId: existing.t3ThreadId, + messageId: startedTurn.messageId, + followUpDelivery, + turnAlreadyRunning, + modelSelection: continueModelSelection + ? `${continueModelSelection.instanceId}/${continueModelSelection.model}` + : "thread-sticky", + imageAttachments: attachments.length, + stagedAttachments: stagedFiles.saved.length, + }); + + // Refresh pinned thread-info (model/worktree/Open in Omegent + newly mentioned Jira/PR links). + const continueShell = currentThread ?? (yield* t3.getThreadShell(existing.t3ThreadId)); + yield* upsertThreadInfoPin({ + discordThreadId: input.discordThreadId, + t3ThreadId: existing.t3ThreadId, + botConfig, + incomingJiraKeys: jiraKeysFromMessages(...continueWorkItemMessages), + dropJiraIssueKeys: jiraIssueKeysMaskedBySentryFromMessages(continueWorkItemMessages), + incomingSentryIssueUrls: sentryUrlsFromMessages(...continueWorkItemMessages), + incomingPrUrls: prUrlsFromMessages(...continueWorkItemMessages), + modelSelection: continueModelSelection ?? continueShell?.modelSelection ?? null, + worktreePath: continueShell?.worktreePath ?? null, + local: continueShell?.worktreePath === null, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to refresh thread info pin", { + discordThreadId: input.discordThreadId, + error: String(error), + }), + ), + ); + + return existing.t3ThreadId; + } + + // New Discord thread / first link: pick model from flags or bot defaults. + const modelSelection = yield* t3.resolveModelSelection({ + project: resolved.project, + ...(input.flags.provider === undefined + ? {} + : { overrideInstanceId: input.flags.provider }), + ...(input.flags.model === undefined ? {} : { overrideModel: input.flags.model }), + }); + + // First link into this Discord thread: pull starter; Sentry bootstrap only when relevant. + const starter = yield* loadThreadStarter({ + discordThreadId: input.discordThreadId, + parentChannelId: input.parentChannelId, + ...(input.mentionMessage === undefined ? {} : { mentionMessage: input.mentionMessage }), + }); + const stagedFiles = yield* Effect.tryPromise({ + try: () => + downloadDiscordAttachmentsToWorkspace({ + attachments: input.discordAttachments ?? [], + discordThreadId: input.discordThreadId, + messageId: input.mentionMessage?.id ?? "message", + }), + catch: (cause) => new DiscordAttachmentStageError({ cause }), + }); + const prompt = appendDiscordAttachmentPromptBlock({ + prompt: input.prompt, + attachments: stagedFiles.saved, + }); + if (stagedFiles.skipped.length > 0) { + yield* Effect.logWarning("Skipped some Discord file attachments", { + skipped: stagedFiles.skipped, + }); + } + + const sentryBootstrap = looksLikeSentryContext({ + starter, + mentionPrompt: prompt, + referencedMessage: input.referencedMessage, + }); + const firstTurnWorkItemMessages = [ + starter, + input.mentionMessage, + input.referencedMessage, + { content: input.prompt }, + ]; + const firstTurnJiraIssueKeys = jiraKeysFromMessages(...firstTurnWorkItemMessages); + const firstTurnSentryIssueUrls = sentryUrlsFromMessages(...firstTurnWorkItemMessages); + const firstTurnSentryMaskedJira = + jiraIssueKeysMaskedBySentryFromMessages(firstTurnWorkItemMessages); + const enrichedPrompt = buildFirstTurnPrompt({ + starter, + mentionMessage: input.mentionMessage, + referencedMessage: input.referencedMessage, + referencedMessageUrl: input.referencedMessageUrl, + mentionPrompt: prompt, + projectShortName: resolved.shortName, + workspaceRoot: resolved.project.workspaceRoot, + honeycombTraceUrlTemplate: botConfig.honeycombTraceUrlTemplate, + jiraIssueKeys: firstTurnJiraIssueKeys, + sentryIssueUrls: firstTurnSentryIssueUrls, + jiraBrowseBaseUrl: botConfig.jiraBrowseBaseUrl, + guildId: input.guildId, + discordThreadId: input.discordThreadId, + }); + + yield* Effect.logInfo("Creating T3 thread with worktree bootstrap", { + shortName: resolved.shortName, + workspaceRoot: resolved.project.workspaceRoot, + model: `${modelSelection.instanceId}/${modelSelection.model}`, + hasStarterContext: starter !== null, + starterAuthor: starter?.author?.username ?? null, + hasReferencedMessage: input.referencedMessage != null, + referencedMessageId: input.referencedMessage?.id ?? null, + sentryBootstrap, + imageAttachments: attachments.length, + stagedAttachments: stagedFiles.saved.length, + }); + + const { threadId, messageId } = yield* t3.startTurnWithWorktree({ + project: resolved.project, + prompt: enrichedPrompt, + titleSeed: input.prompt, + modelSelection, + interactionMode: input.flags.plan ? "plan" : "default", + baseBranch: input.flags.base ?? botConfig.t3DefaultBaseBranch, + local: input.flags.local, + ...(attachments.length > 0 ? { attachments } : {}), + sourceHint: discordSourceHint({ + authorId: input.mentionMessage?.author?.id, + authorUsername: input.mentionMessage?.author?.username, + guildId: input.guildId, + channelId: input.channelId, + discordThreadId: input.discordThreadId, + }), + }); + yield* links.put({ + discordThreadId: input.discordThreadId, + t3ThreadId: threadId, + projectId: resolved.project.id, + channelId: input.channelId, + guildId: input.guildId, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + sentDiscordUserMessageIds: [messageId], + jiraIssueKeys: firstTurnJiraIssueKeys, + sentryIssueUrls: firstTurnSentryIssueUrls, + prUrls: prUrlsFromMessages(...firstTurnWorkItemMessages), + }); + yield* Effect.logInfo("Persisted new Discord↔T3 thread link", { + discordThreadId: input.discordThreadId, + t3ThreadId: threadId, + projectId: resolved.project.id, + channelId: input.channelId, + guildId: input.guildId, + }); + + // Post the bare thread-info pin before the first Working tip so Discord shows the + // pinned message first, but skip expensive repo lookups on this latency-sensitive + // path. A richer refresh still runs after the bridge starts. + yield* upsertThreadInfoPin({ + discordThreadId: input.discordThreadId, + t3ThreadId: threadId, + botConfig, + incomingJiraKeys: firstTurnJiraIssueKeys, + dropJiraIssueKeys: firstTurnSentryMaskedJira, + incomingSentryIssueUrls: firstTurnSentryIssueUrls, + incomingPrUrls: prUrlsFromMessages(...firstTurnWorkItemMessages), + modelSelection, + baseBranchLabel: input.flags.base ?? botConfig.t3DefaultBaseBranch, + local: input.flags.local, + skipChannelRepoLookup: true, + }).pipe( + Effect.tap(() => + input.pendingReadyReaction === undefined + ? Effect.void + : rest + .deleteMyMessageReaction( + input.pendingReadyReaction.channelId, + input.pendingReadyReaction.messageId, + THREAD_BOOTSTRAP_REACTION_EMOJI, + ) + .pipe( + (operation) => + retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.catch((error) => + Effect.logWarning("Failed to clear Discord thread bootstrap reaction", { + discordMessageId: input.pendingReadyReaction?.messageId, + error: String(error), + }), + ), + ), + ), + Effect.catch((error) => + Effect.logWarning("Failed to create initial thread info pin", { + discordThreadId: input.discordThreadId, + error: String(error), + }), + ), + ); + + // Critical path for first in-progress stream: Working tip + bridge MUST start + // immediately after the initial pin. Agent work begins at startTurnWithWorktree; + // keep the remaining path unchanged so the seeded Working tip and bridge delivery + // retain their existing reliability on new thread starts. + const workingAckMessageId = + input.presentationMode === "final-only" + ? null + : yield* rest + .createMessage(input.discordThreadId, { + ...workingMessageFields("_Working.._", threadId), + }) + .pipe( + Effect.map((msg) => msg.id as string), + Effect.tap((postedId) => + Effect.logInfo("Posted Working.. ack", { messageId: postedId }), + ), + Effect.result, + Effect.flatMap((result) => { + if (Result.isSuccess(result)) return Effect.succeed(result.success); + return Effect.logError("Failed to post Working.. ack").pipe( + Effect.andThen(Effect.logError(result.failure)), + Effect.as(null), + ); + }), + ); + + yield* bridgeThreadToDiscord({ + discordChannelId: input.discordThreadId, + t3ThreadId: threadId, + workingAckMessageId, + sentDiscordUserMessageIds: [messageId], + ...(input.presentationMode === undefined + ? {} + : { presentationMode: input.presentationMode }), + }); + + // Refresh after bridge start to add any slower enrichment without blocking the + // initial Working tip / stream subscription. + yield* upsertThreadInfoPin({ + discordThreadId: input.discordThreadId, + t3ThreadId: threadId, + botConfig, + incomingJiraKeys: firstTurnJiraIssueKeys, + dropJiraIssueKeys: firstTurnSentryMaskedJira, + incomingSentryIssueUrls: firstTurnSentryIssueUrls, + incomingPrUrls: prUrlsFromMessages(...firstTurnWorkItemMessages), + modelSelection, + baseBranchLabel: input.flags.base ?? botConfig.t3DefaultBaseBranch, + local: input.flags.local, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to create thread info pin", { + discordThreadId: input.discordThreadId, + error: String(error), + }), + ), + ); + + return threadId; + }); + + const startBridgedTurn = (input: BridgedTurnInput) => + turnCoordinator.withLock(input.discordThreadId, startBridgedTurnUnlocked(input)); + + const waitForStartedTurnToBecomeVisible = Effect.fn( + "MentionRouter.waitForStartedTurnToBecomeVisible", + )(function* (threadId: ThreadId) { + for (let attempt = 0; attempt < 30; attempt += 1) { + const thread = yield* t3.getThreadShell(threadId); + if (hasInterruptibleTurn(thread)) return; + yield* Effect.sleep("100 millis"); + } + yield* Effect.logWarning("Started Discord thread-talk turn was not visible before timeout", { + threadId, + }); + }); + + const reportError = (channelId: string, error: unknown) => { + const raw = error instanceof Error ? error.message : String(error); + const content = + raw === T3_STILL_CONNECTING_MESSAGE || /not connected|still connecting/i.test(raw) + ? T3_STILL_CONNECTING_MESSAGE + : `Could not start T3 turn: ${raw}`; + return rest + .createMessage(channelId, { content }) + .pipe(Effect.catchCause(Effect.logError), Effect.asVoid); + }; + + /** + * dfx InteractionsRegistry runs Ix handlers with a Discord-only context — app + * services like {@link BridgeHub} are not ambient. Provide them explicitly for + * anything that calls `bridgeThreadToDiscord` / `getLiveDiscordBridge`. + */ + const withBridgeHub = (effect: Effect.Effect) => + effect.pipe(Effect.provideService(BridgeHub, bridgeHub)); + + /** + * Background work from slash handlers. Must use `startImmediately: true` — dfx wraps + * handlers in a short-lived Scope, and default forkDetach only schedules on the parent + * dispatcher (often lost when the interaction fiber exits before the task runs). + * Also re-provides BridgeHub (Ix fibers do not inherit the router layer context). + */ + const forkSlashBackground = (effect: Effect.Effect) => + withBridgeHub(effect).pipe(Effect.forkDetach({ startImmediately: true })); + + /** + * Link Discord to an existing T3 thread (no new T3 thread / no new turn). + * Only from a project channel, or from a Discord thread that is not yet linked. + * - If a Discord bridge already exists for that T3 thread, point at it. + * - Else create a Discord thread from the mention (channel) or use the current + * unlinked Discord thread, then persist the link and ensure a bridge. + */ + const replyFields = (replyToMessageId: string | null | undefined) => + replyToMessageId === null || replyToMessageId === undefined + ? {} + : { message_reference: { message_id: replyToMessageId } }; + + /** + * Link Discord to an existing T3 thread (no new T3 thread / no new turn). + * Only from a project channel, or from a Discord thread that is not yet linked. + * Returns a short user-facing summary (mention path posts it; slash uses it as the ack). + */ + const linkExistingT3Thread = (input: { + readonly t3ThreadId: string; + readonly replyChannelId: string; + /** Null when invoked from a slash command (no source message). */ + readonly replyToMessageId: string | null; + readonly guildId: string; + readonly topic: string | null | undefined; + /** When already inside a Discord thread, link that thread instead of creating one. */ + readonly existingDiscordThreadId: string | null; + readonly parentChannelId: string; + /** + * When true, skip `createMessage` on the reply channel and only return the summary + * (caller responds via interaction ack). Still posts into a newly linked thread. + */ + readonly replyViaReturn?: boolean; + }) => + withBridgeHub( + Effect.gen(function* () { + const postReply = (content: string) => + input.replyViaReturn === true + ? Effect.succeed(content) + : rest + .createMessage(input.replyChannelId, { + content, + ...replyFields(input.replyToMessageId), + }) + .pipe(Effect.as(content)); + + // Refuse inside an already-linked Discord thread (same or different T3 id), + // unless that link is incomplete (failed mid-setup) — then finish setup. + if (input.existingDiscordThreadId !== null) { + const currentLink = yield* links.getByDiscordThreadId(input.existingDiscordThreadId); + if ( + currentLink !== null && + currentLink.status === "active" && + !isIncompleteDiscordLink(currentLink) + ) { + return yield* postReply( + [ + "This Discord thread is already linked to a T3 thread.", + "`link` / `pick-up` / `/omegent link` only works from a project channel, or from a Discord thread that is not linked yet.", + `Current T3 thread: \`${currentLink.t3ThreadId}\``, + ].join("\n"), + ); + } + } + + const t3ThreadId = input.t3ThreadId as ThreadId; + const shellThread = yield* t3.getThreadShell(t3ThreadId); + if (shellThread === null) { + return yield* postReply(`No T3 thread found for \`${input.t3ThreadId}\`.`); + } + + const ensureLinkedBridgeAndPin = (args: { + readonly discordThreadId: string; + readonly titleLine: string; + readonly extraLines?: ReadonlyArray; + }) => + Effect.gen(function* () { + yield* bridgeThreadToDiscord({ + discordChannelId: args.discordThreadId, + t3ThreadId, + }); + yield* upsertThreadInfoPin({ + discordThreadId: args.discordThreadId, + t3ThreadId, + botConfig, + incomingJiraKeys: [], + modelSelection: shellThread.modelSelection, + worktreePath: shellThread.worktreePath, + local: shellThread.worktreePath === null, + titleLine: args.titleLine, + extraLines: [ + "Mention me in this thread to continue the conversation.", + ...(args.extraLines ?? []), + ], + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to create thread info pin for linked thread", { + discordThreadId: args.discordThreadId, + t3ThreadId, + error: String(error), + }), + ), + ); + }); + + const shell = yield* t3.shell(); + const existingLinks = yield* links.list(); + const activeLinks = existingLinks.filter((link) => link.status === "active"); + const existingLink = + activeLinks.find((link) => link.t3ThreadId === t3ThreadId) ?? + (input.existingDiscordThreadId !== null + ? activeLinks.find( + (link) => + link.discordThreadId === input.existingDiscordThreadId && + isIncompleteDiscordLink(link), + ) + : undefined) ?? + findDiscordLinkForT3Target({ + links: activeLinks, + threads: shell?.threads ?? [], + target: { id: t3ThreadId, worktreePath: shellThread.worktreePath }, + }); + + if (existingLink !== undefined) { + if (existingLink.t3ThreadId !== t3ThreadId) { + // Worktree match or incomplete Discord thread pointed at a different T3 id. + yield* links.put({ + ...existingLink, + t3ThreadId, + projectId: shellThread.projectId, + }); + } + const recovering = isIncompleteDiscordLink(existingLink); + const titleLine = recovering + ? `Recovered link to existing T3 thread **${shellThread.title}**.` + : `Linked existing T3 thread **${shellThread.title}**.`; + yield* ensureLinkedBridgeAndPin({ + discordThreadId: existingLink.discordThreadId, + titleLine, + ...(recovering + ? { + extraLines: [ + "Previous link attempt did not finish (bridge/pin); setup is complete now.", + ], + } + : {}), + }); + const jump = discordChannelUrl(existingLink.guildId, existingLink.discordThreadId); + const webLink = t3WebThreadUrl(botConfig.webUiBaseUrl, t3ThreadId); + const content = recovering + ? [ + `Recovered link for **${shellThread.title}** → ${jump}`, + "Bridge + thread-info pin re-attached. Mention `@Omegent` to continue.", + webLink === null ? null : `Open in Omegent: ${webLink}`, + ] + .filter((line): line is string => line !== null) + .join("\n") + : [ + `T3 thread **${shellThread.title}** is already linked here: ${jump}`, + webLink === null ? null : `Open in Omegent: ${webLink}`, + ] + .filter((line): line is string => line !== null) + .join("\n"); + yield* Effect.logInfo( + recovering + ? "Recovered incomplete Discord↔T3 link" + : "Pointed at existing Discord↔T3 link", + { + t3ThreadId, + discordThreadId: existingLink.discordThreadId, + replyChannelId: input.replyChannelId, + recovering, + }, + ); + return yield* postReply(content); + } + + // Prefer binding to the project of the T3 thread; when the channel has a topic, + // require it to resolve to the same project so the Discord home is correct. + const shortName = parseTopicShortName(input.topic); + if (shortName !== null) { + const resolved = yield* resolveProjectFromTopic(input.topic).pipe(Effect.result); + if (Result.isFailure(resolved)) { + return yield* postReply(String(resolved.failure)); + } + if (resolved.success.project.id !== shellThread.projectId) { + return yield* postReply( + [ + `That T3 thread belongs to a different project than this channel.`, + `Thread project id: \`${shellThread.projectId}\``, + `Channel project (\`${resolved.success.shortName}\`): \`${resolved.success.project.id}\``, + ].join("\n"), + ); + } + } else if (input.existingDiscordThreadId === null) { + // Creating a Discord thread from a bare channel requires a project topic + // so the thread lives in the right place. + return yield* postReply( + "This channel is not linked to a T3 project. Set the channel topic to include `t3-` (e.g. `t3-example-project`).", + ); + } + + let discordThreadId = input.existingDiscordThreadId; + if (discordThreadId === null) { + let starterMessageId = input.replyToMessageId; + if (starterMessageId === null) { + const starter = yield* rest.createMessage(input.parentChannelId, { + content: `Linking existing T3 thread **${shellThread.title}**…`, + }); + starterMessageId = starter.id; + } + const discordThread = yield* openOrReuseThread( + input.parentChannelId, + starterMessageId, + truncateTitle(shellThread.title), + ); + discordThreadId = discordThread.id; + } + + yield* links.put({ + discordThreadId, + t3ThreadId, + projectId: shellThread.projectId, + channelId: input.parentChannelId, + guildId: input.guildId, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + sentDiscordUserMessageIds: [], + }); + yield* ensureLinkedBridgeAndPin({ + discordThreadId, + titleLine: `Linked existing T3 thread **${shellThread.title}**.`, + }); + + const jump = discordChannelUrl(input.guildId, discordThreadId); + const webLink = t3WebThreadUrl(botConfig.webUiBaseUrl, t3ThreadId); + const modelLine = `${shellThread.modelSelection.instanceId}/${shellThread.modelSelection.model}`; + const linkedContent = [ + `Linked existing T3 thread **${shellThread.title}**.`, + `Model: \`${modelLine}\``, + shellThread.worktreePath === null + ? "Mode: local (no worktree)" + : `Worktree: \`${shellThread.worktreePath}\``, + webLink === null ? null : `Open in Omegent: ${webLink}`, + "Mention `@Omegent` in this thread to continue the conversation.", + ] + .filter((line): line is string => line !== null) + .join("\n"); + + yield* Effect.logInfo("Linked Discord thread to existing T3 thread", { + t3ThreadId, + discordThreadId, + parentChannelId: input.parentChannelId, + createdNewDiscordThread: input.existingDiscordThreadId === null, + }); + + // When the reply channel is the new/linked thread, avoid a second post. + if (input.replyChannelId === discordThreadId) { + return linkedContent; + } + return yield* postReply( + [ + `Linked **${shellThread.title}** → ${jump}`, + webLink === null ? null : `Open in Omegent: ${webLink}`, + ] + .filter((line): line is string => line !== null) + .join("\n"), + ); + }), + ); + + const openOrReuseThread = (channelId: string, messageId: string, name: string) => + rest + .createThreadFromMessage(channelId, messageId, { + name, + auto_archive_duration: 1440, + }) + .pipe( + Effect.catch((error) => + Effect.gen(function* () { + // Another bot (e.g. AutoThreads) may have already opened a thread. + yield* Effect.logWarning( + "createThreadFromMessage failed; looking up existing thread", + { + error: String(error), + messageId, + }, + ); + const message = yield* rest.getMessage(channelId, messageId); + const threadId = + message.thread && typeof message.thread === "object" && "id" in message.thread + ? String((message.thread as { id: string }).id) + : null; + if (threadId === null) { + return yield* Effect.fail(error); + } + return { id: threadId } as { id: string }; + }), + ), + ); + + const runTodayRecapTurn = (input: { + readonly deliveryChannelId: string; + readonly shortName: string; + readonly topic: string | null | undefined; + readonly guildId: string; + readonly requester: DiscordMessageLike; + }) => + Effect.gen(function* () { + const date = utcDateStamp(DateTime.formatIso(DateTime.nowUnsafe())); + const prompt = buildTodayRecapPrompt({ + shortName: input.shortName, + date, + parentChannelId: input.deliveryChannelId, + }); + yield* Effect.logInfo("today-recap starting T3 turn", { + shortName: input.shortName, + deliveryChannelId: input.deliveryChannelId, + date, + }); + yield* waitForT3ReadyForInbound({ + discordChannelId: input.deliveryChannelId, + reason: "today-recap", + }); + const resolved = yield* resolveProjectFromTopic(input.topic); + const modelSelection = yield* t3.resolveModelSelection({ project: resolved.project }); + const { threadId } = yield* t3.startTurnWithWorktree({ + project: resolved.project, + prompt, + titleSeed: formatTodayRecapThreadTitle({ shortName: input.shortName, date }), + modelSelection, + interactionMode: "default", + baseBranch: botConfig.t3DefaultBaseBranch, + local: true, + sourceHint: discordSourceHint({ + authorId: input.requester.author?.id, + authorUsername: input.requester.author?.username, + guildId: input.guildId, + channelId: input.deliveryChannelId, + }), + }); + yield* Effect.logInfo("today-recap T3 thread started", { + shortName: input.shortName, + threadId, + date, + }); + const startedAt = yield* Clock.currentTimeMillis; + while ((yield* Clock.currentTimeMillis) - startedAt < TODAY_RECAP_TURN_TIMEOUT_MS) { + const detail = yield* t3.fetchThreadDetail(threadId); + const state = detail?.thread.latestTurn?.state; + if (state === "completed" || state === "interrupted" || state === "error") { + const text = extractLatestAssistantText(detail?.thread.messages ?? []); + yield* Effect.logInfo("today-recap T3 turn settled", { + shortName: input.shortName, + threadId, + state, + hasText: text !== null, + }); + if (text !== null) return text; + if (state === "interrupted") { + return "today-recap stopped before a recap was produced."; + } + if (state === "error") { + return "today-recap failed before a recap was produced."; + } + return "no change"; + } + yield* Effect.sleep(`${TODAY_RECAP_TURN_POLL_MS} millis`); + } + yield* Effect.logWarning("today-recap timed out waiting for the recap", { + shortName: input.shortName, + threadId, + }); + return "today-recap timed out waiting for the recap."; + }); + + const watchedDiscordLinkRequests = new Set(); + const completedDiscordLinkRequests = new Set(); + const linkingDiscordThreads = new Set(); + yield* Effect.forkScoped( + Effect.forever( + Effect.gen(function* () { + const shell = yield* t3.shell(); + if (shell === null) { + yield* Effect.sleep("1 second"); + return; + } + for (const thread of shell.threads) { + if (watchedDiscordLinkRequests.has(thread.id)) continue; + watchedDiscordLinkRequests.add(thread.id); + yield* Effect.forkDetach( + t3 + .subscribeThread(thread.id, (detail: OrchestrationThread) => + Effect.gen(function* () { + if ( + completedDiscordLinkRequests.has(detail.id) || + linkingDiscordThreads.has(detail.id) || + !detail.messages.some( + (message) => + message.role === "user" && + message.text.includes(DISCORD_LINK_REQUEST_MARKER), + ) + ) { + return; + } + linkingDiscordThreads.add(detail.id); + yield* Effect.gen(function* () { + const currentShell = yield* t3.shell(); + if (currentShell === null) return; + const target = currentShell.threads.find( + (candidate) => candidate.id === detail.id, + ); + if (target === undefined) return; + const existingLinks = yield* links.list(); + const worktreeLink = findDiscordLinkForT3Target({ + links: existingLinks, + threads: currentShell.threads, + target, + }); + if (worktreeLink !== undefined) { + if (worktreeLink.t3ThreadId !== target.id) { + yield* links.put({ + ...worktreeLink, + t3ThreadId: target.id, + projectId: target.projectId, + }); + } + yield* bridgeThreadToDiscord({ + discordChannelId: worktreeLink.discordThreadId, + t3ThreadId: target.id, + }); + completedDiscordLinkRequests.add(target.id); + yield* Effect.logInfo("Reused Discord thread for GitHub link request", { + t3ThreadId: target.id, + worktreePath: target.worktreePath, + discordThreadId: worktreeLink.discordThreadId, + }); + return; + } + + const project = currentShell.projects.find( + (candidate) => candidate.id === target.projectId, + ); + const alias = + project === undefined + ? undefined + : aliases + .list() + .find( + (candidate) => + normalizeWorkspacePath(candidate.workspaceRoot) === + normalizeWorkspacePath(project.workspaceRoot), + ); + if (!alias?.discordChannelId) { + yield* Effect.logWarning( + "GitHub requested a Discord thread but the project has no Discord channel", + { t3ThreadId: target.id, projectId: target.projectId }, + ); + return; + } + const parent = yield* rest.getChannel(alias.discordChannelId); + const guildId = + "guild_id" in parent && typeof parent.guild_id === "string" + ? parent.guild_id + : ""; + const starter = yield* rest.createMessage(alias.discordChannelId, { + content: `T3 created **${target.title}** from GitHub.`, + }); + const discordThread = yield* openOrReuseThread( + alias.discordChannelId, + starter.id, + truncateTitle(target.title), + ); + yield* links.put({ + discordThreadId: discordThread.id, + t3ThreadId: target.id, + projectId: target.projectId, + channelId: alias.discordChannelId, + guildId, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + sentDiscordUserMessageIds: [], + }); + yield* bridgeThreadToDiscord({ + discordChannelId: discordThread.id, + t3ThreadId: target.id, + }); + yield* upsertThreadInfoPin({ + discordThreadId: discordThread.id, + t3ThreadId: target.id, + botConfig, + modelSelection: target.modelSelection, + worktreePath: target.worktreePath, + local: target.worktreePath === null, + titleLine: `T3 created **${target.title}** from GitHub.`, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to create thread info pin for GitHub link", { + discordThreadId: discordThread.id, + t3ThreadId: target.id, + error: String(error), + }), + ), + ); + completedDiscordLinkRequests.add(target.id); + yield* Effect.logInfo("Created Discord thread for GitHub link request", { + t3ThreadId: target.id, + worktreePath: target.worktreePath, + discordThreadId: discordThread.id, + discordChannelId: alias.discordChannelId, + }); + }).pipe( + Effect.ensuring( + Effect.sync(() => { + linkingDiscordThreads.delete(detail.id); + }), + ), + ); + }), + ) + .pipe( + Effect.catchCause((cause) => + Effect.logError("Discord link request watcher stopped", { + t3ThreadId: thread.id, + cause, + }), + ), + ), + ); + } + yield* Effect.sleep("1 second"); + }), + ), + ); + + // The app's managed role id, per guild. Resolved lazily and cached: it never changes + // for a given guild, and listGuildRoles on every message would burn rate limit. + const botRoleIdByGuild = new Map(); + const resolveBotRoleId = (guildId: string) => + Effect.gen(function* () { + const cached = botRoleIdByGuild.get(guildId); + if (cached !== undefined) return cached; + const roles = yield* rest.listGuildRoles(guildId).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + yield* Effect.logWarning(`Could not list roles for guild ${guildId}`, { cause }); + return [] as ReadonlyArray; + }), + ), + ); + const roleId = botManagedRoleIdFrom(roles, botUserId); + botRoleIdByGuild.set(guildId, roleId); + return roleId; + }); + + const handledMessageIds = createHandledDiscordMessageTracker(); + + type GatewayMessageEvent = { + readonly id: string; + readonly channel_id: string; + readonly guild_id?: string | null | undefined; + readonly type?: number | undefined; + readonly content?: string | null | undefined; + readonly mentions?: ReadonlyArray<{ readonly id?: string }> | null | undefined; + readonly mention_roles?: ReadonlyArray | null | undefined; + readonly attachments?: ReadonlyArray | null | undefined; + readonly author?: + | { + readonly id?: string | undefined; + readonly username?: string | undefined; + readonly global_name?: string | null | undefined; + readonly bot?: boolean | undefined; + } + | undefined; + readonly member?: { readonly nick?: string | null | undefined } | undefined; + readonly embeds?: DiscordMessageLike["embeds"]; + readonly timestamp?: string | undefined; + readonly webhook_id?: string | undefined; + readonly referenced_message?: DiscordMessagePayload | null | undefined; + readonly message_reference?: + | { + readonly message_id?: string | null | undefined; + readonly channel_id?: string | null | undefined; + readonly guild_id?: string | null | undefined; + } + | null + | undefined; + }; + + const handleInboundMessage = (rawEvent: GatewayMessageEvent, source: "create" | "update") => + Effect.gen(function* () { + // Cheap pre-filter: never re-enter routing for a message we already claimed. + // (CREATE and UPDATE share this tracker so edits cannot start a second turn.) + if (handledMessageIds.has(rawEvent.id)) { + yield* Effect.logInfo("Ignoring already-handled Discord message", { + source, + channelId: rawEvent.channel_id, + messageId: rawEvent.id, + }); + return; + } + + const event: GatewayMessageEvent | null = + source === "update" + ? yield* rest.getMessage(rawEvent.channel_id, rawEvent.id).pipe( + (operation) => + retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.map( + (full) => + ({ + ...rawEvent, + ...full, + channel_id: rawEvent.channel_id, + }) as GatewayMessageEvent, + ), + Effect.catch((error) => + Effect.logWarning("Failed to hydrate Discord message update via REST", { + channelId: rawEvent.channel_id, + messageId: rawEvent.id, + error: String(error), + }).pipe(Effect.as(null)), + ), + ) + : rawEvent; + if (event === null) return; + + const mentionIds = (event.mentions ?? []) + .map((user) => user.id) + .filter((id): id is string => typeof id === "string"); + const mentionRoleIds = (event.mention_roles ?? []).filter( + (id): id is string => typeof id === "string", + ); + const guildId = event.guild_id ?? null; + const botRoleId = guildId === null ? null : yield* resolveBotRoleId(guildId); + const mentionsBotRole = botRoleId !== null && mentionRoleIds.includes(botRoleId); + + yield* Effect.logInfo(source === "create" ? "MESSAGE_CREATE" : "MESSAGE_UPDATE", { + channelId: event.channel_id, + messageId: event.id, + guildId, + type: event.type, + authorId: event.author?.id ?? null, + authorBot: event.author?.bot === true, + contentLen: (event.content ?? "").length, + contentPreview: (event.content ?? "").slice(0, 80), + mentionIds, + mentionsBot: mentionIds.includes(botUserId), + mentionRoleIds, + mentionsBotRole, + }); + + if ( + event.author?.bot === true || + event.author?.id === botUserId || + event.webhook_id !== undefined + ) { + return; + } + + let content = event.content ?? ""; + let gatewayAttachments = (event.attachments ?? + []) as ReadonlyArray; + let mentioned = + mentionsBotInEvent( + { + content: event.content ?? null, + mentions: event.mentions ?? null, + }, + botUserId, + ) || + mentionsBotInContent(content, botUserId) || + mentionsBotRole; + + if (!mentioned && content.includes(botUserId)) { + mentioned = true; + } + + const unmentionedLink = mentioned + ? null + : yield* links.getByDiscordThreadId(event.channel_id); + const automaticThreadMessage = !mentioned && threadTalkEnabled(unmentionedLink); + if (!mentioned && !automaticThreadMessage) return; + + if (content.length === 0) { + yield* Effect.logWarning( + "Routable message has empty gateway content; fetching it via REST. Enable Message Content Intent in the Discord Developer Portal.", + { channelId: event.channel_id, messageId: event.id }, + ); + const full = yield* rest.getMessage(event.channel_id, event.id).pipe( + (operation) => + retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.catch((error) => + Effect.logError("Failed to fetch message content via REST", { + error: String(error), + }).pipe(Effect.as(null)), + ), + ); + if (full !== null) { + content = full.content ?? ""; + if (Array.isArray(full.attachments) && full.attachments.length > 0) { + gatewayAttachments = full.attachments as ReadonlyArray; + } + } + } + + if ( + event.type !== Discord.MessageType.DEFAULT && + event.type !== Discord.MessageType.REPLY + ) { + yield* Effect.logInfo("Ignoring mentioned non-user message type", { + type: event.type, + messageId: event.id, + }); + return; + } + + const referenced = yield* resolveReferencedMessage({ + event: { + channel_id: event.channel_id, + guild_id: event.guild_id, + referenced_message: event.referenced_message ?? null, + message_reference: event.message_reference ?? null, + }, + rest: rest as { + readonly getMessage: ( + channelId: string, + messageId: string, + ) => Effect.Effect; + }, + }); + if (referenced !== null) { + yield* Effect.logInfo("Resolved referenced Discord message for mention", { + messageId: event.id, + referencedMessageId: referenced.message.id, + referencedAuthor: referenced.message.author?.username ?? null, + hasEmbeds: (referenced.message.embeds?.length ?? 0) > 0, + }); + } + + const channel = yield* rest.getChannel(event.channel_id); + const inThread = isThreadChannel(channel.type); + if (automaticThreadMessage && !inThread) return; + + // Claim before image download / turn start. Late marking let MESSAGE_UPDATE race + // MESSAGE_CREATE and double-run prompts (especially noticeable on short edits). + if (!handledMessageIds.claim(event.id)) { + yield* Effect.logInfo("Ignoring concurrent Discord message routing race", { + source, + channelId: event.channel_id, + messageId: event.id, + }); + return; + } + + const body = mentioned ? stripBotMention(content, botUserId, botRoleId) : content.trim(); + const threadTalkCommand = mentioned ? parseThreadTalkCommand(body) : null; + if (threadTalkCommand !== null) { + if (!inThread) { + yield* rest.createMessage(event.channel_id, { + content: "Thread-talk can only be configured inside a linked Discord thread.", + message_reference: { message_id: event.id }, + }); + return; + } + const link = yield* links.getByDiscordThreadId(event.channel_id); + if (link === null) { + yield* rest.createMessage(event.channel_id, { + content: "This Discord thread is not linked to a T3 thread yet.", + message_reference: { message_id: event.id }, + }); + return; + } + if (threadTalkCommand.kind === "set") { + yield* links.setThreadTalkMode( + event.channel_id, + threadTalkCommand.enabled ? "all-messages" : null, + ); + } + const enabled = + threadTalkCommand.kind === "set" ? threadTalkCommand.enabled : threadTalkEnabled(link); + yield* rest.createMessage(event.channel_id, { + content: enabled + ? "Thread-talk is **on**. New human messages in this linked thread will be sent to T3 without requiring a mention." + : "Thread-talk is **off**. Mention `@Omegent` to send a message to Omegent.", + message_reference: { message_id: event.id }, + }); + yield* Effect.logInfo("Discord thread-talk mode resolved", { + discordThreadId: event.channel_id, + t3ThreadId: link.t3ThreadId, + enabled, + command: threadTalkCommand.kind, + actorId: event.author?.id ?? null, + }); + return; + } + + if (automaticThreadMessage && unmentionedLink !== null) { + const threadShell = yield* t3.getThreadShell(unmentionedLink.t3ThreadId); + if (hasInterruptibleTurn(threadShell)) { + yield* rest.createMessage(event.channel_id, { + content: + "Omegent is already working, so this message was not submitted. Wait for the current turn to finish, or mention `@Omegent stop`.", + message_reference: { message_id: event.id }, + }); + return; + } + } + + const intent = mentioned + ? parseMentionIntent(body) + : { + kind: "prompt" as const, + local: false, + plan: false, + prompt: body, + }; + const flags = intent.kind === "prompt" ? intent : parseMentionFlags(body); + const pendingReadyReaction = shouldShowThreadBootstrapReaction({ + inThread, + intentKind: intent.kind, + hasPromptOrAttachment: + (intent.kind === "prompt" && intent.prompt.length > 0) || + intent.kind === "today-recap" || + gatewayAttachments.length > 0, + }) + ? { channelId: event.channel_id, messageId: event.id } + : undefined; + if (pendingReadyReaction !== undefined) { + yield* rest + .addMyMessageReaction( + pendingReadyReaction.channelId, + pendingReadyReaction.messageId, + THREAD_BOOTSTRAP_REACTION_EMOJI, + ) + .pipe( + (operation) => + retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.catch((error) => + Effect.logWarning("Failed to add Discord thread bootstrap reaction", { + discordMessageId: event.id, + error: String(error), + }), + ), + ); + } + + const imageCandidates = filterDiscordImageAttachments(gatewayAttachments); + const downloaded = yield* Effect.tryPromise({ + try: () => downloadDiscordImagesAsUploadAttachments(imageCandidates), + catch: (cause) => new DiscordImageDownloadError({ cause }), + }).pipe( + Effect.catch((cause) => + Effect.logError("Failed to download Discord image attachments").pipe( + Effect.andThen(Effect.logError(cause)), + Effect.as({ + uploads: [] as ReadonlyArray, + skipped: imageCandidates.map((a) => ({ + filename: a.filename ?? "image", + reason: "download failed", + })), + }), + ), + ), + ); + if (downloaded.skipped.length > 0) { + yield* Effect.logWarning("Skipped some Discord image attachments", { + skipped: downloaded.skipped, + }); + } + const uploadAttachments = downloaded.uploads; + const hasAnyAttachments = gatewayAttachments.length > 0; + + yield* Effect.logInfo( + automaticThreadMessage ? "Thread-talk message received" : "Bot mention received", + { + channelId: event.channel_id, + messageId: event.id, + guildId: event.guild_id ?? null, + messageType: event.type, + source, + contentPreview: content.slice(0, 120), + discordAttachments: gatewayAttachments.length, + imageAttachments: uploadAttachments.length, + }, + ); + + const prompt = + intent.kind === "prompt" && intent.prompt.length > 0 + ? intent.prompt + : uploadAttachments.length > 0 + ? IMAGE_ONLY_PROMPT + : hasAnyAttachments + ? ATTACHMENT_ONLY_PROMPT + : ""; + if (intent.kind === "prompt" && prompt.length === 0) { + yield* rest.createMessage(event.channel_id, { + content: + content.length === 0 + ? "I saw your mention but message content is empty. Enable **Message Content Intent** for this bot in the Discord Developer Portal, then restart me." + : "Send a prompt after mentioning me (or attach a file). Optional flags: `--model` `--provider` `--base` `--local` `--plan` `--steer` `--queue`. Mid-turn follow-ups **queue** by default (📥); delete your message to cancel, or `/omegent steernow` to inject the queue. Use `--steer` to inject immediately.", + message_reference: { message_id: event.id }, + }); + return; + } + const effectivePrompt = automaticThreadMessage + ? formatUnmentionedDiscordPrompt({ + content: prompt, + authorId: event.author?.id ?? "unknown", + authorName: event.author?.global_name ?? event.author?.username ?? "Unknown user", + messageId: event.id, + }) + : prompt; + const flagsWithPrompt = { ...flags, prompt: effectivePrompt }; + + if (inThread) { + const topicLookup = yield* resolveProjectTopic(channel); + const parentId = + topicLookup.kind === "parent-unavailable" + ? topicLookup.parentChannelId + : (topicLookup.parentChannelId ?? + ("parent_id" in channel && typeof channel.parent_id === "string" + ? channel.parent_id + : null)); + const parentUnavailable = topicLookup.kind === "parent-unavailable"; + const topic = topicLookup.kind === "resolved" ? topicLookup.topic : null; + const pin = parentUnavailable + ? null + : yield* refreshChannelInfoPin(parentId ?? event.channel_id, topic); + + if (intent.kind === "help") { + if (parentUnavailable) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ inThread: true, parentUnavailable: true }), + message_reference: { message_id: event.id }, + }); + return; + } + if (pin === null || parseTopicShortName(topic) === null) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ + inThread: true, + parentUnavailable: false, + }), + message_reference: { message_id: event.id }, + }); + return; + } + + yield* rest.createMessage(event.channel_id, { + content: `Channel info: ${discordMessageUrl(event.guild_id, pin.channelId, pin.messageId)}`, + message_reference: { message_id: event.id }, + }); + return; + } + + if (intent.kind === "today-recap") { + if (parentUnavailable) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ inThread: true, parentUnavailable: true }), + message_reference: { message_id: event.id }, + }); + return; + } + const shortName = parseTopicShortName(topic); + if (shortName === null || parentId === null) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ + inThread: true, + parentUnavailable: false, + }), + message_reference: { message_id: event.id }, + }); + return; + } + const mentionMessage = discordMessageFromEvent({ ...event, content }); + const recap = yield* runTodayRecapTurn({ + deliveryChannelId: event.channel_id, + shortName, + topic, + guildId: event.guild_id ?? "", + requester: mentionMessage, + }).pipe( + Effect.catch((error) => + Effect.succeed( + `today-recap failed: ${error instanceof Error ? error.message : String(error)}`, + ), + ), + ); + const chunks = chunkTodayRecapContent(recap); + for (const [index, chunk] of chunks.entries()) { + yield* rest.createMessage(event.channel_id, { + content: chunk, + ...(index === 0 ? { message_reference: { message_id: event.id } } : {}), + }); + } + return; + } + + if (intent.kind === "link-thread") { + if (parentUnavailable && parseTopicShortName(topic) === null) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ inThread: true, parentUnavailable: true }), + message_reference: { message_id: event.id }, + }); + return; + } + yield* linkExistingT3Thread({ + t3ThreadId: intent.t3ThreadId, + replyChannelId: event.channel_id, + replyToMessageId: event.id, + guildId: event.guild_id ?? "", + topic, + existingDiscordThreadId: event.channel_id, + parentChannelId: parentId ?? event.channel_id, + }).pipe(Effect.catch((error) => reportError(event.channel_id, error))); + return; + } + + if (intent.kind === "interrupt") { + const existing = yield* links.getByDiscordThreadId(event.channel_id); + if (existing === null) { + yield* rest.createMessage(event.channel_id, { + content: + "This Discord thread is not linked to a T3 thread, so there is nothing to stop.", + message_reference: { message_id: event.id }, + }); + return; + } + + const threadShell = yield* t3.getThreadShell(existing.t3ThreadId); + if (!hasInterruptibleTurn(threadShell)) { + yield* rest.createMessage(event.channel_id, { + content: "There is no active turn to stop right now.", + message_reference: { message_id: event.id }, + }); + return; + } + + yield* t3.interrupt(existing.t3ThreadId); + yield* rest.createMessage(event.channel_id, { + content: "Stopping the current turn.", + message_reference: { message_id: event.id }, + }); + return; + } + + if (intent.kind === "compact") { + const existing = yield* links.getByDiscordThreadId(event.channel_id); + if (existing === null) { + yield* rest.createMessage(event.channel_id, { + content: + "This Discord thread is not linked to a T3 thread, so there is nothing to compact.", + message_reference: { message_id: event.id }, + }); + return; + } + + const content = yield* runContextCompact(existing.t3ThreadId); + yield* rest.createMessage(event.channel_id, { + content, + message_reference: { message_id: event.id }, + }); + return; + } + + if (intent.kind === "refresh-indicators") { + const existing = yield* links.getByDiscordThreadId(event.channel_id); + if (existing === null) { + yield* rest.createMessage(event.channel_id, { + content: + "This Discord thread is not linked to a T3 thread, so there are no indicators to refresh.", + message_reference: { message_id: event.id }, + }); + return; + } + + yield* bridgeThreadToDiscord({ + discordChannelId: event.channel_id, + t3ThreadId: existing.t3ThreadId, + mode: "rehydrate", + preferred: true, + lastActivityAt: existing.lastActivityAt, + }).pipe(Effect.catch((error) => reportError(event.channel_id, error))); + + const live = yield* bridgeHub.getLive(event.channel_id, existing.t3ThreadId); + if (live === null) { + yield* rest.createMessage(event.channel_id, { + content: "Could not attach a live bridge for this thread. Try again in a moment.", + message_reference: { message_id: event.id }, + }); + return; + } + + const result = yield* live.refreshThreadIndicators(); + yield* rest.createMessage(event.channel_id, { + content: result.ok + ? `Refreshed thread indicators → **${result.title}**` + : `Refresh-indicators failed: ${result.error}`, + message_reference: { message_id: event.id }, + }); + return; + } + + const mentionMessage = discordMessageFromEvent({ ...event, content }); + const turnInput: BridgedTurnInput = { + discordThreadId: event.channel_id, + channelId: parentId ?? event.channel_id, + guildId: event.guild_id ?? "", + prompt: effectivePrompt, + flags: flagsWithPrompt, + topic, + ...(parentUnavailable ? { parentUnavailable: true } : {}), + parentChannelId: parentId, + mentionMessage, + ...(referenced !== null + ? { + referencedMessage: referenced.message, + referencedMessageUrl: referenced.url, + } + : {}), + ...(gatewayAttachments.length > 0 ? { discordAttachments: gatewayAttachments } : {}), + ...(uploadAttachments.length > 0 ? { attachments: uploadAttachments } : {}), + ...(automaticThreadMessage ? { presentationMode: "final-only" as const } : {}), + }; + if (automaticThreadMessage && unmentionedLink !== null) { + const attempted = yield* turnCoordinator + .tryWithLock( + event.channel_id, + Effect.gen(function* () { + const latest = yield* t3.getThreadShell(unmentionedLink.t3ThreadId); + if (hasInterruptibleTurn(latest)) return "busy" as const; + yield* startBridgedTurnUnlocked(turnInput); + yield* waitForStartedTurnToBecomeVisible(unmentionedLink.t3ThreadId); + return "started" as const; + }), + ) + .pipe( + Effect.catch((error) => + reportError(event.channel_id, error).pipe( + Effect.as(Option.some("failed" as const)), + ), + ), + ); + const outcome = Option.match(attempted, { + onNone: () => "busy" as const, + onSome: (value) => value, + }); + if (outcome === "busy") { + yield* rest.createMessage(event.channel_id, { + content: + "Omegent is already working, so this message was not submitted. Wait for the current turn to finish, or mention `@Omegent stop`.", + message_reference: { message_id: event.id }, + }); + } + return; + } + + yield* startBridgedTurn(turnInput).pipe( + Effect.catch((error) => reportError(event.channel_id, error)), + ); + return; + } + + if (intent.kind === "interrupt") { + yield* rest.createMessage(event.channel_id, { + content: "Stop is only supported inside a linked Discord thread.", + message_reference: { message_id: event.id }, + }); + return; + } + + if (intent.kind === "compact") { + yield* rest.createMessage(event.channel_id, { + content: "Compact is only supported inside a linked Discord thread.", + message_reference: { message_id: event.id }, + }); + return; + } + + if (intent.kind === "refresh-indicators") { + yield* rest.createMessage(event.channel_id, { + content: "Refresh-indicators is only supported inside a linked Discord thread.", + message_reference: { message_id: event.id }, + }); + return; + } + + const topicLookup = yield* resolveProjectTopic(channel); + const parentUnavailable = topicLookup.kind === "parent-unavailable"; + const topic = topicLookup.kind === "resolved" ? topicLookup.topic : null; + const pin = parentUnavailable + ? null + : yield* refreshChannelInfoPin(event.channel_id, topic); + if (intent.kind === "help") { + if (parentUnavailable || pin === null || parseTopicShortName(topic) === null) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ + inThread: false, + parentUnavailable, + }), + message_reference: { message_id: event.id }, + }); + return; + } + + yield* rest.createMessage(event.channel_id, { + content: `Channel info: ${discordMessageUrl(event.guild_id, pin.channelId, pin.messageId)}`, + message_reference: { message_id: event.id }, + }); + return; + } + + if (intent.kind === "today-recap") { + const shortName = parseTopicShortName(topic); + if (parentUnavailable || shortName === null) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ + inThread: false, + parentUnavailable, + }), + message_reference: { message_id: event.id }, + }); + return; + } + const mentionMessage = discordMessageFromEvent({ ...event, content }); + const recap = yield* runTodayRecapTurn({ + deliveryChannelId: event.channel_id, + shortName, + topic, + guildId: event.guild_id ?? "", + requester: mentionMessage, + }).pipe( + Effect.catch((error) => + Effect.succeed( + `today-recap failed: ${error instanceof Error ? error.message : String(error)}`, + ), + ), + ); + const chunks = chunkTodayRecapContent(recap); + for (const [index, chunk] of chunks.entries()) { + yield* rest.createMessage(event.channel_id, { + content: chunk, + ...(index === 0 ? { message_reference: { message_id: event.id } } : {}), + }); + } + return; + } + + if (intent.kind === "link-thread") { + if (parentUnavailable && parseTopicShortName(topic) === null) { + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ + inThread: false, + parentUnavailable: true, + }), + message_reference: { message_id: event.id }, + }); + return; + } + yield* linkExistingT3Thread({ + t3ThreadId: intent.t3ThreadId, + replyChannelId: event.channel_id, + replyToMessageId: event.id, + guildId: event.guild_id ?? "", + topic, + existingDiscordThreadId: null, + parentChannelId: event.channel_id, + }).pipe(Effect.catch((error) => reportError(event.channel_id, error))); + return; + } + + if (parentUnavailable || parseTopicShortName(topic) === null) { + if (pendingReadyReaction !== undefined) { + yield* rest + .deleteMyMessageReaction( + pendingReadyReaction.channelId, + pendingReadyReaction.messageId, + THREAD_BOOTSTRAP_REACTION_EMOJI, + ) + .pipe( + (operation) => + retryTransientDiscordOperation(operation, DISCORD_MESSAGE_RETRY_DELAYS_MS), + Effect.catch(() => Effect.void), + ); + } + yield* rest.createMessage(event.channel_id, { + content: missingProjectBindingMessage({ + inThread: false, + parentUnavailable, + }), + message_reference: { message_id: event.id }, + }); + return; + } + + const discordThread = yield* openOrReuseThread( + event.channel_id, + event.id, + truncateTitle(prompt), + ); + const mentionMessage = discordMessageFromEvent({ ...event, content }); + + yield* startBridgedTurn({ + discordThreadId: discordThread.id, + channelId: event.channel_id, + guildId: event.guild_id ?? "", + prompt, + flags: flagsWithPrompt, + topic, + parentChannelId: event.channel_id, + mentionMessage, + ...(referenced !== null + ? { + referencedMessage: referenced.message, + referencedMessageUrl: referenced.url, + } + : {}), + ...(gatewayAttachments.length > 0 ? { discordAttachments: gatewayAttachments } : {}), + ...(uploadAttachments.length > 0 ? { attachments: uploadAttachments } : {}), + ...(pendingReadyReaction === undefined ? {} : { pendingReadyReaction }), + }).pipe(Effect.catch((error) => reportError(discordThread.id, error))); + }); + + const messageDispatchQueue = yield* makeDiscordMessageDispatchQueue(); + const enqueueMessageDispatch = ( + channelId: string, + handle: Effect.Effect, + ): Effect.Effect => + Effect.context().pipe( + Effect.flatMap((context) => + messageDispatchQueue.enqueue({ + channelId, + handle: handle.pipe(Effect.provide(context)), + }), + ), + ); + + const handleMessages = gateway.handleDispatch("MESSAGE_CREATE", (event) => { + const message = event as GatewayMessageEvent; + return enqueueMessageDispatch(message.channel_id, handleInboundMessage(message, "create")); + }); + const handleMessageUpdates = gateway.handleDispatch("MESSAGE_UPDATE", (event) => { + const message = event as GatewayMessageEvent; + return enqueueMessageDispatch(message.channel_id, handleInboundMessage(message, "update")); + }); + // User deletes their parked prompt → drop it from the server queue (and badge). + const handleMessageDeletes = gateway.handleDispatch("MESSAGE_DELETE", (event) => { + const deleted = event as { readonly channel_id: string; readonly id?: unknown }; + return enqueueMessageDispatch( + deleted.channel_id, + Effect.gen(function* () { + const messageId = + typeof event === "object" && + event !== null && + "id" in event && + typeof (event as { id?: unknown }).id === "string" + ? (event as { id: string }).id + : null; + if (messageId === null) return; + const pending = queuedPrompts.forgetDiscordMessage(messageId); + if (pending === null) return; + yield* Effect.logInfo("Discord user deleted queued prompt; removing from server queue", { + discordMessageId: messageId, + t3ThreadId: pending.t3ThreadId, + t3MessageId: pending.t3MessageId, + }); + yield* t3 + .removeQueuedMessage({ + threadId: pending.t3ThreadId, + messageId: pending.t3MessageId, + }) + .pipe( + Effect.catch((error) => + Effect.logWarning("Failed to remove queued prompt after Discord delete", { + t3ThreadId: pending.t3ThreadId, + t3MessageId: pending.t3MessageId, + error: String(error), + }), + ), + ); + // Message is gone — reaction cleanup is unnecessary. + }).pipe(Effect.catchCause(Effect.logError)), + ); + }); + + const approvalButton = Ix.messageComponent( + Ix.idStartsWith("t3_approve:"), + Effect.gen(function* () { + const data = yield* Ix.MessageComponentData; + const parts = data.custom_id.split(":"); + const threadId = parts[1]; + const requestId = parts[2]; + if (threadId === undefined || requestId === undefined) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Invalid approval payload.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + yield* t3.respondToApproval(threadId as ThreadId, requestId, "accept"); + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Approved.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: `Approval failed: ${error instanceof Error ? error.message : String(error)}`, + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }), + ), + ), + ), + ); + + const denyButton = Ix.messageComponent( + Ix.idStartsWith("t3_deny:"), + Effect.gen(function* () { + const data = yield* Ix.MessageComponentData; + const parts = data.custom_id.split(":"); + const threadId = parts[1]; + const requestId = parts[2]; + if (threadId === undefined || requestId === undefined) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Invalid approval payload.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + yield* t3.respondToApproval(threadId as ThreadId, requestId, "decline"); + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Denied.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: `Deny failed: ${error instanceof Error ? error.message : String(error)}`, + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }), + ), + ), + ), + ); + + const stopButton = Ix.messageComponent( + Ix.idStartsWith("t3_stop:"), + Effect.gen(function* () { + const data = yield* Ix.MessageComponentData; + const threadId = data.custom_id.slice(turnStopCustomId("").length); + if (threadId.length === 0) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Invalid stop payload.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + + const threadShell = yield* t3.getThreadShell(threadId as ThreadId); + if (!hasInterruptibleTurn(threadShell)) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "There is no active turn to stop right now.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + + yield* t3.interrupt(threadId as ThreadId); + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Stopping the current turn.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: `Stop failed: ${error instanceof Error ? error.message : String(error)}`, + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }), + ), + ), + ), + ); + + /** + * Blue Continue on a wake-up notice after server restart / interrupted session. + * Removes the button and starts a bridged "Continue" turn to wake the agent. + */ + const continueButton = Ix.messageComponent( + Ix.idStartsWith("t3_continue:"), + Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const data = yield* Ix.MessageComponentData; + const t3ThreadId = data.custom_id.slice(turnContinueCustomId("").length); + if (t3ThreadId.length === 0) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Invalid continue payload.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "Continue only works inside a Discord thread.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + + const link = yield* links.getByDiscordThreadId(channelId); + if (link === null || link.t3ThreadId !== t3ThreadId) { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "This thread is no longer linked to that T3 session.", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + } + + const messageContent = + typeof interaction.message === "object" && + interaction.message !== null && + "content" in interaction.message && + typeof interaction.message.content === "string" + ? interaction.message.content + : ""; + + // Ack by stripping the Continue button so it cannot be double-clicked. + // Bridged turn starts in the background (interaction window is short). + const user = interaction.member?.user ?? interaction.user; + const requester: DiscordMessageLike = { + id: interaction.id, + content: "Continue", + author: { + id: user?.id, + username: user?.username, + displayName: + interaction.member?.nick ?? user?.global_name ?? user?.username ?? undefined, + bot: user?.bot, + }, + timestamp: interaction.id, + channelId, + }; + + const channel = yield* rest.getChannel(channelId); + const topicLookup = yield* resolveProjectTopic(channel); + const parentUnavailable = topicLookup.kind === "parent-unavailable"; + const parentId = + topicLookup.kind === "parent-unavailable" + ? topicLookup.parentChannelId + : (topicLookup.parentChannelId ?? + ("parent_id" in channel && typeof channel.parent_id === "string" + ? channel.parent_id + : null)); + const topic = topicLookup.kind === "resolved" ? topicLookup.topic : null; + + yield* forkSlashBackground( + startBridgedTurn({ + discordThreadId: channelId, + channelId: parentId ?? channelId, + guildId: interaction.guild_id ?? link.guildId ?? "", + prompt: "Continue", + flags: { local: false, plan: false, prompt: "Continue" }, + topic, + ...(parentUnavailable ? { parentUnavailable: true } : {}), + parentChannelId: parentId, + mentionMessage: requester, + }).pipe( + Effect.tap(() => + Effect.logInfo("Continue button woke interrupted T3 thread", { + channelId, + t3ThreadId, + }), + ), + Effect.catch((error) => reportError(channelId, error)), + ), + ); + + return Ix.response({ + type: Discord.InteractionCallbackTypes.UPDATE_MESSAGE, + data: { + ...idleMessageFields(messageContent), + }, + }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: `Continue failed: ${error instanceof Error ? error.message : String(error)}`, + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }), + ), + ), + ), + ); + + // `/omegent` and its `/agent` alias share one handler. Discord has no native + // aliases, so each name is a separately registered command; the cast keeps the + // command-spec type constant across both so the single handler type-checks. + const makeSlashCommand = (commandName: string) => + Ix.guild( + { ...OMEGENT_SLASH_COMMAND, name: commandName } as typeof OMEGENT_SLASH_COMMAND, + (ix) => { + const optionString = (name: string): string => { + const value = Option.getOrUndefined(HashMap.get(ix.optionsMap, name)); + return typeof value === "string" ? value : ""; + }; + const optionBoolean = (name: string): boolean => { + // optionsMap is string-typed; read nested option objects for booleans. + // Cast: multi-subcommand root makes typed option names `never` in dfx helpers. + const option = Option.getOrUndefined(ix.option(name as never)); + return option !== undefined && "value" in option && option.value === true; + }; + + const interactionRequester = ( + interaction: Discord.APIInteraction, + ): DiscordMessageLike => { + const user = interaction.member?.user ?? interaction.user; + return { + id: interaction.id, + content: null, + author: { + id: user?.id, + username: user?.username, + displayName: + interaction.member?.nick ?? user?.global_name ?? user?.username ?? undefined, + bot: user?.bot, + }, + timestamp: interaction.id, // snowflake; buildDiscordTurnPrompt only needs identity + }; + }; + + const promptSlashHandler = (forcedDelivery?: "steer" | "queue") => + Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("Ask only works inside a server channel or thread.", { + ephemeral: true, + }); + } + + const prompt = optionString("prompt").trim(); + if (prompt.length === 0) { + return slashReply("Provide a non-empty `prompt`.", { ephemeral: true }); + } + + const model = optionString("model").trim(); + const provider = optionString("provider").trim(); + const base = optionString("base").trim(); + const local = optionBoolean("local"); + const plan = optionBoolean("plan"); + const steer = optionBoolean("steer"); + const queue = optionBoolean("queue"); + // Subcommand force wins; otherwise ask booleans (queue wins if both true). + const followUpDelivery = + forcedDelivery ?? + (queue === true + ? ("queue" as const) + : steer === true + ? ("steer" as const) + : undefined); + const flags = { + ...(model.length > 0 ? { model } : {}), + ...(provider.length > 0 ? { provider } : {}), + ...(base.length > 0 ? { base } : {}), + local, + plan, + ...(followUpDelivery === undefined ? {} : { followUpDelivery }), + prompt, + }; + + const channel = yield* rest.getChannel(channelId); + const inThread = isThreadChannel(channel.type); + const topicLookup = yield* resolveProjectTopic(channel); + const parentUnavailable = topicLookup.kind === "parent-unavailable"; + const parentId = + topicLookup.kind === "parent-unavailable" + ? topicLookup.parentChannelId + : (topicLookup.parentChannelId ?? + (inThread && "parent_id" in channel && typeof channel.parent_id === "string" + ? channel.parent_id + : null)); + const topic = topicLookup.kind === "resolved" ? topicLookup.topic : null; + + // New work needs a topic; continue turns can recover from an existing link. + if (parseTopicShortName(topic) === null) { + const existingLink = inThread ? yield* links.getByDiscordThreadId(channelId) : null; + if (existingLink === null) { + return slashReply(missingProjectBindingMessage({ inThread, parentUnavailable }), { + ephemeral: true, + }); + } + } + + const requester = interactionRequester(interaction); + const displayName = + requester.author?.displayName ?? requester.author?.username ?? "Someone"; + const ack = formatAskSlashAck({ + displayName, + prompt, + plan, + local, + ...(followUpDelivery === undefined ? {} : { followUpDelivery }), + }); + + if (inThread) { + // Fire-and-forget so we ack within Discord's interaction window. + yield* Effect.logInfo( + "Slash /omegent ask: starting bridged turn in linked thread", + { + channelId, + promptPreview: prompt.slice(0, 120), + }, + ); + yield* forkSlashBackground( + startBridgedTurn({ + discordThreadId: channelId, + channelId: parentId ?? channelId, + guildId: interaction.guild_id ?? "", + prompt, + flags, + topic, + ...(parentUnavailable ? { parentUnavailable: true } : {}), + parentChannelId: parentId, + mentionMessage: requester, + }).pipe( + Effect.tap(() => + Effect.logInfo("Slash /omegent ask: bridged turn started in linked thread", { + channelId, + }), + ), + Effect.catch((error) => reportError(channelId, error)), + ), + ); + return slashReply(ack); + } + + // New work from a project channel: seed a public starter message, open a thread. + const starter = yield* rest.createMessage(channelId, { content: ack }); + const discordThread = yield* openOrReuseThread( + channelId, + starter.id, + truncateTitle(prompt), + ); + yield* Effect.logInfo( + "Slash /omegent ask: starting bridged turn in new Discord thread", + { + channelId, + discordThreadId: discordThread.id, + promptPreview: prompt.slice(0, 120), + }, + ); + yield* forkSlashBackground( + startBridgedTurn({ + discordThreadId: discordThread.id, + channelId, + guildId: interaction.guild_id ?? "", + prompt, + flags, + topic, + parentChannelId: channelId, + mentionMessage: { + ...requester, + id: starter.id, + content: ack, + }, + }).pipe( + Effect.tap(() => + Effect.logInfo( + "Slash /omegent ask: bridged turn started in new Discord thread", + { + channelId, + discordThreadId: discordThread.id, + }, + ), + ), + Effect.catch((error) => reportError(discordThread.id, error)), + ), + ); + + const jump = discordChannelUrl(interaction.guild_id, discordThread.id); + return slashReply(`${ack}\n→ ${jump}`); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Ask failed: ${error instanceof Error ? error.message : String(error)}`, + { + ephemeral: true, + }, + ), + ), + ), + ); + + return ix.subCommands({ + ask: promptSlashHandler(), + steer: promptSlashHandler("steer"), + queue: promptSlashHandler("queue"), + + "today-recap": Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("today-recap only works inside a server channel or thread.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + const inThread = isThreadChannel(channel.type); + const topicLookup = yield* resolveProjectTopic(channel); + const parentUnavailable = topicLookup.kind === "parent-unavailable"; + const topic = topicLookup.kind === "resolved" ? topicLookup.topic : null; + const shortName = parseTopicShortName(topic); + if (parentUnavailable || shortName === null) { + return slashReply(missingProjectBindingMessage({ inThread, parentUnavailable }), { + ephemeral: true, + }); + } + + const requester = interactionRequester(interaction); + const access = classifyDiscordAgentAccess({ + people: identityMap.list(), + discordId: requester.author?.id ?? null, + discordUsername: requester.author?.username ?? null, + discordDisplayName: requester.author?.displayName ?? null, + }); + if (!access.allowed) { + return slashReply(access.userMessage, { ephemeral: true }); + } + + const applicationId = interaction.application_id; + const token = interaction.token; + yield* forkSlashBackground( + Effect.gen(function* () { + yield* Effect.sleep("250 millis"); + const date = utcDateStamp(DateTime.formatIso(DateTime.nowUnsafe())); + yield* rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { + content: formatTodayRecapWorking({ shortName, date }), + }, + }) + .pipe( + Effect.catch((error) => + Effect.logWarning("today-recap working status failed", { + shortName, + error: String(error), + }), + ), + ); + const recap = yield* runTodayRecapTurn({ + deliveryChannelId: channelId, + shortName, + topic, + guildId: interaction.guild_id ?? "", + requester, + }); + const chunks = chunkTodayRecapContent(recap); + yield* rest.updateOriginalWebhookMessage(applicationId, token, { + payload: { content: chunks[0] ?? "no change" }, + }); + for (const extra of chunks.slice(1)) { + yield* rest.createMessage(channelId, { content: extra }); + } + }).pipe( + Effect.catch((error: unknown) => + rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { + content: `today-recap failed: ${error instanceof Error ? error.message : String(error)}`, + }, + }) + .pipe(Effect.ignore), + ), + ), + ); + + return slashDefer(); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `today-recap failed: ${error instanceof Error ? error.message : String(error)}`, + { ephemeral: true }, + ), + ), + ), + ), + + steernow: Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("steernow only works inside a linked Discord thread.", { + ephemeral: true, + }); + } + const channel = yield* rest.getChannel(channelId); + if (!isThreadChannel(channel.type)) { + return slashReply("steernow only works inside a linked Discord thread.", { + ephemeral: true, + }); + } + const link = yield* links.getByDiscordThreadId(channelId); + if (link === null) { + return slashReply("This thread is not linked to an Omegent session.", { + ephemeral: true, + }); + } + + // Server snapshot is authoritative after restart; local registry covers + // HTTP lag / soft-failed fetchThreadDetail so just-queued 📥 items still flush. + const detail = yield* t3.fetchThreadDetail(link.t3ThreadId); + const resolved = resolveSteernowMessageIds({ + serverQueued: detail?.thread.queuedMessages ?? [], + localPending: queuedPrompts.listForThread(link.t3ThreadId), + detailLoaded: detail !== null, + }); + if (resolved.messageIds.length === 0) { + return slashReply( + formatSteernowEmptyQueueMessage({ + snapshotMissing: resolved.snapshotMissing, + }), + { ephemeral: true }, + ); + } + + if (resolved.source === "local") { + yield* Effect.logInfo("steernow using local queued-prompt registry fallback", { + t3ThreadId: link.t3ThreadId, + count: resolved.messageIds.length, + snapshotMissing: resolved.snapshotMissing, + }); + } + + let steered = 0; + const failures: string[] = []; + for (const messageId of resolved.messageIds) { + const result = yield* t3 + .steerQueuedMessage({ + threadId: link.t3ThreadId, + messageId, + }) + .pipe(Effect.result); + if (Result.isSuccess(result)) { + steered += 1; + const pending = queuedPrompts.forgetT3Message(link.t3ThreadId, messageId); + if (pending !== null) { + yield* clearQueuedBadge(pending); + } + } else { + failures.push(String(messageId)); + yield* Effect.logWarning("steernow failed for queued message", { + t3ThreadId: link.t3ThreadId, + messageId, + error: String(result.failure), + }); + } + } + + if (steered === 0) { + return slashReply( + `Could not steer the queue (${failures.length} failed). Try again when the turn is running, or use \`/agent steer prompt:…\` to inject a new mid-turn prompt.`, + { ephemeral: true }, + ); + } + const failNote = + failures.length > 0 ? ` (${failures.length} could not be steered yet)` : ""; + return slashReply(`Steered ${steered} queued message(s)${failNote}.`); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `steernow failed: ${error instanceof Error ? error.message : String(error)}`, + { ephemeral: true }, + ), + ), + ), + ), + + help: Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("This command only works inside a server channel or thread.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + const inThread = isThreadChannel(channel.type); + const topicLookup = yield* resolveProjectTopic(channel); + if (topicLookup.kind === "parent-unavailable") { + return slashReply( + missingProjectBindingMessage({ inThread, parentUnavailable: true }), + { + ephemeral: true, + }, + ); + } + const parentId = topicLookup.parentChannelId; + const topic = topicLookup.topic; + const pinChannelId = parentId ?? channelId; + const binding = yield* resolveHelpChannelBinding(pinChannelId, topic); + if (binding.kind === "ok") { + return slashReply( + `Channel info: ${discordMessageUrl(interaction.guild_id, binding.pin.channelId, binding.pin.messageId)}`, + { ephemeral: true }, + ); + } + if (binding.kind === "no-topic") { + return slashReply( + missingProjectBindingMessage({ inThread, parentUnavailable: false }), + { ephemeral: true }, + ); + } + if (binding.kind === "unknown-alias") { + return slashReply( + `Channel topic resolves to alias \`${binding.shortName}\`, but that alias is not in the bot aliases file (\`T3_PROJECT_ALIASES_PATH\`).`, + { ephemeral: true }, + ); + } + if (binding.kind === "t3-connecting") { + return slashReply(T3_STILL_CONNECTING_MESSAGE, { ephemeral: true }); + } + if (binding.kind === "no-project") { + return slashReply( + `Alias \`${binding.shortName}\` → \`${binding.workspaceRoot}\`, but no T3 project is registered at that path.`, + { ephemeral: true }, + ); + } + return slashReply( + `Project \`${binding.shortName}\` is linked, but the channel-info pin could not be refreshed (often: pin content exceeded Discord’s 2000-character limit). Check bot logs for details.`, + { ephemeral: true }, + ); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Help failed: ${error instanceof Error ? error.message : String(error)}`, + { + ephemeral: true, + }, + ), + ), + ), + ), + + stop: Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("Stop only works inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + if (!isThreadChannel(channel.type)) { + return slashReply("Stop is only supported inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const existing = yield* links.getByDiscordThreadId(channelId); + if (existing === null) { + return slashReply( + "This Discord thread is not linked to a T3 thread, so there is nothing to stop.", + { ephemeral: true }, + ); + } + + const threadShell = yield* t3.getThreadShell(existing.t3ThreadId); + if (!hasInterruptibleTurn(threadShell)) { + return slashReply("There is no active turn to stop right now.", { + ephemeral: true, + }); + } + + yield* t3.interrupt(existing.t3ThreadId); + // Public ack so the thread has a shared audit trail. + return slashReply("Stopping the current turn."); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Stop failed: ${error instanceof Error ? error.message : String(error)}`, + { + ephemeral: true, + }, + ), + ), + ), + ), + + compact: Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("Compact only works inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + if (!isThreadChannel(channel.type)) { + return slashReply("Compact is only supported inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const existing = yield* links.getByDiscordThreadId(channelId); + if (existing === null) { + return slashReply( + "This Discord thread is not linked to a T3 thread, so there is nothing to compact.", + { ephemeral: true }, + ); + } + + // Compact can take longer than Discord's ~3s interaction window. + // Public deferred reply → edit with compaction stats for the channel. + const applicationId = interaction.application_id; + const token = interaction.token; + yield* forkSlashBackground( + Effect.gen(function* () { + yield* Effect.sleep("250 millis"); + const content = yield* runContextCompact(existing.t3ThreadId); + yield* rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { content }, + }) + .pipe( + Effect.catch((error) => + Effect.logWarning("Failed to edit deferred compact response", { + channelId, + error: String(error), + }), + ), + ); + }).pipe( + Effect.catchCause((cause) => + rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { + content: `Context compact failed: ${formatAlertCause(cause, 300)}`, + }, + }) + .pipe(Effect.ignore), + ), + ), + ); + + return slashDefer(); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Compact failed: ${error instanceof Error ? error.message : String(error)}`, + { ephemeral: true }, + ), + ), + ), + ), + + "thread-talk": Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply( + "Thread-talk can only be configured inside a linked Discord thread.", + { + ephemeral: true, + }, + ); + } + + // optionsMap flattens nested subcommand options; typed optionValue() is + // fragile across dfx's subcommand inference for multi-subcommand roots. + const actionRaw = + Option.getOrElse(HashMap.get(ix.optionsMap, "action"), () => "") ?? ""; + if (!isThreadTalkSlashAction(actionRaw)) { + return slashReply("Invalid thread-talk action. Use on, off, or status.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + if (!isThreadChannel(channel.type)) { + return slashReply( + "Thread-talk can only be configured inside a linked Discord thread.", + { + ephemeral: true, + }, + ); + } + + const link = yield* links.getByDiscordThreadId(channelId); + if (link === null) { + return slashReply("This Discord thread is not linked to a T3 thread yet.", { + ephemeral: true, + }); + } + + if (actionRaw === "on" || actionRaw === "off") { + yield* links.setThreadTalkMode( + channelId, + actionRaw === "on" ? "all-messages" : null, + ); + } + const enabled = + actionRaw === "on" || actionRaw === "off" + ? actionRaw === "on" + : threadTalkEnabled(link); + + yield* Effect.logInfo("Discord thread-talk mode resolved via slash", { + discordThreadId: channelId, + t3ThreadId: link.t3ThreadId, + enabled, + action: actionRaw, + actorId: interaction.member?.user?.id ?? interaction.user?.id ?? null, + }); + return threadTalkSlashReply({ action: actionRaw, enabled }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Thread-talk failed: ${error instanceof Error ? error.message : String(error)}`, + { ephemeral: true }, + ), + ), + ), + ), + + link: Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("Link only works inside a server channel or thread.", { + ephemeral: true, + }); + } + + const ref = ( + Option.getOrElse(HashMap.get(ix.optionsMap, "ref"), () => "") ?? "" + ).trim(); + const t3ThreadId = extractT3ThreadId(ref); + if (t3ThreadId === null) { + return slashReply( + "Could not parse a T3 thread id from `ref`. Pass a bare id or a T3 URL with `?thread=`.", + { ephemeral: true }, + ); + } + + const channel = yield* rest.getChannel(channelId); + const inThread = isThreadChannel(channel.type); + const topicLookup = yield* resolveProjectTopic(channel); + if (topicLookup.kind === "parent-unavailable") { + return slashReply( + missingProjectBindingMessage({ inThread, parentUnavailable: true }), + { + ephemeral: true, + }, + ); + } + const parentId = topicLookup.parentChannelId; + const topic = topicLookup.topic; + + const summary = yield* linkExistingT3Thread({ + t3ThreadId, + replyChannelId: channelId, + replyToMessageId: null, + guildId: interaction.guild_id ?? "", + topic, + existingDiscordThreadId: inThread ? channelId : null, + parentChannelId: parentId ?? channelId, + replyViaReturn: true, + }); + // Shared link mutations are public. + return slashReply(summary); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Link failed: ${error instanceof Error ? error.message : String(error)}`, + { + ephemeral: true, + }, + ), + ), + ), + ), + + "refresh-indicators": Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("Refresh-indicators only works inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + if (!isThreadChannel(channel.type)) { + return slashReply( + "Refresh-indicators is only supported inside a linked Discord thread.", + { ephemeral: true }, + ); + } + + const existing = yield* links.getByDiscordThreadId(channelId); + if (existing === null) { + return slashReply( + "This Discord thread is not linked to a T3 thread, so there are no indicators to refresh.", + { ephemeral: true }, + ); + } + + // Bridge rehydrate + VCS/PR lookup often exceeds Discord's ~3s interaction window. + // Return DEFERRED immediately; finish work after dfx acks, then edit the original. + const applicationId = interaction.application_id; + const token = interaction.token; + yield* forkSlashBackground( + Effect.gen(function* () { + // Let the deferred interaction response land before webhook edits. + yield* Effect.sleep("250 millis"); + yield* bridgeThreadToDiscord({ + discordChannelId: channelId, + t3ThreadId: existing.t3ThreadId, + mode: "rehydrate", + preferred: true, + lastActivityAt: existing.lastActivityAt, + }); + + const live = + (yield* bridgeHub.getLive(channelId, existing.t3ThreadId)) ?? + (yield* getLiveDiscordBridge(channelId, existing.t3ThreadId)); + const content = + live === null + ? "Could not attach a live bridge for this thread. Try again in a moment." + : yield* live + .refreshThreadIndicators() + .pipe( + Effect.map((result) => + result.ok + ? `Refreshed thread indicators → **${result.title}**` + : `Refresh-indicators failed: ${result.error}`, + ), + ); + + yield* rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { content }, + }) + .pipe( + Effect.catch((error) => + Effect.logWarning("Failed to edit deferred refresh-indicators response", { + channelId, + error: String(error), + }), + ), + ); + }).pipe( + Effect.catchCause((cause) => + rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { + content: `Refresh-indicators failed: ${formatAlertCause(cause, 300)}`, + }, + }) + .pipe(Effect.ignore), + ), + ), + ); + + return slashDefer({ ephemeral: true }); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Refresh-indicators failed: ${error instanceof Error ? error.message : String(error)}`, + { ephemeral: true }, + ), + ), + ), + ), + + assign: Effect.gen(function* () { + const interaction = yield* Ix.Interaction; + const channelId = interaction.channel_id; + if (channelId === undefined || channelId.length === 0) { + return slashReply("Assign only works inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const channel = yield* rest.getChannel(channelId); + if (!isThreadChannel(channel.type)) { + return slashReply("Assign is only supported inside a linked Discord thread.", { + ephemeral: true, + }); + } + + const existing = yield* links.getByDiscordThreadId(channelId); + if (existing === null) { + return slashReply( + "This Discord thread is not linked to a T3 thread, so there are no PRs to assign.", + { ephemeral: true }, + ); + } + + const githubOption = ( + Option.getOrElse(HashMap.get(ix.optionsMap, "github"), () => "") ?? "" + ).trim(); + const requesterId = interaction.member?.user?.id ?? interaction.user?.id ?? null; + const resolved = resolveAssignGithubLogin({ + githubOption: githubOption.length > 0 ? githubOption : undefined, + requesterDiscordId: requesterId, + resolveByDiscordId: (discordId) => identityMap.resolveByDiscordId(discordId), + }); + if (!resolved.ok) { + return slashReply(resolved.message, { ephemeral: true }); + } + + const prUrls = existing.prUrls ?? []; + if (prUrls.length === 0) { + return slashReply( + `No linked pull requests on this thread yet. Open or post a PR first, then run \`/agent assign\`.`, + { ephemeral: true }, + ); + } + + // gh API can exceed Discord's ~3s window when multiple PRs are linked. + const applicationId = interaction.application_id; + const token = interaction.token; + const login = resolved.login; + yield* forkSlashBackground( + Effect.gen(function* () { + yield* Effect.sleep("250 millis"); + // assignPullRequestAssignees is best-effort (per-URL results; does not throw). + const results = yield* Effect.promise(() => + assignPullRequestAssignees({ + prUrls, + login, + }), + ); + const content = formatAssignSlashReply({ login, results }); + yield* Effect.logInfo("Discord slash assign completed", { + discordThreadId: channelId, + t3ThreadId: existing.t3ThreadId, + login, + source: resolved.source, + assigned: results.filter((r) => r.status === "assigned").length, + errors: results.filter((r) => r.status === "error").length, + actorId: requesterId, + }); + yield* rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { content }, + }) + .pipe( + Effect.catch((error) => + Effect.logWarning("Failed to edit deferred assign response", { + channelId, + error: String(error), + }), + ), + ); + }).pipe( + Effect.catchCause((cause) => + rest + .updateOriginalWebhookMessage(applicationId, token, { + payload: { + content: `Assign failed: ${formatAlertCause(cause, 300)}`, + }, + }) + .pipe(Effect.ignore), + ), + ), + ); + + // Public so the thread sees who assigned whom. + return slashDefer(); + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed( + slashReply( + `Assign failed: ${error instanceof Error ? error.message : String(error)}`, + { ephemeral: true }, + ), + ), + ), + ), + }); + }, + ); + + const omegentSlashCommand = makeSlashCommand(OMEGENT_SLASH_COMMAND_NAME); + const agentSlashCommand = makeSlashCommand(OMEGENT_SLASH_COMMAND_ALIAS); + + yield* registry.register( + Ix.builder + .add(omegentSlashCommand) + .add(agentSlashCommand) + .add(approvalButton) + .add(denyButton) + .add(stopButton) + .add(continueButton) + .catchAllCause(Effect.logError) as never, + ); + + yield* Effect.logInfo("Registered Discord slash commands", { + commands: [OMEGENT_SLASH_COMMAND_NAME, OMEGENT_SLASH_COMMAND_ALIAS], + subcommands: OMEGENT_SLASH_COMMAND.options.map((option) => option.name), + scope: "guild", + }); + + // Confirm gateway session is actually up (not only that the handler registered). + yield* Effect.forkScoped( + gateway.handleDispatch("READY", (ready) => + Effect.logInfo("Discord gateway READY", { + user: ready.user?.username, + userId: ready.user?.id, + guilds: Array.isArray(ready.guilds) ? ready.guilds.length : null, + }), + ), + ); + yield* Effect.forkScoped(handleMessages); + yield* Effect.forkScoped(handleMessageUpdates); + yield* Effect.forkScoped(handleMessageDeletes); + yield* Effect.logInfo("Discord mention router ready"); + return DiscordBotRunning.of({ botUserId }); + }); + +export const MentionRouterLive = (botConfig: DiscordBotConfig) => + Layer.effect(DiscordBotRunning, make(botConfig)); diff --git a/apps/discord-bot/src/features/ResponseBridge.test.ts b/apps/discord-bot/src/features/ResponseBridge.test.ts new file mode 100644 index 000000000000..c137133e66b5 --- /dev/null +++ b/apps/discord-bot/src/features/ResponseBridge.test.ts @@ -0,0 +1,2904 @@ +import { MessageId, TurnId, type VcsStatusResult } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + activeStreamTipIdsForDelivery, + activeStreamTipText, + assistantMessagesThisTurn, + bridgeNeedsHttpReconcile, + isDeliveryBehindOrchestration, + isStreamTipDisplacedByForeignMessage, + isStreamTipDisplacedByRecentMessages, + isStreamTipDisplacedByEchoedCommand, + isDiscordEchoedCommandContent, + shouldHopWorkingTipOnDisplacement, + isDiscordContentMessageType, + pickLatestContentMessageId, + deliveryFailureBackoffSeconds, + shouldRetryDeliveryFailure, + BRIDGE_DELIVERY_FAILURE_MAX_RETRIES, + findAlreadyPostedFinalChunkIds, + isAssistantAlreadyFinalizedOnDiscord, + normalizeDiscordContentForIdempotency, + resolveSubscribeAfterSequence, + resolveThreadSubscribeSeed, + trimOrchestrationThreadForDiscordMemory, + DISCORD_DELIVERED_MESSAGE_MEMORY_BUFFER, + SUBSCRIBE_SEQUENCE_BUFFER, + classifyUserMessageIngress, + DISCORD_EXTERNAL_ECHO_SURFACES, + discordBridgeOwnedMessageIds, + externalUserMessagesToEcho, + formatEchoedUserMessage, + isDiscordOriginatedUserPrompt, + isDiscordTasksSidePostContent, + isGitHubOriginatedUserPrompt, + isInternalAgentScaffoldingUserText, + shouldEchoUserMessageToDiscord, + shouldSuppressExternalUserEcho, + firstSnapshotBridgeAction, + pickLatestContentMessage, + nextBridgeStateAfterAdoptWorkingAck, + nextStateAfterMovingWorkingTip, + planStreamTipFreezeOnDisplacement, + resolveThreadTitleChangeRequestFromStatus, + rewriteInlinePathCodeSpansForDiscord, + rewriteMarkdownLocalFileLinksForDiscord, + resolveTaskMessageAction, + seedStreamMessageIds, + shouldArchiveStreamHistory, + shouldDropSeededWorkingAckOnInitialSnapshot, + shouldHoldFreshWorkingAck, + shouldPreserveStreamTipsOnBridgeStop, + shouldPublishRehydrateResumeTip, + shouldRecreateStreamTipOnUpdateFailure, + shouldSkipAlreadyDeliveredAssistant, + shouldReopenFinalizedDelivery, + shouldPublishAssistantUpdate, + startsNewStreamDelivery, + shouldFinalizeStreamBeforeNewDelivery, + streamTipBodyForHeartbeat, + finalAnswerText, + parseDiscordThreadTitleBadgeState, + parseDiscordThreadTitleBadges, + resolveDiscordThreadActivityBadgeState, + resolveDiscordThreadTitleBadgeState, + resolveDiscordThreadTitleBadges, + resolveDiscordTitlePrEvidence, + resolveSettledDiscordThreadTitleUpgrade, + resolveSilentDiscordThreadPrBadge, + resolveTemporaryDiscordThreadTitleBadge, + resolveThreadChangeRequestLookupCwds, + mergeStickyTitlePr, + nextMirroredThreadTitleAfterApply, + planDiscordThreadTitleApply, + shouldApplyDiscordThreadPrBadge, + shouldApplyDiscordThreadTitleBadge, + shouldDeferInitializedPrWhileBusy, + shouldConvertWorkingTipsToWakeUp, + summarizeExternalUserInput, + threadTitleChangeRequestState, + toStickyTitlePrEvidence, +} from "./ResponseBridge.ts"; + +const asMessageId = (value: string): MessageId => MessageId.make(value); +const asTurnId = (value: string): TurnId => TurnId.make(value); +const assistantMessage = ( + id = "assistant-1", + overrides?: Partial<{ + readonly text: string; + readonly turnId: TurnId | null; + }>, +) => ({ + id: asMessageId(id), + role: "assistant" as const, + text: overrides?.text ?? "", + turnId: overrides?.turnId === undefined ? null : overrides.turnId, + streaming: false, + createdAt: "2026-07-19T00:00:00.000Z", + updatedAt: "2026-07-19T00:00:00.000Z", +}); +const userMessage = (id: string) => ({ + id: asMessageId(id), + role: "user" as const, + text: "follow-up", + turnId: null, + streaming: false, + createdAt: "2026-07-19T00:00:00.000Z", + updatedAt: "2026-07-19T00:00:00.000Z", +}); + +const statusWithPr = (overrides?: Partial): VcsStatusResult => ({ + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "feature/thread-title", + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + aheadOfDefaultCount: 0, + pr: { + number: 42, + title: "Thread title badges", + state: "merged", + headRef: "feature/thread-title", + baseRef: "main", + url: "https://github.com/acme/widgets/pull/42", + }, + ...overrides, +}); + +describe("finalAnswerText", () => { + const threadWithTurnBubbles = (texts: ReadonlyArray) => { + const turnId = asTurnId("turn-answer"); + return { + latestTurn: { + turnId, + state: "completed" as const, + requestedAt: "2026-07-20T09:00:00.000Z", + startedAt: "2026-07-20T09:00:00.000Z", + completedAt: "2026-07-20T09:10:00.000Z", + assistantMessageId: asMessageId(`assistant-${texts.length - 1}`), + }, + session: null, + messages: [ + userMessage("user-1"), + ...texts.map((text, index) => assistantMessage(`assistant-${index}`, { text, turnId })), + ], + }; + }; + + it("prefers a substantial last bubble over an earlier longer Findings (draft PR case)", () => { + const findings = "A".repeat(2811); + const draftPr = + "**Draft PR:** https://github.com/example-org/scanner/pull/1950\n\n" + + "### Approach\n" + + "B".repeat(900); + expect(finalAnswerText(threadWithTurnBubbles([findings, draftPr]) as never)).toBe(draftPr); + }); + + it("keeps long Findings when the last bubble is only a short trailer", () => { + const findings = "Findings:\n" + "C".repeat(3200); + const trailer = "Done."; + expect(finalAnswerText(threadWithTurnBubbles([findings, trailer]) as never)).toBe(findings); + }); + + it("returns the only bubble when the turn has a single answer", () => { + const only = "**Draft PR:** https://example.com/pull/1"; + expect(finalAnswerText(threadWithTurnBubbles([only]) as never)).toBe(only); + }); +}); + +describe("assistantMessagesThisTurn", () => { + it("keeps pre-steer assistant progress when a mid-turn user message arrives", () => { + const turnId = asTurnId("turn-1"); + const preSteer = assistantMessage("assistant-pre", { + text: "long pre-steer findings…", + turnId, + }); + const postSteer = assistantMessage("assistant-post", { + text: "ack of follow-up", + turnId, + }); + const thread = { + latestTurn: { + turnId, + state: "running" as const, + requestedAt: "2026-07-19T00:00:00.000Z", + startedAt: "2026-07-19T00:00:00.000Z", + completedAt: null, + assistantMessageId: asMessageId("assistant-post"), + }, + session: { + threadId: "thread-1" as never, + status: "running" as const, + providerName: "codex", + runtimeMode: "default" as const, + activeTurnId: turnId, + lastError: null, + updatedAt: "2026-07-19T00:00:00.000Z", + }, + messages: [userMessage("user-1"), preSteer, userMessage("user-steer"), postSteer], + }; + + // Heuristic "after last user" would drop preSteer; turnId matching keeps it. + expect(assistantMessagesThisTurn(thread as never).map((message) => message.id)).toEqual([ + asMessageId("assistant-pre"), + asMessageId("assistant-post"), + ]); + }); + + it("falls back to after-last-user when turn ids are missing", () => { + const pre = assistantMessage("assistant-old", { text: "old" }); + const post = assistantMessage("assistant-new", { text: "new" }); + const thread = { + latestTurn: null, + session: null, + messages: [userMessage("user-1"), pre, userMessage("user-2"), post], + }; + expect(assistantMessagesThisTurn(thread as never).map((message) => message.id)).toEqual([ + asMessageId("assistant-new"), + ]); + }); + + it("returns empty for a new turn with no assistants yet (does not reuse prior turn bubbles)", () => { + const turn1 = asTurnId("turn-1"); + const turn2 = asTurnId("turn-2"); + const priorAnswer = assistantMessage("assistant-prior", { + text: "Mako Demo is live with the fix…", + turnId: turn1, + }); + const thread = { + latestTurn: { + turnId: turn2, + state: "running" as const, + requestedAt: "2026-07-21T08:30:00.000Z", + startedAt: "2026-07-21T08:30:00.000Z", + completedAt: null, + assistantMessageId: null, + }, + session: { + threadId: "thread-1" as never, + status: "running" as const, + providerName: "codex", + runtimeMode: "default" as const, + activeTurnId: turn2, + lastError: null, + updatedAt: "2026-07-21T08:30:00.000Z", + }, + messages: [ + userMessage("user-1"), + priorAnswer, + userMessage("user-2"), // "so we good, don't care about gist" + ], + }; + + expect(assistantMessagesThisTurn(thread as never)).toEqual([]); + expect(finalAnswerText(thread as never)).toBe(""); + }); +}); + +describe("seedStreamMessageIds", () => { + it("keeps persisted stream tips active instead of marking them stale", () => { + expect( + seedStreamMessageIds({ + workingAckMessageId: "ack-new", + persistedStreamMessageIds: ["tip-1", "tip-2"], + }), + ).toEqual({ + discordMessageIds: ["tip-1", "tip-2", "ack-new"], + staleStreamMessageIds: [], + orphanTipIdsToDelete: [], + }); + }); + + it("dedupes when the working ack is already persisted", () => { + expect( + seedStreamMessageIds({ + workingAckMessageId: "tip-2", + persistedStreamMessageIds: ["tip-1", "tip-2"], + }), + ).toEqual({ + discordMessageIds: ["tip-1", "tip-2"], + staleStreamMessageIds: [], + orphanTipIdsToDelete: [], + }); + }); + + it("works with no working ack", () => { + expect( + seedStreamMessageIds({ + workingAckMessageId: null, + persistedStreamMessageIds: ["tip-1"], + }), + ).toEqual({ + discordMessageIds: ["tip-1"], + staleStreamMessageIds: [], + orphanTipIdsToDelete: [], + }); + }); + + it("discards persisted tips on a fresh Working turn so old bodies are not reused", () => { + expect( + seedStreamMessageIds({ + workingAckMessageId: "ack-new", + persistedStreamMessageIds: ["tip-1", "tip-2"], + discardPersistedTips: true, + }), + ).toEqual({ + discordMessageIds: ["ack-new"], + staleStreamMessageIds: [], + orphanTipIdsToDelete: ["tip-1", "tip-2"], + }); + }); + + it("does not discard persisted tips without a fresh Working ack", () => { + expect( + seedStreamMessageIds({ + workingAckMessageId: null, + persistedStreamMessageIds: ["tip-1"], + discardPersistedTips: true, + }), + ).toEqual({ + discordMessageIds: ["tip-1"], + staleStreamMessageIds: [], + orphanTipIdsToDelete: [], + }); + }); +}); + +describe("activeStreamTipText", () => { + it("returns full text when there is no break", () => { + expect(activeStreamTipText("hello world", "")).toBe("hello world"); + }); + + it("returns only the suffix after a frozen break prefix", () => { + expect(activeStreamTipText("hello world\n\nmore", "hello world")).toBe("more"); + }); + + it("falls back to full text when progress no longer starts with the prefix", () => { + expect(activeStreamTipText("rewritten", "hello")).toBe("rewritten"); + }); +}); + +describe("firstSnapshotBridgeAction", () => { + it("rehydrates a running turn even when the stream looks like it is still streaming", () => { + // Historical bug: isAssistantStreaming is true for any running turn, so + // gating on !streaming made rehydrate-resume dead code. + expect( + firstSnapshotBridgeAction({ + mode: "rehydrate", + turnInProgress: true, + hasContent: true, + alreadyFinalizedOnDiscord: false, + hasOpenTips: true, + }), + ).toBe("rehydrate-resume"); + }); + + it("catch-up finalizes offline-completed turns with open tips", () => { + expect( + firstSnapshotBridgeAction({ + mode: "rehydrate", + turnInProgress: false, + hasContent: true, + alreadyFinalizedOnDiscord: true, + hasOpenTips: true, + }), + ).toBe("catch-up-finalize"); + }); + + it("adopts completed assistants without re-post on interactive open", () => { + expect( + firstSnapshotBridgeAction({ + mode: "interactive", + turnInProgress: false, + hasContent: true, + alreadyFinalizedOnDiscord: true, + hasOpenTips: false, + }), + ).toBe("adopt-completed"); + }); +}); + +describe("shouldDropSeededWorkingAckOnInitialSnapshot", () => { + it("keeps the pre-posted working marker through the first prior-completed snapshot", () => { + expect( + shouldDropSeededWorkingAckOnInitialSnapshot({ + adoptedInitialSnapshot: false, + seededWorkingAckPending: true, + streaming: false, + turnInProgress: false, + }), + ).toBe(false); + }); + + it("keeps the working marker once the new turn is actually running", () => { + expect( + shouldDropSeededWorkingAckOnInitialSnapshot({ + adoptedInitialSnapshot: false, + seededWorkingAckPending: true, + streaming: true, + turnInProgress: true, + }), + ).toBe(false); + }); + + it("does not re-run after the initial snapshot has already been adopted", () => { + expect( + shouldDropSeededWorkingAckOnInitialSnapshot({ + adoptedInitialSnapshot: true, + seededWorkingAckPending: true, + streaming: false, + turnInProgress: false, + }), + ).toBe(false); + }); +}); + +describe("shouldReopenFinalizedDelivery", () => { + it("reopens when the same turn emits a new assistant segment after finalize", () => { + expect( + shouldReopenFinalizedDelivery({ + finalizedTurnId: "turn-1", + currentAssistantMessageId: "assistant-1", + turnId: "turn-1", + nextAssistantMessageId: "assistant-2", + }), + ).toBe(true); + }); + + it("keeps duplicate snapshots of the finalized assistant closed", () => { + expect( + shouldReopenFinalizedDelivery({ + finalizedTurnId: "turn-1", + currentAssistantMessageId: "assistant-1", + turnId: "turn-1", + nextAssistantMessageId: "assistant-1", + }), + ).toBe(false); + }); +}); + +describe("resolveTaskMessageAction", () => { + it("updates the persisted task message when tasks change across turns", () => { + expect( + resolveTaskMessageAction({ + taskDiscordMessageId: "task-message-1", + lastTasksKey: "old-turn-tasks", + nextTasksKey: "new-turn-tasks", + }), + ).toBe("update"); + }); + + it("creates only when no task message has ever been persisted", () => { + expect( + resolveTaskMessageAction({ + taskDiscordMessageId: null, + lastTasksKey: "", + nextTasksKey: "first-tasks", + }), + ).toBe("create"); + }); + + it("skips unchanged task content", () => { + expect( + resolveTaskMessageAction({ + taskDiscordMessageId: "task-message-1", + lastTasksKey: "same-tasks", + nextTasksKey: "same-tasks", + }), + ).toBe("skip"); + }); +}); + +describe("Discord Tasks side-channel (special treatment)", () => { + it("never classifies Tasks side-post bodies as external-echoable user input", () => { + const tasksBody = "**Tasks 1/3**\n◐ Fix the bridge\n○ Add tests\n✅ Ship it"; + expect(isDiscordTasksSidePostContent(tasksBody)).toBe(true); + expect(classifyUserMessageIngress(tasksBody)).toBe("internal"); + expect( + shouldEchoUserMessageToDiscord({ + text: tasksBody, + messageId: "t1", + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }), + ).toBe(false); + }); + + it("includes taskDiscordMessageId among owned ids so Tasks never freeze Working", () => { + const owned = discordBridgeOwnedMessageIds({ + discordMessageIds: ["working-tip"], + taskDiscordMessageId: "tasks-msg", + infoDiscordMessageId: "info-pin", + }); + expect(owned).toContain("tasks-msg"); + expect(owned).toContain("working-tip"); + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "tasks-msg", + streamTipId: "working-tip", + ownedMessageIds: owned, + latestAuthorIsSelfBot: false, + }), + ).toBe(false); + }); +}); + +describe("shouldPublishAssistantUpdate", () => { + it("suppresses only live progress in final-only mode", () => { + expect(shouldPublishAssistantUpdate({ presentationMode: "final-only", streaming: true })).toBe( + false, + ); + expect(shouldPublishAssistantUpdate({ presentationMode: "final-only", streaming: false })).toBe( + true, + ); + }); + + it("keeps live progress in full mode", () => { + expect(shouldPublishAssistantUpdate({ presentationMode: "full", streaming: true })).toBe(true); + }); +}); + +describe("isStreamTipDisplacedByForeignMessage / content message types", () => { + it("treats Default and Reply as content; channel rename/pin as system", () => { + expect(isDiscordContentMessageType(0)).toBe(true); + expect(isDiscordContentMessageType(19)).toBe(true); + expect(isDiscordContentMessageType(undefined)).toBe(true); + expect(isDiscordContentMessageType(4)).toBe(false); // CHANNEL_NAME_CHANGE + expect(isDiscordContentMessageType(6)).toBe(false); // CHANNEL_PINNED_MESSAGE + }); + + it("picks the latest content message, skipping channel renames", () => { + // newest-first + expect( + pickLatestContentMessageId([ + { id: "rename-2", type: 4 }, + { id: "rename-1", type: 4 }, + { id: "tip-1", type: 0 }, + { id: "older", type: 0 }, + ]), + ).toBe("tip-1"); + }); + + it("is not displaced when the tip is still the channel tip", () => { + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "tip-1", + streamTipId: "tip-1", + ownedMessageIds: ["task-1"], + }), + ).toBe(false); + }); + + it("is not displaced when latest is a live Tasks message (bot-owned)", () => { + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "task-1", + streamTipId: "tip-1", + ownedMessageIds: ["task-1", "tip-1"], + }), + ).toBe(false); + }); + + it("is displaced when a human message is newer than the tip", () => { + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "user-1", + streamTipId: "tip-1", + ownedMessageIds: ["task-1", "tip-1"], + }), + ).toBe(true); + }); + + it("is not displaced when latest is another owned stream chunk", () => { + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "tip-2", + streamTipId: "tip-1", + ownedMessageIds: ["tip-1", "tip-2"], + }), + ).toBe(false); + }); +}); + +describe("Working tip hop policy", () => { + it("does not hop Working below casual human chat", () => { + expect(shouldHopWorkingTipOnDisplacement("casual-chat")).toBe(false); + }); + + it("hops Working below an echoed desktop/web/mobile command", () => { + expect(shouldHopWorkingTipOnDisplacement("echoed-command")).toBe(true); + }); +}); + +describe("isDiscordEchoedCommandContent", () => { + it("matches the 💭 from **user@desktop** echo prefix", () => { + expect( + isDiscordEchoedCommandContent( + "💭 from **patroza@desktop**:\nmake CUPSFake its own distinct service", + ), + ).toBe(true); + }); + + it("does not match Tasks or Working bodies", () => { + expect(isDiscordEchoedCommandContent("**Tasks 1/3**\n- [ ] wire CUPS")).toBe(false); + expect(isDiscordEchoedCommandContent("_Working.._")).toBe(false); + }); +}); + +describe("isStreamTipDisplacedByEchoedCommand", () => { + const echo = "💭 from **patroza@desktop**:\nmake CUPSFake its own distinct service"; + + it("hops when an echo sits newer than Working", () => { + expect( + isStreamTipDisplacedByEchoedCommand({ + recentMessagesNewestFirst: [ + { id: "echo-1", type: 0, author: { id: "bot-1" }, content: echo }, + { id: "working-tip", type: 0, author: { id: "bot-1" }, content: "_Working.._" }, + ], + streamTipId: "working-tip", + }), + ).toBe(true); + }); + + it("does not hop for casual human chat below Working", () => { + expect( + isStreamTipDisplacedByEchoedCommand({ + recentMessagesNewestFirst: [ + { id: "human-1", type: 0, author: { id: "user-a" }, content: "side discussion" }, + { id: "working-tip", type: 0, author: { id: "bot-1" }, content: "_Working.._" }, + ], + streamTipId: "working-tip", + }), + ).toBe(false); + }); + + it("does not hop when Working is still the channel tip", () => { + expect( + isStreamTipDisplacedByEchoedCommand({ + recentMessagesNewestFirst: [ + { id: "working-tip", type: 0, author: { id: "bot-1" }, content: "_Working.._" }, + { id: "echo-1", type: 0, author: { id: "bot-1" }, content: echo }, + ], + streamTipId: "working-tip", + }), + ).toBe(false); + }); +}); + +describe("isStreamTipDisplacedByRecentMessages", () => { + const bot = "bot-1"; + const owned = ["working-tip", "tasks-msg", "info-pin"]; + + it("is not displaced when Working is still the channel tip", () => { + expect( + isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [{ id: "working-tip", type: 0, author: { id: bot } }], + streamTipId: "working-tip", + ownedMessageIds: owned, + botUserId: bot, + }), + ).toBe(false); + }); + + it("is not displaced when latest is Tasks with no human after Working", () => { + expect( + isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [ + { id: "tasks-msg", type: 0, author: { id: bot } }, + { id: "working-tip", type: 0, author: { id: bot } }, + ], + streamTipId: "working-tip", + ownedMessageIds: owned, + botUserId: bot, + }), + ).toBe(false); + }); + + it("detects humans between Working and a later Tasks post", () => { + // Working → human chat → channel rename → Tasks. Latest-only missed this. + // Human displacement is detected; hop still requires an echoed command. + expect( + isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [ + { id: "tasks-msg", type: 0, author: { id: bot } }, + { id: "rename", type: 4, author: { id: bot } }, + { id: "human-2", type: 0, author: { id: "user-b" } }, + { id: "human-1", type: 0, author: { id: "user-a" } }, + { id: "working-tip", type: 0, author: { id: bot } }, + ], + streamTipId: "working-tip", + ownedMessageIds: owned, + botUserId: bot, + }), + ).toBe(true); + }); + + it("detects a newer human content message", () => { + expect( + isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [ + { id: "human-1", type: 0, author: { id: "user-a" } }, + { id: "working-tip", type: 0, author: { id: bot } }, + ], + streamTipId: "working-tip", + ownedMessageIds: owned, + botUserId: bot, + }), + ).toBe(true); + }); + + it("is not displaced by channel rename + Tasks after Working", () => { + expect( + isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [ + { id: "tasks-msg", type: 0, author: { id: bot } }, + { id: "rename", type: 4, author: { id: bot } }, + { id: "working-tip", type: 0, author: { id: bot } }, + ], + streamTipId: "working-tip", + ownedMessageIds: owned, + botUserId: bot, + }), + ).toBe(false); + }); + + it("is not displaced when humans are older than Working", () => { + expect( + isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [ + { id: "working-tip", type: 0, author: { id: bot } }, + { id: "human-1", type: 0, author: { id: "user-a" } }, + ], + streamTipId: "working-tip", + ownedMessageIds: owned, + botUserId: bot, + }), + ).toBe(false); + }); +}); + +describe("shouldArchiveStreamHistory", () => { + it("never archives progress for final-only conversational turns", () => { + expect( + shouldArchiveStreamHistory({ + presentationMode: "final-only", + hasStreamMessages: true, + }), + ).toBe(false); + }); + + it("archives tracked progress in full mode", () => { + expect(shouldArchiveStreamHistory({ presentationMode: "full", hasStreamMessages: true })).toBe( + true, + ); + }); +}); + +describe("finalize accept-without-ack idempotency", () => { + it("normalizes Working markers and whitespace", () => { + expect(normalizeDiscordContentForIdempotency("Hello\n\n_Working.._\n")).toBe("Hello"); + expect(normalizeDiscordContentForIdempotency(" a b ")).toBe("a b"); + }); + + it("finds contiguous bot final chunks among recent messages", () => { + const ids = findAlreadyPostedFinalChunkIds({ + botUserId: "bot", + finalChunks: ["Part one", "Part two"], + // newest first (Discord listMessages order) + recentMessages: [ + { id: "m3", authorId: "bot", content: "Part two" }, + { id: "m2", authorId: "bot", content: "Part one" }, + { id: "m1", authorId: "user", content: "hi" }, + ], + }); + expect(ids).toEqual(["m2", "m3"]); + }); + + it("returns null when chunks are incomplete or in the wrong order", () => { + expect( + findAlreadyPostedFinalChunkIds({ + botUserId: "bot", + finalChunks: ["Part one", "Part two"], + recentMessages: [{ id: "m1", authorId: "bot", content: "Part one" }], + }), + ).toBeNull(); + // Wrong chronological order among bot messages (two then one). + expect( + findAlreadyPostedFinalChunkIds({ + botUserId: "bot", + finalChunks: ["Part one", "Part two"], + recentMessages: [ + { id: "m2", authorId: "bot", content: "Part one" }, + { id: "m1", authorId: "bot", content: "Part two" }, + ], + }), + ).toBeNull(); + }); + + it("ignores human messages between bot final chunks when bot order is correct", () => { + expect( + findAlreadyPostedFinalChunkIds({ + botUserId: "bot", + finalChunks: ["Part one", "Part two"], + recentMessages: [ + { id: "m3", authorId: "bot", content: "Part two" }, + { id: "m-x", authorId: "user", content: "interrupt" }, + { id: "m2", authorId: "bot", content: "Part one" }, + ], + }), + ).toEqual(["m2", "m3"]); + }); + + it("excludes stream tip ids from adoption", () => { + expect( + findAlreadyPostedFinalChunkIds({ + botUserId: "bot", + finalChunks: ["Answer"], + excludeMessageIds: ["tip-1"], + recentMessages: [ + { id: "tip-1", authorId: "bot", content: "Answer" }, + { id: "final-1", authorId: "bot", content: "Answer" }, + ], + }), + ).toEqual(["final-1"]); + }); + + it("detects durable or in-memory finalize markers", () => { + expect( + isAssistantAlreadyFinalizedOnDiscord({ + assistantId: "a1", + finalizedTurnId: "t1", + turnId: "t1", + lastFinalizedAssistantId: null, + durableLastFinalizedAssistantId: null, + }), + ).toBe(true); + expect( + isAssistantAlreadyFinalizedOnDiscord({ + assistantId: "a1", + finalizedTurnId: null, + turnId: "t1", + lastFinalizedAssistantId: null, + durableLastFinalizedAssistantId: "a1", + }), + ).toBe(true); + expect( + isAssistantAlreadyFinalizedOnDiscord({ + assistantId: "a1", + finalizedTurnId: null, + turnId: "t1", + lastFinalizedAssistantId: null, + durableLastFinalizedAssistantId: "a0", + }), + ).toBe(false); + }); +}); + +describe("trimOrchestrationThreadForDiscordMemory", () => { + const thread = (messageIds: ReadonlyArray) => + ({ + id: "t1", + messages: messageIds.map((id) => ({ + id, + role: id.startsWith("u") ? "user" : "assistant", + text: id, + turnId: null, + })), + }) as unknown as Parameters[0]["thread"]; + + it("keeps full transcript when nothing is finalized", () => { + const input = thread(["u1", "a1", "u2", "a2"]); + expect( + trimOrchestrationThreadForDiscordMemory({ + thread: input, + lastFinalizedAssistantId: null, + }).messages.map((m) => m.id), + ).toEqual(["u1", "a1", "u2", "a2"]); + }); + + it("drops messages before finalize watermark minus buffer", () => { + const input = thread(["u0", "a0", "u1", "a1", "u2", "a2"]); + expect( + trimOrchestrationThreadForDiscordMemory({ + thread: input, + lastFinalizedAssistantId: "a1", + buffer: DISCORD_DELIVERED_MESSAGE_MEMORY_BUFFER, + }).messages.map((m) => m.id), + ).toEqual(["a0", "u1", "a1", "u2", "a2"]); + }); +}); + +describe("resolveThreadSubscribeSeed", () => { + const warmThread = { id: "t1", messages: [] } as never; + it("prefers warm cache over HTTP", () => { + expect( + resolveThreadSubscribeSeed({ + warm: { snapshotSequence: 50, thread: warmThread }, + afterSequence: 40, + }), + ).toEqual({ kind: "warm", thread: warmThread, afterSequence: 50 }); + }); + + it("falls back to HTTP when warm is missing", () => { + expect( + resolveThreadSubscribeSeed({ + warm: null, + afterSequence: 40, + }), + ).toEqual({ kind: "http", afterSequence: 40 }); + }); + + it("is cold when neither seed is available", () => { + expect(resolveThreadSubscribeSeed({ warm: null, afterSequence: null })).toEqual({ + kind: "cold", + }); + }); +}); + +describe("deliveryFailureBackoffSeconds / shouldRetryDeliveryFailure", () => { + it("backs off exponentially and caps at 30s", () => { + expect(deliveryFailureBackoffSeconds(1)).toBe(2); + expect(deliveryFailureBackoffSeconds(2)).toBe(4); + expect(deliveryFailureBackoffSeconds(3)).toBe(8); + expect(deliveryFailureBackoffSeconds(4)).toBe(16); + expect(deliveryFailureBackoffSeconds(5)).toBe(30); + expect(deliveryFailureBackoffSeconds(10)).toBe(30); + }); + + it("retries up to the max then stops", () => { + expect(shouldRetryDeliveryFailure({ failureCount: 1 })).toBe(true); + expect( + shouldRetryDeliveryFailure({ + failureCount: BRIDGE_DELIVERY_FAILURE_MAX_RETRIES, + }), + ).toBe(true); + expect( + shouldRetryDeliveryFailure({ + failureCount: BRIDGE_DELIVERY_FAILURE_MAX_RETRIES + 1, + }), + ).toBe(false); + }); +}); + +describe("isDeliveryBehindOrchestration", () => { + it("is not lagging when neither cursor is set", () => { + expect( + isDeliveryBehindOrchestration({ + lastDeliveredSequence: null, + lastThreadSnapshotSequence: null, + }), + ).toBe(false); + }); + + it("does not treat unknown delivery cursor as lag (legacy links / first write)", () => { + expect( + isDeliveryBehindOrchestration({ + lastDeliveredSequence: null, + lastThreadSnapshotSequence: 10, + }), + ).toBe(false); + }); + + it("lags when delivery sequence is strictly behind orchestration", () => { + expect( + isDeliveryBehindOrchestration({ + lastDeliveredSequence: 5, + lastThreadSnapshotSequence: 10, + }), + ).toBe(true); + }); + + it("is caught up when cursors match", () => { + expect( + isDeliveryBehindOrchestration({ + lastDeliveredSequence: 10, + lastThreadSnapshotSequence: 10, + }), + ).toBe(false); + }); + + it("is caught up when delivery is ahead (HTTP seed race)", () => { + expect( + isDeliveryBehindOrchestration({ + lastDeliveredSequence: 12, + lastThreadSnapshotSequence: 10, + }), + ).toBe(false); + }); +}); + +describe("resolveSubscribeAfterSequence", () => { + it("returns null when no durable cursors exist (cold subscribe)", () => { + expect( + resolveSubscribeAfterSequence({ + lastDeliveredSequence: null, + lastThreadSnapshotSequence: null, + }), + ).toBeNull(); + }); + + it("prefers delivery cursor so already-synced events are not re-walked", () => { + expect( + resolveSubscribeAfterSequence({ + lastDeliveredSequence: 100, + lastThreadSnapshotSequence: 150, + buffer: 2, + }), + ).toBe(98); + }); + + it("falls back to orchestration cursor when delivery is unknown", () => { + expect( + resolveSubscribeAfterSequence({ + lastDeliveredSequence: null, + lastThreadSnapshotSequence: 40, + buffer: 2, + }), + ).toBe(38); + }); + + it("does not go below zero when buffer exceeds the anchor", () => { + expect( + resolveSubscribeAfterSequence({ + lastDeliveredSequence: 1, + lastThreadSnapshotSequence: 1, + buffer: 5, + }), + ).toBe(0); + }); + + it("uses the default buffer when omitted", () => { + expect( + resolveSubscribeAfterSequence({ + lastDeliveredSequence: 10, + lastThreadSnapshotSequence: 10, + }), + ).toBe(10 - SUBSCRIBE_SEQUENCE_BUFFER); + }); +}); + +describe("bridgeNeedsHttpReconcile", () => { + const idle = { + openStreamTipCount: 0, + seededWorkingAckPending: false, + turnInProgress: false, + awaitingDiscordFinal: false, + }; + + it("is idle when nothing is outstanding", () => { + expect(bridgeNeedsHttpReconcile(idle)).toBe(false); + }); + + it("reconciles while Working tips are open (stuck Working recovery)", () => { + expect(bridgeNeedsHttpReconcile({ ...idle, openStreamTipCount: 1 })).toBe(true); + }); + + it("reconciles while a fresh Working ack is pending", () => { + expect(bridgeNeedsHttpReconcile({ ...idle, seededWorkingAckPending: true })).toBe(true); + }); + + it("reconciles while the T3 turn is still running", () => { + expect(bridgeNeedsHttpReconcile({ ...idle, turnInProgress: true })).toBe(true); + }); + + it("reconciles until Discord has finalized a Discord-originated turn", () => { + expect(bridgeNeedsHttpReconcile({ ...idle, awaitingDiscordFinal: true })).toBe(true); + }); + + it("reconciles when dual-cursor delivery lags orchestration", () => { + expect(bridgeNeedsHttpReconcile({ ...idle, deliveryLagging: true })).toBe(true); + }); +}); + +describe("shouldPreserveStreamTipsOnBridgeStop", () => { + it("preserves tips when the turn is still running", () => { + expect( + shouldPreserveStreamTipsOnBridgeStop({ turnInProgress: true, openStreamTipCount: 1 }), + ).toBe(true); + }); + + it("does not preserve when the turn is idle (safe to clear leftovers)", () => { + expect( + shouldPreserveStreamTipsOnBridgeStop({ turnInProgress: false, openStreamTipCount: 2 }), + ).toBe(false); + }); + + it("does not preserve when there are no open tips", () => { + expect( + shouldPreserveStreamTipsOnBridgeStop({ turnInProgress: true, openStreamTipCount: 0 }), + ).toBe(false); + }); +}); + +describe("streamTipBodyForHeartbeat", () => { + it("suppresses prior-turn body while a fresh Working ack is pending", () => { + expect( + streamTipBodyForHeartbeat({ + seededWorkingAckPending: true, + lastAssistantText: "previous final answer", + streamBreakPrefix: "", + }), + ).toBe(""); + }); + + it("uses current stream body once the Working ack has been claimed by a stream write", () => { + expect( + streamTipBodyForHeartbeat({ + seededWorkingAckPending: false, + lastAssistantText: "live progress", + streamBreakPrefix: "", + }), + ).toContain("live progress"); + }); +}); + +/** + * Behaviour contracts for Working-tip lifecycle. + * These encode the product intent so regressions (prior-turn leak, dark Discord after + * restart, 10008 tip edits) fail tests instead of only showing up in Discord. + */ +describe("Working tip lifecycle contracts", () => { + describe("new user turn on reused bridge (no prior-turn leak)", () => { + it("holds only while Working is pending and the new turn has no assistants yet", () => { + expect( + shouldHoldFreshWorkingAck({ + mode: "interactive", + seededWorkingAckPending: true, + currentTurnAssistantCount: 0, + }), + ).toBe(true); + }); + + it("does not hold once the new turn has assistant content (stream it)", () => { + expect( + shouldHoldFreshWorkingAck({ + mode: "interactive", + seededWorkingAckPending: true, + currentTurnAssistantCount: 1, + }), + ).toBe(false); + }); + + it("does not hold on rehydrate (must catch-up / resume immediately)", () => { + expect( + shouldHoldFreshWorkingAck({ + mode: "rehydrate", + seededWorkingAckPending: true, + currentTurnAssistantCount: 0, + }), + ).toBe(false); + }); + + it("does not hold once stream has claimed the Working ack", () => { + expect( + shouldHoldFreshWorkingAck({ + mode: "interactive", + seededWorkingAckPending: false, + currentTurnAssistantCount: 0, + }), + ).toBe(false); + }); + + it("skips re-post when the latest assistant was already finalized and turn is idle", () => { + expect( + shouldSkipAlreadyDeliveredAssistant({ + assistantId: "assistant-prior", + lastFinalizedAssistantId: "assistant-prior", + turnInProgress: false, + }), + ).toBe(true); + }); + + it("skips the same finalized assistant even while a new turn is running", () => { + // Time-query race: turnInProgress=true with snapshot still showing prior bubble. + expect( + shouldSkipAlreadyDeliveredAssistant({ + assistantId: "assistant-prior", + lastFinalizedAssistantId: "assistant-prior", + turnInProgress: true, + }), + ).toBe(true); + }); + + it("does not skip a new assistant after the previous one was finalized", () => { + expect( + shouldSkipAlreadyDeliveredAssistant({ + assistantId: "assistant-new", + lastFinalizedAssistantId: "assistant-prior", + turnInProgress: false, + }), + ).toBe(false); + }); + + it("adopt Working ack resets prior body and tip ids to only the new ack", () => { + const next = nextBridgeStateAfterAdoptWorkingAck({ + priorDiscordMessageIds: ["old-tip-1", "old-tip-2"], + priorStaleStreamMessageIds: ["stale-a"], + workingAckMessageId: "new-working-ack", + }); + expect(next.discordMessageIds).toEqual(["new-working-ack"]); + expect(next.lastAssistantText).toBe(""); + expect(next.streamBreakPrefix).toBe(""); + expect(next.currentTurnId).toBeNull(); + expect(next.finalizedTurnId).toBeNull(); + expect(next.seededWorkingAckPending).toBe(true); + // Prior tips are frozen as channel history (not live/stale tips). + expect(next.orphanTipsToDelete).toEqual(["old-tip-1", "old-tip-2"]); + expect(next.staleStreamMessageIds).toEqual(["stale-a"]); + }); + + it("mid-turn Working ack adoption freezes old tips and starts a new delivery epoch", () => { + // Expected Discord UX: old tip loses Working+Stop, new Working appears under + // the human mid-turn message, stream continues on the new tip only. + const next = nextBridgeStateAfterAdoptWorkingAck({ + priorDiscordMessageIds: ["working-above-user"], + priorStaleStreamMessageIds: [], + workingAckMessageId: "working-below-user", + }); + expect(next.discordMessageIds).toEqual(["working-below-user"]); + expect(next.orphanTipsToDelete).toEqual(["working-above-user"]); + expect(next.seededWorkingAckPending).toBe(true); + expect( + startsNewStreamDelivery({ + currentTurnId: "same-turn", + nextTurnId: "same-turn", + reopensFinalizedDelivery: false, + seededWorkingAckPending: next.seededWorkingAckPending, + }), + ).toBe(true); + }); + + it("heartbeat never shows previous final answer under a fresh Working ack", () => { + const previousFinal = "**You are right** — fixed and pushed to PR #99"; + expect( + streamTipBodyForHeartbeat({ + seededWorkingAckPending: true, + lastAssistantText: previousFinal, + streamBreakPrefix: "", + }), + ).toBe(""); + }); + + it("starts a new stream delivery when Working ack is pending (not mid-turn edit)", () => { + expect( + startsNewStreamDelivery({ + currentTurnId: "turn-1", + nextTurnId: "turn-1", + reopensFinalizedDelivery: false, + seededWorkingAckPending: true, + }), + ).toBe(true); + }); + + it("starts a new stream delivery when turn id changes", () => { + expect( + startsNewStreamDelivery({ + currentTurnId: "turn-1", + nextTurnId: "turn-2", + reopensFinalizedDelivery: false, + seededWorkingAckPending: false, + }), + ).toBe(true); + }); + + it("continues the same delivery mid-turn without a fresh Working ack", () => { + expect( + startsNewStreamDelivery({ + currentTurnId: "turn-2", + nextTurnId: "turn-2", + reopensFinalizedDelivery: false, + seededWorkingAckPending: false, + }), + ).toBe(false); + }); + + it("finalizes substantial prior tip body before a new delivery (queue-drain race)", () => { + expect( + shouldFinalizeStreamBeforeNewDelivery({ + startsNewDelivery: true, + lastAssistantText: + "**Yes — the bug is almost entirely a naming/dual-use problem.** Rename + return type.", + t3AssistantMessageId: "assistant:run:segment:5", + finalizedTurnId: null, + currentTurnId: "turn-prior", + }), + ).toBe(true); + }); + + it("does not finalize empty Working placeholders before a new delivery", () => { + expect( + shouldFinalizeStreamBeforeNewDelivery({ + startsNewDelivery: true, + lastAssistantText: "_Working.._", + t3AssistantMessageId: "assistant:placeholder", + finalizedTurnId: null, + currentTurnId: "turn-prior", + }), + ).toBe(false); + }); + + it("does not re-finalize when the prior tip turn is already finalized", () => { + expect( + shouldFinalizeStreamBeforeNewDelivery({ + startsNewDelivery: true, + lastAssistantText: "Already posted final answer body", + t3AssistantMessageId: "assistant:run:segment:5", + finalizedTurnId: "turn-prior", + currentTurnId: "turn-prior", + }), + ).toBe(false); + }); + + it("on new delivery keeps only the newest tip slot (avoids 10008 on prior tips)", () => { + const tips = activeStreamTipIdsForDelivery({ + startsNewDelivery: true, + discordMessageIds: ["prior-turn-tip", "fresh-working-ack"], + staleStreamMessageIds: [], + }); + expect(tips.discordMessageIds).toEqual(["fresh-working-ack"]); + expect(tips.staleStreamMessageIds).toEqual(["prior-turn-tip"]); + }); + + it("mid-turn delivery keeps the full tip history for multi-chunk streams", () => { + const tips = activeStreamTipIdsForDelivery({ + startsNewDelivery: false, + discordMessageIds: ["chunk-0", "chunk-1"], + staleStreamMessageIds: ["frozen"], + }); + expect(tips.discordMessageIds).toEqual(["chunk-0", "chunk-1"]); + expect(tips.staleStreamMessageIds).toEqual(["frozen"]); + }); + }); + + describe("bot restart / rehydrate while turn still running", () => { + it("preserves open tips on bridge stop when the turn is in progress", () => { + expect( + shouldPreserveStreamTipsOnBridgeStop({ + turnInProgress: true, + openStreamTipCount: 1, + }), + ).toBe(true); + }); + + it("does not treat preserve-on-stop as an excuse to repaint prior final text", () => { + // Preserve keeps the Discord message id; heartbeat must still not inject old body + // once a *new* Working ack is pending after the next user message. + expect( + shouldPreserveStreamTipsOnBridgeStop({ + turnInProgress: true, + openStreamTipCount: 1, + }), + ).toBe(true); + expect( + streamTipBodyForHeartbeat({ + seededWorkingAckPending: true, + lastAssistantText: "old final from before restart", + streamBreakPrefix: "", + }), + ).toBe(""); + }); + + it("rehydrate of a running turn resumes streaming (not catch-up finalize)", () => { + expect( + firstSnapshotBridgeAction({ + mode: "rehydrate", + turnInProgress: true, + hasContent: false, // tasks-only / tools only — still resume + alreadyFinalizedOnDiscord: false, + hasOpenTips: false, // tips may have been wiped + }), + ).toBe("rehydrate-resume"); + }); + + it("publishes a rehydrate resume tip even with empty progress (Working-only)", () => { + expect( + shouldPublishRehydrateResumeTip({ + presentationMode: "full", + turnInProgress: true, + }), + ).toBe(true); + }); + + it("does not publish rehydrate resume tips in final-only presentation", () => { + expect( + shouldPublishRehydrateResumeTip({ + presentationMode: "final-only", + turnInProgress: true, + }), + ).toBe(false); + }); + + it("catch-up finalizes when the turn completed offline with open tips", () => { + expect( + firstSnapshotBridgeAction({ + mode: "rehydrate", + turnInProgress: false, + hasContent: true, + alreadyFinalizedOnDiscord: false, + hasOpenTips: true, + }), + ).toBe("catch-up-finalize"); + }); + + it("HTTP reconcile stays armed while Working tips are open or turn is running", () => { + expect( + bridgeNeedsHttpReconcile({ + openStreamTipCount: 1, + seededWorkingAckPending: false, + turnInProgress: false, + awaitingDiscordFinal: false, + }), + ).toBe(true); + expect( + bridgeNeedsHttpReconcile({ + openStreamTipCount: 0, + seededWorkingAckPending: false, + turnInProgress: true, + awaitingDiscordFinal: false, + }), + ).toBe(true); + }); + }); + + describe("Discord 10008 Unknown Message on tip update", () => { + it("recreates the tip when update fails and the turn is still running", () => { + expect( + shouldRecreateStreamTipOnUpdateFailure({ + turnInProgress: true, + updateFailed: true, + }), + ).toBe(true); + }); + + it("does not recreate when the turn is idle (avoid ghost Working after settle)", () => { + expect( + shouldRecreateStreamTipOnUpdateFailure({ + turnInProgress: false, + updateFailed: true, + }), + ).toBe(false); + }); + + it("does not recreate when the update succeeded", () => { + expect( + shouldRecreateStreamTipOnUpdateFailure({ + turnInProgress: true, + updateFailed: false, + }), + ).toBe(false); + }); + }); + + describe("seedStreamMessageIds for fresh vs rehydrate", () => { + it("fresh Working turn discards persisted prior-turn tip ids as orphans", () => { + const seeded = seedStreamMessageIds({ + workingAckMessageId: "new-ack", + persistedStreamMessageIds: ["old-1", "old-2"], + discardPersistedTips: true, + }); + expect(seeded.discordMessageIds).toEqual(["new-ack"]); + expect(seeded.orphanTipIdsToDelete).toEqual(["old-1", "old-2"]); + }); + + it("rehydrate keeps persisted tip ids active so mid-turn resume can edit them", () => { + const seeded = seedStreamMessageIds({ + workingAckMessageId: null, + persistedStreamMessageIds: ["running-tip"], + discardPersistedTips: false, + }); + expect(seeded.discordMessageIds).toEqual(["running-tip"]); + expect(seeded.orphanTipIdsToDelete).toEqual([]); + }); + }); +}); + +describe("rewriteMarkdownLocalFileLinksForDiscord", () => { + it("rewrites GitHub-backed local file links to GitHub URLs", () => { + const text = + "[githubLinks.ts](/var/lib/t3/worktrees/t3code/t3-discord-1dd39f28/apps/discord-bot/src/presentation/githubLinks.ts:96)"; + const rewritten = rewriteMarkdownLocalFileLinksForDiscord({ + text, + githubUrlsBySrc: new Map([ + [ + "/var/lib/t3/worktrees/t3code/t3-discord-1dd39f28/apps/discord-bot/src/presentation/githubLinks.ts:96", + "https://github.com/example-org/example-repo/blob/main/apps/discord-bot/src/presentation/githubLinks.ts#L96", + ], + ]), + }); + expect(rewritten).toBe( + "[githubLinks.ts](https://github.com/example-org/example-repo/blob/main/apps/discord-bot/src/presentation/githubLinks.ts#L96)", + ); + }); + + it("keeps attachment fallback text for non-GitHub local files in final messages", () => { + const rewritten = rewriteMarkdownLocalFileLinksForDiscord({ + text: "[report.csv](/tmp/report.csv)", + githubUrlsBySrc: new Map(), + attachedFileNames: new Set(["report.csv"]), + oversizedByName: new Set(), + }); + expect(rewritten).toBe("report.csv (attached below)"); + }); + + it("keeps attachable documents as attachments even when source refs become links", () => { + const rewritten = rewriteMarkdownLocalFileLinksForDiscord({ + text: [ + "[ResponseBridge.ts](/repo/apps/discord-bot/src/features/ResponseBridge.ts:12)", + "[plan.md](/repo/tmp/plan.md)", + ].join("\n"), + githubUrlsBySrc: new Map([ + [ + "/repo/apps/discord-bot/src/features/ResponseBridge.ts:12", + "https://github.com/example-org/example-repo/blob/main/apps/discord-bot/src/features/ResponseBridge.ts#L12", + ], + ]), + attachedFileNames: new Set(["plan.md"]), + oversizedByName: new Set(), + }); + expect(rewritten).toContain( + "[ResponseBridge.ts](https://github.com/example-org/example-repo/blob/main/apps/discord-bot/src/features/ResponseBridge.ts#L12)", + ); + expect(rewritten).toContain("plan.md (attached below)"); + }); +}); + +describe("rewriteInlinePathCodeSpansForDiscord", () => { + it("rewrites inline tracked repo file references to GitHub links", () => { + const rewritten = rewriteInlinePathCodeSpansForDiscord({ + text: [ + "**Files:** `api/src/EasyLife/Standard/resources/RealPacking.ts:37-44`,", + "`api/src/EasyLife/Standard/core/packingCompletion.ts:36-45`", + ].join(" "), + githubUrlsByToken: new Map([ + [ + "api/src/EasyLife/Standard/resources/RealPacking.ts:37-44", + "https://github.com/example-org/example-repo/blob/main/api/src/EasyLife/Standard/resources/RealPacking.ts#L37", + ], + [ + "api/src/EasyLife/Standard/core/packingCompletion.ts:36-45", + "https://github.com/example-org/example-repo/blob/main/api/src/EasyLife/Standard/core/packingCompletion.ts#L36", + ], + ]), + }); + expect(rewritten).toContain( + "[`api/src/EasyLife/Standard/resources/RealPacking.ts:37-44`](https://github.com/example-org/example-repo/blob/main/api/src/EasyLife/Standard/resources/RealPacking.ts#L37)", + ); + expect(rewritten).toContain( + "[`api/src/EasyLife/Standard/core/packingCompletion.ts:36-45`](https://github.com/example-org/example-repo/blob/main/api/src/EasyLife/Standard/core/packingCompletion.ts#L36)", + ); + }); + + it("leaves unmatched inline references untouched", () => { + const text = "**Files:** `tmp/generated-report.html:1-10`"; + expect( + rewriteInlinePathCodeSpansForDiscord({ + text, + githubUrlsByToken: new Map(), + }), + ).toBe(text); + }); +}); + +describe("externalUserMessagesToEcho", () => { + it("includes unseen user messages from other clients", () => { + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("user-1"), + role: "user", + text: "sent from github", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + { + id: MessageId.make("assistant-1"), + role: "assistant", + text: "ack", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:01.000Z", + updatedAt: "2026-07-18T00:00:01.000Z", + }, + ], + observedInitialUserSnapshot: true, + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }); + expect(messages.map((message) => message.id)).toEqual(["user-1"]); + }); + + it("suppresses user messages that the Discord bot just sent into T3", () => { + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("user-1"), + role: "user", + text: "from discord", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + ], + observedInitialUserSnapshot: true, + seenUserMessageIds: [], + sentDiscordUserMessageIds: ["user-1"], + }); + expect(messages).toEqual([]); + }); + + it("suppresses Discord-originated prompts even when sentDiscordUserMessageIds is missing", () => { + // Regression: idle rehydrate / id mismatch used to echo buildDiscordTurnPrompt + // back into Discord as External User Input, freeze the Working tip under that + // bot side-post, and leave the channel desynced while T3 kept working. + const discordPrompt = `## Discord conversation context +- This turn originated from a Discord thread. + +### Current requester +\`\`\`json +{"id":"1"} +\`\`\` + +## User request +fix the bridge desync`; + expect(isDiscordOriginatedUserPrompt(discordPrompt)).toBe(true); + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("user-discord-1"), + role: "user", + text: discordPrompt, + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + { + id: MessageId.make("user-external-1"), + role: "user", + text: "plain input from the web app", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:01.000Z", + updatedAt: "2026-07-18T00:00:01.000Z", + }, + ], + observedInitialUserSnapshot: true, + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }); + expect(messages.map((message) => message.id)).toEqual(["user-external-1"]); + }); + + it("suppresses system-reminder / background-task scaffolding as external input", () => { + // Regression: agent harness injects Background task … + // as user-role text; mirroring it as External User Input is noise and freezes tips. + const systemReminder = ` +Background task "call-caf23c75-09ca-4fc6-a98e-daa9bcaa8e80-41" completed (exit code: 0). +Command: # High-signal PRs for resume/restart/wake continuity +for n in 3677 4229; do gh api "repos/pingdotgg/t3code/pulls/$n"; done +| Duration: 15.2s +Use get_command_or_subagent_output("call-caf23c75-09ca-4fc6-a98e-daa9bcaa8e80-41") to see the full output. +`; + expect(isInternalAgentScaffoldingUserText(systemReminder)).toBe(true); + expect(shouldSuppressExternalUserEcho(systemReminder)).toBe(true); + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("user-sys-1"), + role: "user", + text: systemReminder, + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + { + id: MessageId.make("user-real-1"), + role: "user", + text: "please also check PR 42", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:01.000Z", + updatedAt: "2026-07-18T00:00:01.000Z", + }, + ], + observedInitialUserSnapshot: true, + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }); + expect(messages.map((message) => message.id)).toEqual(["user-real-1"]); + }); + + it("whitelists github + t3-client only (never same-surface discord or internal)", () => { + // Cross-surface policy: Discord echoes other surfaces, not its own ingress or harness. + expect(DISCORD_EXTERNAL_ECHO_SURFACES).toEqual(new Set(["github", "t3-client"])); + + const github = ` + +From GH [octocat](https://github.com/octocat) on [PR #42](https://github.com/acme/widgets/pull/42): investigate the failing check`; + const discord = `## Discord conversation context +### Current requester +## User request +hi from discord`; + const internal = `Background task "x" completed (exit code: 0).`; + const client = "plain note from the web app"; + + expect(classifyUserMessageIngress(github)).toBe("github"); + expect(classifyUserMessageIngress(discord)).toBe("discord"); + expect(classifyUserMessageIngress(internal)).toBe("internal"); + expect(classifyUserMessageIngress(client)).toBe("t3-client"); + expect(isGitHubOriginatedUserPrompt(github)).toBe(true); + + expect( + shouldEchoUserMessageToDiscord({ + text: github, + messageId: "g1", + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }), + ).toBe(true); + expect( + shouldEchoUserMessageToDiscord({ + text: client, + messageId: "c1", + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }), + ).toBe(true); + expect( + shouldEchoUserMessageToDiscord({ + text: discord, + messageId: "d1", + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }), + ).toBe(false); + expect( + shouldEchoUserMessageToDiscord({ + text: internal, + messageId: "i1", + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }), + ).toBe(false); + + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("g1"), + role: "user", + text: github, + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + { + id: MessageId.make("d1"), + role: "user", + text: discord, + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:01.000Z", + updatedAt: "2026-07-18T00:00:01.000Z", + }, + { + id: MessageId.make("i1"), + role: "user", + text: internal, + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:02.000Z", + updatedAt: "2026-07-18T00:00:02.000Z", + }, + { + id: MessageId.make("c1"), + role: "user", + text: client, + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:03.000Z", + updatedAt: "2026-07-18T00:00:03.000Z", + }, + ], + observedInitialUserSnapshot: true, + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }); + expect(messages.map((message) => message.id)).toEqual(["g1", "c1"]); + }); + + it("does not replay already-seen external user messages after resubscribe", () => { + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("user-1"), + role: "user", + text: "already mirrored", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + ], + observedInitialUserSnapshot: true, + seenUserMessageIds: ["user-1"], + sentDiscordUserMessageIds: [], + }); + expect(messages).toEqual([]); + }); + + it("does not replay historical external user messages from the initial snapshot", () => { + const messages = externalUserMessagesToEcho({ + messages: [ + { + id: MessageId.make("user-1"), + role: "user", + text: "historical message", + turnId: null, + streaming: false, + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + }, + ], + observedInitialUserSnapshot: false, + seenUserMessageIds: [], + sentDiscordUserMessageIds: [], + }); + expect(messages).toEqual([]); + }); +}); + +describe("formatEchoedUserMessage", () => { + it("labels cross-client input with its person identity and client channel", () => { + expect( + formatEchoedUserMessage({ + ...userMessage("user-mobile"), + text: "please check the latest build", + source: { + channel: "mobile", + username: "patroza", + }, + }), + ).toBe("💭 from **patroza@mobile**:\nplease check the latest build"); + }); + + it("uses an explicit fallback for legacy messages without provenance", () => { + expect(formatEchoedUserMessage(userMessage("user-legacy"))).toBe( + "💭 from **unknown@unknown**:\nfollow-up", + ); + }); +}); + +describe("nextStateAfterMovingWorkingTip", () => { + it("creates the new tip first conceptually: old ids are returned for delete after create", () => { + const moved = nextStateAfterMovingWorkingTip({ + priorDiscordMessageIds: ["working-above"], + priorStaleStreamMessageIds: ["stale-a"], + newTipIds: ["working-below"], + }); + expect(moved.discordMessageIds).toEqual(["working-below"]); + expect(moved.oldIdsToDelete).toEqual(["working-above"]); + expect(moved.staleStreamMessageIds).toEqual(["stale-a"]); + expect(moved.streamBreakPrefix).toBe(""); + }); + + it("drops deleted ids from stale so finalize does not retry the delete", () => { + const moved = nextStateAfterMovingWorkingTip({ + priorDiscordMessageIds: ["working-above"], + priorStaleStreamMessageIds: ["working-above", "stale-a"], + newTipIds: ["working-below"], + }); + expect(moved.oldIdsToDelete).toEqual(["working-above"]); + expect(moved.staleStreamMessageIds).toEqual(["stale-a"]); + }); + + it("keeps earlier stream chunks when only the live Working tip moves", () => { + const moved = nextStateAfterMovingWorkingTip({ + priorDiscordMessageIds: ["working-above"], + priorStaleStreamMessageIds: [], + newTipIds: ["chunk-1", "working-below"], + }); + expect(moved.discordMessageIds).toEqual(["chunk-1", "working-below"]); + expect(moved.oldIdsToDelete).toEqual(["working-above"]); + }); +}); + +describe("planStreamTipFreezeOnDisplacement", () => { + it("does not hide in-flight body when freezing an empty Working tip (mid-turn human reply)", () => { + // Production: Working.. never got prose painted; human mid-turn mention displaced the + // tip. Old code set breakPrefix = fullDisplayText so post-break tip was empty forever. + const plan = planStreamTipFreezeOnDisplacement({ + previousFullDisplayText: "", + previousTipBody: "", + previousLastAssistantText: "", + }); + expect(plan.freezeContent).toBeNull(); + expect(plan.nextBreakPrefix).toBe(""); + expect(plan.nextLastAssistantText).toBe(""); + // Current write must paint fully under the user message. + expect(activeStreamTipText("I'll find how the web UI handles…", plan.nextBreakPrefix)).toBe( + "I'll find how the web UI handles…", + ); + }); + + it("freezes already-shown prose and only posts the delta post-break", () => { + const shown = "I'll find how the web UI handles the wake-up status."; + const plan = planStreamTipFreezeOnDisplacement({ + previousFullDisplayText: shown, + previousTipBody: shown, + previousLastAssistantText: shown, + }); + expect(plan.freezeContent).toBe(shown); + expect(plan.nextBreakPrefix).toBe(shown); + expect(plan.nextLastAssistantText).toBe(shown); + const next = `${shown}\n\nUpdated plan: add a blue Continue button.`; + expect(activeStreamTipText(next, plan.nextBreakPrefix)).toBe( + "Updated plan: add a blue Continue button.", + ); + }); +}); + +describe("isStreamTipDisplacedByForeignMessage self-bot side posts", () => { + it("does not freeze the Working tip when the latest content message is our bot", () => { + // External User Input / Tasks echoes are bot-authored; without this guard they + // stole tip ownership and left Discord on a frozen Working body while T3 advanced. + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "external-echo-1", + streamTipId: "working-tip", + ownedMessageIds: ["working-tip"], + latestAuthorIsSelfBot: true, + }), + ).toBe(false); + }); + + it("still freezes when a human reply is newer than the tip", () => { + expect( + isStreamTipDisplacedByForeignMessage({ + latestMessageId: "human-1", + streamTipId: "working-tip", + ownedMessageIds: ["working-tip"], + latestAuthorIsSelfBot: false, + }), + ).toBe(true); + }); + + it("pickLatestContentMessage returns author for self-bot checks", () => { + const latest = pickLatestContentMessage([ + { id: "rename", type: 4, author: { id: "bot" } }, + { id: "echo", type: 0, author: { id: "bot" } }, + ]); + expect(latest?.id).toBe("echo"); + expect(latest?.author?.id).toBe("bot"); + }); +}); + +describe("summarizeExternalUserInput", () => { + it("drops leading HTML comment sections and preserves the visible linked header", () => { + expect( + summarizeExternalUserInput(` + +From GH [octocat](https://github.com/octocat) on [PR #42](https://github.com/acme/widgets/pull/42): investigate the failing check`), + ).toBe( + "From GH [octocat](https://github.com/octocat) on [PR #42](https://github.com/acme/widgets/pull/42): investigate the failing check", + ); + }); + + it("drops HTML comment sections and preserves the visible linked header", () => { + expect( + summarizeExternalUserInput(`From GH [octocat](https://github.com/octocat) on [PR #42](https://github.com/acme/widgets/pull/42): investigate the failing check + +`), + ).toBe( + "From GH [octocat](https://github.com/octocat) on [PR #42](https://github.com/acme/widgets/pull/42): investigate the failing check", + ); + }); + + it("falls back to the raw text when no summary marker is present", () => { + expect(summarizeExternalUserInput("plain external input")).toBe("plain external input"); + }); + + it("strips system-reminder envelopes from echoed text", () => { + expect( + summarizeExternalUserInput(`prefix + +Background task "x" completed (exit code: 0). + +suffix`), + ).toBe("prefix\n\nsuffix"); + }); +}); + +describe("threadTitleChangeRequestState", () => { + it("returns null when the thread has no branch-backed worktree context", () => { + expect( + threadTitleChangeRequestState( + { + branch: null, + worktreePath: "/tmp/worktree", + messages: [assistantMessage()], + }, + { state: "open" }, + ), + ).toBeNull(); + expect( + threadTitleChangeRequestState( + { + branch: "feature/thread-title", + worktreePath: null, + messages: [assistantMessage()], + }, + { state: "open" }, + ), + ).toBeNull(); + }); + + it("returns null until the thread has a real assistant response", () => { + expect( + threadTitleChangeRequestState( + { branch: "feature/thread-title", worktreePath: "/tmp/worktree", messages: [] }, + { state: "open" }, + ), + ).toBeNull(); + }); + + it("passes through open and merged pull request states for linked worktrees", () => { + expect( + threadTitleChangeRequestState( + { + branch: "feature/thread-title", + worktreePath: "/tmp/worktree", + messages: [assistantMessage()], + }, + { state: "open" }, + ), + ).toBe("open"); + expect( + threadTitleChangeRequestState( + { + branch: "feature/thread-title", + worktreePath: "/tmp/worktree", + messages: [assistantMessage()], + }, + { state: "merged" }, + ), + ).toBe("merged"); + }); + + it("uses the initialized state for assistant-backed threads with no PR", () => { + expect( + threadTitleChangeRequestState( + { + branch: "feature/thread-title", + worktreePath: "/tmp/worktree", + messages: [assistantMessage()], + }, + null, + ), + ).toBe("initialized"); + }); +}); + +describe("resolveSettledDiscordThreadTitleUpgrade", () => { + it("upgrades a plain settled title once the worktree thread has an assistant message", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Link Discord to T3 thread", + branch: "t3-discord/23df93db", + worktreePath: "/var/lib/t3/worktrees/t3code/t3-discord-23df93db", + messages: [assistantMessage()], + }, + mirroredThreadTitle: "Link Discord to T3 thread", + attemptedThreadTitle: "Link Discord to T3 thread", + cachedPr: null, + }), + ).toBe("▫️ Link Discord to T3 thread"); + }); + + it("returns null when still waiting for an assistant response", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Link Discord to T3 thread", + branch: "t3-discord/23df93db", + worktreePath: "/var/lib/t3/worktrees/t3code/t3-discord-23df93db", + messages: [], + }, + mirroredThreadTitle: "Link Discord to T3 thread", + attemptedThreadTitle: "Link Discord to T3 thread", + cachedPr: null, + }), + ).toBeNull(); + }); + + it("returns null when the initialized badge is already mirrored", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Link Discord to T3 thread", + branch: "t3-discord/23df93db", + worktreePath: "/var/lib/t3/worktrees/t3code/t3-discord-23df93db", + messages: [assistantMessage()], + }, + mirroredThreadTitle: "▫️ Link Discord to T3 thread", + attemptedThreadTitle: "▫️ Link Discord to T3 thread", + cachedPr: null, + }), + ).toBeNull(); + }); + + it("upgrades when cached VCS status later reports an open PR", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Verify PROJ-378 PR readiness", + branch: "t3-discord/91dbe634", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-91dbe634", + messages: [assistantMessage()], + }, + mirroredThreadTitle: "▫️ Verify PROJ-378 PR readiness", + attemptedThreadTitle: "▫️ Verify PROJ-378 PR readiness", + cachedPr: { state: "open", hasFailingChecks: false }, + }), + ).toBe("🔀 Verify PROJ-378 PR readiness"); + }); + + it("does not demote an open PR badge to initialized when PR cache is briefly null", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + }, + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + attemptedThreadTitle: "🔀 Empasa pickup carrier rollout", + cachedPr: null, + }), + ).toBeNull(); + }); + + it("keeps open PR and adds wake-required activity when interrupted mid-turn", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "interrupted", activeTurnId: null } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + completedAt: null, + } as never, + }, + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + attemptedThreadTitle: "🔀 Empasa pickup carrier rollout", + cachedPr: { state: "open", hasFailingChecks: false }, + }), + ).toBe("🔀 ❗ Empasa pickup carrier rollout"); + }); + + it("keeps open PR and adds busy activity while a turn is Working", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "running", activeTurnId: "turn-1" } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + completedAt: null, + } as never, + }, + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + attemptedThreadTitle: "🔀 Empasa pickup carrier rollout", + cachedPr: { state: "open", hasFailingChecks: false }, + }), + ).toBe("🔀 ⏳ Empasa pickup carrier rollout"); + }); + + it("clears busy activity and keeps the PR badge when a turn settles", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "ready", activeTurnId: null } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "completed", + completedAt: "2026-07-01T00:00:00.000Z", + } as never, + }, + mirroredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + attemptedThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + cachedPr: { state: "open", hasFailingChecks: false }, + }), + ).toBe("🔀 Empasa pickup carrier rollout"); + }); + + it("restores initialized when busy settles with confirmed no-PR evidence", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "ready", activeTurnId: null } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "completed", + completedAt: "2026-07-01T00:00:00.000Z", + } as never, + }, + mirroredThreadTitle: "⏳ Empasa pickup carrier rollout", + attemptedThreadTitle: "⏳ Empasa pickup carrier rollout", + cachedPr: null, + canApplyNoPrBadge: true, + }), + ).toBe("▫️ Empasa pickup carrier rollout"); + }); + + it("does not paint ▫️ when busy settles but no-PR is still unconfirmed", () => { + // Activity clears → plain title is ok; without canApplyNoPrBadge we keep no PR column. + // Mirrored was activity-only, so desired becomes plain title (no badges). + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "ready", activeTurnId: null } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "completed", + completedAt: "2026-07-01T00:00:00.000Z", + } as never, + }, + mirroredThreadTitle: "⏳ Empasa pickup carrier rollout", + attemptedThreadTitle: "⏳ Empasa pickup carrier rollout", + cachedPr: null, + canApplyNoPrBadge: false, + }), + ).toBe("Empasa pickup carrier rollout"); + }); + + it("retries dual busy title when attempted was poisoned by a failed rename", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "running", activeTurnId: "turn-1" } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + completedAt: null, + } as never, + }, + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + attemptedThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + cachedPr: { state: "open", hasFailingChecks: false }, + }), + ).toBe("🔀 ⏳ Empasa pickup carrier rollout"); + }); + + it("does not thrash-rename ⏳ → ▫️ ⏳ while still busy after no-PR is confirmed", () => { + // Turn start painted activity-only; VCS later confirms no PR. Second rename to + // ▫️ ⏳ is pure channel noise — settle will paint ▫️ when busy clears. + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "for pr 2101, i wish we could push freely to draft PRs", + branch: "t3-discord/pr-2101-draft-pushes", + worktreePath: "/var/lib/t3/worktrees/t3code/t3-discord-6c17cdca", + messages: [assistantMessage()], + session: { status: "running", activeTurnId: "turn-1" } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + completedAt: null, + } as never, + }, + mirroredThreadTitle: "⏳ for pr 2101, i wish we could push freely to draft PRs", + attemptedThreadTitle: "⏳ for pr 2101, i wish we could push freely to draft PRs", + cachedPr: null, + canApplyNoPrBadge: true, + }), + ).toBeNull(); + }); + + it("still paints ▫️ ⏳ in one shot when busy starts on a plain title with no-PR known", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "for pr 2101, i wish we could push freely to draft PRs", + branch: "t3-discord/pr-2101-draft-pushes", + worktreePath: "/var/lib/t3/worktrees/t3code/t3-discord-6c17cdca", + messages: [assistantMessage()], + session: { status: "running", activeTurnId: "turn-1" } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + completedAt: null, + } as never, + }, + mirroredThreadTitle: "for pr 2101, i wish we could push freely to draft PRs", + attemptedThreadTitle: "for pr 2101, i wish we could push freely to draft PRs", + cachedPr: null, + canApplyNoPrBadge: true, + }), + ).toBe("▫️ ⏳ for pr 2101, i wish we could push freely to draft PRs"); + }); + + it("still upgrades ⏳ → 🔀 ⏳ mid-turn when a real PR appears", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Empasa pickup carrier rollout", + branch: "t3-discord/empasa-pickup-carrier", + worktreePath: "/var/lib/t3/worktrees/scanner/t3-discord-c434b753", + messages: [assistantMessage()], + session: { status: "running", activeTurnId: "turn-1" } as never, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + completedAt: null, + } as never, + }, + mirroredThreadTitle: "⏳ Empasa pickup carrier rollout", + attemptedThreadTitle: "⏳ Empasa pickup carrier rollout", + cachedPr: { state: "open", hasFailingChecks: false }, + }), + ).toBe("🔀 ⏳ Empasa pickup carrier rollout"); + }); +}); + +describe("shouldDeferInitializedPrWhileBusy / resolveSilentDiscordThreadPrBadge", () => { + it("defers only the no-PR badge while busy is unchanged", () => { + expect( + shouldDeferInitializedPrWhileBusy({ + currentPr: null, + nextPr: "initialized", + currentActivity: "busy", + nextActivity: "busy", + }), + ).toBe(true); + expect( + resolveSilentDiscordThreadPrBadge({ + currentPr: null, + nextPr: "initialized", + currentActivity: "busy", + nextActivity: "busy", + }), + ).toBeNull(); + }); + + it("does not defer when painting dual badges from a plain title", () => { + expect( + shouldDeferInitializedPrWhileBusy({ + currentPr: null, + nextPr: "initialized", + currentActivity: null, + nextActivity: "busy", + }), + ).toBe(false); + expect( + resolveSilentDiscordThreadPrBadge({ + currentPr: null, + nextPr: "initialized", + currentActivity: null, + nextActivity: "busy", + }), + ).toBe("initialized"); + }); + + it("does not defer real PR upgrades or settle (busy → idle)", () => { + expect( + shouldDeferInitializedPrWhileBusy({ + currentPr: null, + nextPr: "open", + currentActivity: "busy", + nextActivity: "busy", + }), + ).toBe(false); + expect( + shouldDeferInitializedPrWhileBusy({ + currentPr: null, + nextPr: "initialized", + currentActivity: "busy", + nextActivity: null, + }), + ).toBe(false); + expect( + resolveSilentDiscordThreadPrBadge({ + currentPr: null, + nextPr: "initialized", + currentActivity: "busy", + nextActivity: null, + }), + ).toBe("initialized"); + }); +}); + +describe("planDiscordThreadTitleApply", () => { + it("applies a freshly computed title that Discord does not have yet", () => { + expect( + planDiscordThreadTitleApply({ + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + pendingDesiredThreadTitle: null, + computedDesiredTitle: "🔀 ⏳ Empasa pickup carrier rollout", + }), + ).toEqual({ + pendingDesiredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + applyTitle: "🔀 ⏳ Empasa pickup carrier rollout", + }); + }); + + it("clears pending when compute says Discord already matches", () => { + expect( + planDiscordThreadTitleApply({ + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + computedDesiredTitle: "🔀 Empasa pickup carrier rollout", + }), + ).toEqual({ + pendingDesiredThreadTitle: null, + applyTitle: null, + }); + }); + + it("retries a prior failed rename when compute has nothing new", () => { + // Turn settled, secondary timed out mid-rename — heartbeat must re-apply settle. + expect( + planDiscordThreadTitleApply({ + mirroredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 Empasa pickup carrier rollout", + computedDesiredTitle: null, + }), + ).toEqual({ + pendingDesiredThreadTitle: "🔀 Empasa pickup carrier rollout", + applyTitle: "🔀 Empasa pickup carrier rollout", + }); + }); + + it("does not re-apply when mirrored already matches pending", () => { + expect( + planDiscordThreadTitleApply({ + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 Empasa pickup carrier rollout", + computedDesiredTitle: null, + }), + ).toEqual({ + pendingDesiredThreadTitle: null, + applyTitle: null, + }); + }); + + it("prefers a newer computed settle over a stale pending busy title", () => { + // VCS raced with settle: pending still wants ⏳, compute now wants settled. + expect( + planDiscordThreadTitleApply({ + mirroredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + computedDesiredTitle: "🔀 Empasa pickup carrier rollout", + }), + ).toEqual({ + pendingDesiredThreadTitle: "🔀 Empasa pickup carrier rollout", + applyTitle: "🔀 Empasa pickup carrier rollout", + }); + }); +}); + +describe("nextMirroredThreadTitleAfterApply", () => { + it("keeps pending and leaves mirrored unchanged on REST failure", () => { + expect( + nextMirroredThreadTitleAfterApply({ + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + appliedTitle: "🔀 ⏳ Empasa pickup carrier rollout", + success: false, + }), + ).toEqual({ + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + attemptedThreadTitle: null, + }); + }); + + it("updates mirrored and clears matching pending on success", () => { + expect( + nextMirroredThreadTitleAfterApply({ + mirroredThreadTitle: "🔀 ⏳ Empasa pickup carrier rollout", + pendingDesiredThreadTitle: "🔀 Empasa pickup carrier rollout", + appliedTitle: "🔀 Empasa pickup carrier rollout", + success: true, + }), + ).toEqual({ + mirroredThreadTitle: "🔀 Empasa pickup carrier rollout", + pendingDesiredThreadTitle: null, + attemptedThreadTitle: "🔀 Empasa pickup carrier rollout", + }); + }); +}); + +describe("resolveTemporaryDiscordThreadTitleBadge", () => { + it("returns busy while a turn is Working", () => { + expect( + resolveTemporaryDiscordThreadTitleBadge({ + sessionStatus: "running", + latestTurnState: "running", + }), + ).toBe("busy"); + }); + + it("returns wake-required for a real mid-turn interrupt", () => { + expect( + resolveTemporaryDiscordThreadTitleBadge({ + sessionStatus: "interrupted", + latestTurnState: "running", + }), + ).toBe("wake-required"); + }); + + it("returns null when idle so the PR path can paint sticky badges", () => { + expect( + resolveTemporaryDiscordThreadTitleBadge({ + sessionStatus: "ready", + latestTurnState: "completed", + latestTurnCompletedAt: "2026-07-01T00:00:00.000Z", + }), + ).toBeNull(); + }); +}); + +describe("shouldApplyDiscordThreadTitleBadge", () => { + it("allows plain → initialized → open → merged", () => { + expect(shouldApplyDiscordThreadTitleBadge(null, "initialized")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("initialized", "open")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("open", "merged")).toBe(true); + }); + + it("refuses open → initialized / plain demotion (flip-flop)", () => { + expect(shouldApplyDiscordThreadTitleBadge("open", "initialized")).toBe(false); + expect(shouldApplyDiscordThreadTitleBadge("open", null)).toBe(false); + expect(shouldApplyDiscordThreadTitleBadge("merged", "initialized")).toBe(false); + }); + + it("always allows applying and clearing wake-required (sticky over git/PR while active)", () => { + expect(shouldApplyDiscordThreadTitleBadge("open", "wake-required")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("merged", "wake-required")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("wake-required", "open")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("wake-required", "initialized")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("wake-required", null)).toBe(true); + }); + + it("always allows applying and clearing busy (Working..) over git/PR badges", () => { + expect(shouldApplyDiscordThreadTitleBadge("open", "busy")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("initialized", "busy")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("merged", "busy")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("busy", "open")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("busy", "initialized")).toBe(true); + expect(shouldApplyDiscordThreadTitleBadge("busy", null)).toBe(true); + }); + + it("parses dual-slot and legacy badge prefixes from mirrored Discord titles", () => { + expect(parseDiscordThreadTitleBadges("🔀 ⏳ Empasa pickup carrier rollout")).toEqual({ + pr: "open", + activity: "busy", + }); + expect(parseDiscordThreadTitleBadges("❌ ❗ Empasa pickup carrier rollout")).toEqual({ + pr: "open", + activity: "wake-required", + }); + // Legacy dual ❌ 🔀 still parses as open. + expect(parseDiscordThreadTitleBadges("❌ 🔀 Empasa pickup carrier rollout")).toEqual({ + pr: "open", + activity: null, + }); + expect(parseDiscordThreadTitleBadgeState("🔀 Empasa pickup carrier rollout")).toBe("open"); + expect(parseDiscordThreadTitleBadgeState("❌ Empasa pickup carrier rollout")).toBe("open"); + expect(parseDiscordThreadTitleBadgeState("❌ 🔀 Empasa pickup carrier rollout")).toBe("open"); + expect(parseDiscordThreadTitleBadgeState("❗ Empasa pickup carrier rollout")).toBe( + "wake-required", + ); + expect(parseDiscordThreadTitleBadgeState("⏳ Empasa pickup carrier rollout")).toBe("busy"); + expect(parseDiscordThreadTitleBadgeState("▫️ Empasa pickup carrier rollout")).toBe( + "initialized", + ); + expect(parseDiscordThreadTitleBadgeState("Empasa pickup carrier rollout")).toBeNull(); + }); + + it("shouldApplyDiscordThreadPrBadge refuses open → initialized demotion", () => { + expect(shouldApplyDiscordThreadPrBadge("open", "initialized")).toBe(false); + expect(shouldApplyDiscordThreadPrBadge("open", "merged")).toBe(true); + }); +}); + +describe("resolveDiscordThreadTitleBadges", () => { + it("keeps PR and activity independent (client-style dual indicators)", () => { + expect( + resolveDiscordThreadTitleBadges({ + sessionStatus: "running", + latestTurnState: "running", + prState: "open", + }), + ).toEqual({ pr: "open", activity: "busy" }); + expect( + resolveDiscordThreadTitleBadges({ + sessionStatus: "interrupted", + latestTurnState: "running", + prState: "open", + }), + ).toEqual({ pr: "open", activity: "wake-required" }); + expect( + resolveDiscordThreadTitleBadges({ + sessionStatus: "ready", + prState: "open", + }), + ).toEqual({ pr: "open", activity: null }); + }); +}); + +describe("resolveDiscordThreadTitleBadgeState", () => { + it("legacy exclusive API prefers activity over PR", () => { + expect( + resolveDiscordThreadTitleBadgeState({ + sessionStatus: "interrupted", + latestTurnState: "running", + prState: "open", + }), + ).toBe("wake-required"); + expect( + resolveDiscordThreadTitleBadgeState({ + sessionStatus: "running", + latestTurnState: "running", + prState: "open", + }), + ).toBe("busy"); + }); + + it("returns activity busy when session is starting with no turn yet", () => { + expect( + resolveDiscordThreadActivityBadgeState({ + sessionStatus: "starting", + latestTurnState: null, + }), + ).toBe("busy"); + }); + + it("keeps PR state for zombie interrupted sessions with a completed turn", () => { + expect( + resolveDiscordThreadTitleBadgeState({ + sessionStatus: "interrupted", + latestTurnState: "completed", + latestTurnCompletedAt: "2026-07-01T00:00:00.000Z", + prState: "open", + }), + ).toBe("open"); + }); + + it("returns PR state once the session is no longer interrupted", () => { + expect( + resolveDiscordThreadTitleBadgeState({ + sessionStatus: "ready", + prState: "open", + }), + ).toBe("open"); + }); +}); + +describe("shouldConvertWorkingTipsToWakeUp", () => { + it("converts open Working tips when a mid-turn session is interrupted", () => { + expect( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: "interrupted", + latestTurnState: "running", + turnInProgress: false, + openStreamTipCount: 1, + wakeUpNoticePosted: false, + }), + ).toBe(true); + }); + + it("does not convert zombie interrupted sessions or empty tips", () => { + expect( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: "interrupted", + latestTurnState: "completed", + latestTurnCompletedAt: "2026-07-01T00:00:00.000Z", + turnInProgress: false, + openStreamTipCount: 1, + wakeUpNoticePosted: false, + }), + ).toBe(false); + expect( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: "interrupted", + latestTurnState: "running", + turnInProgress: false, + openStreamTipCount: 1, + wakeUpNoticePosted: true, + }), + ).toBe(false); + expect( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: "interrupted", + latestTurnState: "running", + turnInProgress: true, + openStreamTipCount: 1, + wakeUpNoticePosted: false, + }), + ).toBe(false); + expect( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: "interrupted", + latestTurnState: "running", + turnInProgress: false, + openStreamTipCount: 0, + wakeUpNoticePosted: false, + }), + ).toBe(false); + expect( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: "ready", + latestTurnState: "running", + turnInProgress: false, + openStreamTipCount: 1, + wakeUpNoticePosted: false, + }), + ).toBe(false); + }); +}); + +describe("resolveThreadTitleChangeRequestFromStatus", () => { + it("reuses the shared VCS status PR when it belongs to the thread branch", () => { + expect( + resolveThreadTitleChangeRequestFromStatus({ branch: "feature/thread-title" }, statusWithPr()), + ).toMatchObject({ number: 42, state: "merged" }); + }); + + it("ignores PRs from unrelated branches", () => { + expect( + resolveThreadTitleChangeRequestFromStatus( + { branch: "feature/thread-title" }, + statusWithPr({ + refName: "feature/other-branch", + pr: { ...statusWithPr().pr!, headRef: "feature/other-branch" }, + }), + ), + ).toBeNull(); + }); +}); + +describe("mergeStickyTitlePr / resolveDiscordTitlePrEvidence", () => { + it("keeps sticky PR when the next observation is null (unknown)", () => { + const sticky = { state: "open" as const, number: 9, hasFailingChecks: true }; + expect(mergeStickyTitlePr(sticky, null)).toEqual(sticky); + expect(mergeStickyTitlePr(sticky, undefined)).toEqual(sticky); + }); + + it("keeps hasFailingChecks=true for the same open PR until explicit false", () => { + const sticky = { state: "open" as const, number: 9, hasFailingChecks: true }; + expect(mergeStickyTitlePr(sticky, { state: "open", number: 9 })).toEqual({ + state: "open", + number: 9, + hasFailingChecks: true, + }); + expect( + mergeStickyTitlePr(sticky, { state: "open", number: 9, hasFailingChecks: false }), + ).toEqual({ + state: "open", + number: 9, + hasFailingChecks: false, + }); + }); + + it("does not allow no-PR (▫️) badge until remote status is observed", () => { + expect( + resolveDiscordTitlePrEvidence({ + stickyPr: null, + statusPr: null, + remoteStatusObserved: false, + }), + ).toEqual({ + stickyPr: null, + effectivePr: null, + canApplyNoPrBadge: false, + }); + }); + + it("allows no-PR badge only after remote is observed with no sticky PR", () => { + expect( + resolveDiscordTitlePrEvidence({ + stickyPr: null, + statusPr: null, + remoteStatusObserved: true, + }), + ).toEqual({ + stickyPr: null, + effectivePr: null, + canApplyNoPrBadge: true, + }); + }); + + it("sticks open failing PR from VCS and refuses demotion via null status", () => { + const openFailing = toStickyTitlePrEvidence({ + state: "open", + number: 12, + hasFailingChecks: true, + }); + const afterNull = resolveDiscordTitlePrEvidence({ + stickyPr: openFailing, + statusPr: null, + remoteStatusObserved: true, + }); + expect(afterNull.effectivePr).toEqual(openFailing); + expect(afterNull.canApplyNoPrBadge).toBe(false); + }); + + it("settled upgrade does not paint ▫️ when canApplyNoPrBadge is false", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Sync recent scanner learnings", + branch: "t3-discord/scanner", + worktreePath: "/tmp/wt", + messages: [assistantMessage()], + }, + mirroredThreadTitle: "❌ Sync recent scanner learnings", + attemptedThreadTitle: "❌ Sync recent scanner learnings", + cachedPr: null, + canApplyNoPrBadge: false, + }), + ).toBeNull(); + }); + + it("settled upgrade may paint ▫️ only with confirmed no-PR evidence", () => { + expect( + resolveSettledDiscordThreadTitleUpgrade({ + thread: { + title: "Sync recent scanner learnings", + branch: "t3-discord/scanner", + worktreePath: "/tmp/wt", + messages: [assistantMessage()], + }, + mirroredThreadTitle: "Sync recent scanner learnings", + attemptedThreadTitle: "Sync recent scanner learnings", + cachedPr: null, + canApplyNoPrBadge: true, + }), + ).toBe("▫️ Sync recent scanner learnings"); + }); +}); + +describe("resolveThreadChangeRequestLookupCwds", () => { + it("tries the thread worktree before the project root", () => { + expect( + resolveThreadChangeRequestLookupCwds( + { worktreePath: "/tmp/worktree" }, + { workspaceRoot: "/tmp/project" }, + ), + ).toEqual(["/tmp/worktree", "/tmp/project"]); + }); + + it("deduplicates identical worktree and project paths", () => { + expect( + resolveThreadChangeRequestLookupCwds( + { worktreePath: "/tmp/project" }, + { workspaceRoot: "/tmp/project" }, + ), + ).toEqual(["/tmp/project"]); + }); +}); diff --git a/apps/discord-bot/src/features/ResponseBridge.ts b/apps/discord-bot/src/features/ResponseBridge.ts new file mode 100644 index 000000000000..cffd04f58994 --- /dev/null +++ b/apps/discord-bot/src/features/ResponseBridge.ts @@ -0,0 +1,5933 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectContext:off globalFetchInEffect:off unknownInEffectCatch:off nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodePath from "node:path"; +import type { + ChatImageAttachment, + OrchestrationThread, + ThreadId, + VcsStatusChangeRequest, + VcsStatusResult, +} from "@t3tools/contracts"; +import { applyGitStatusStreamEvent } from "@t3tools/shared/git"; +import { sessionNeedsWakeUp } from "@t3tools/shared/sessionWake"; +import { resolveThreadChangeRequest } from "@t3tools/shared/sourceControl"; +import { + appendStatsToMessageChunks, + formatTurnResponseStatsLine, +} from "@t3tools/shared/turnResponseStats"; +import { Discord, DiscordConfig, DiscordREST, UI } from "dfx"; +import * as Cause from "effect/Cause"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Redacted from "effect/Redacted"; +import * as Ref from "effect/Ref"; +import * as Result from "effect/Result"; +import * as Semaphore from "effect/Semaphore"; + +import { DiscordBotConfig } from "../config.ts"; +import { + appendT3DeepLinkToChunks, + buildStreamHistoryMarkdownText, + DISCORD_MAX_FILES_PER_MESSAGE, + imageAttachmentsOf, + STREAM_HISTORY_MARKDOWN_NAME, + streamHistoryHasAdditionalContent, + unpostedAttachments, +} from "../presentation/attachments.ts"; +import { buildOmegentThreadMessageUrl } from "../presentation/discordPrAttribution.ts"; +import { + createMessageWithAttachments, + DiscordUploadError, + textFile, + type DiscordUploadFile, +} from "../presentation/discordFiles.ts"; +import { formatModelSelectionLine } from "../presentation/threadInfoPin.ts"; +import { + assertFilesystemPath as assertFilesystemFilePath, + extractMarkdownLocalFileLinks, + fileNameForLocalFileRef, + guessFileMimeType, + isLocalFileSrc, + replaceMarkdownLocalFileLinks, + resolveLocalFilePathOnDisk, + stripMarkdownLocalFileLinks, + type MarkdownLocalFileRef, +} from "../presentation/markdownFiles.ts"; +import { + resolveGitHubBlobUrlForLocalPath, + resolveGitHubBlobUrlForPathReference, +} from "../presentation/githubLinks.ts"; +import { extractPullRequestUrls } from "../presentation/prLinks.ts"; +import { + assertFilesystemPath, + extractMarkdownImages, + fileNameForImageRef, + guessImageMimeType, + isLocalImageSrc, + resolveImagePathOnDisk, + stripMarkdownImages, + type MarkdownImageRef, +} from "../presentation/markdownImages.ts"; +import { rewriteMarkdownTablesForDiscord } from "../presentation/markdownTables.ts"; +import { + chunkDiscordContent, + formatInProgressChunk, + formatWakeUpTipContent, + inProgressChunkLimit, + idleMessageFields, + nextWorkingDotCount, + decorateDiscordThreadTitle, + stripWorkingIndicator, + type WorkingDotCount, + wakeUpMessageFields, + workingMessageFields, +} from "../presentation/messages.ts"; +import { + derivePendingInteractions, + type PendingApproval, +} from "../presentation/pendingInteractions.ts"; +import { formatTasksForDiscord, presentTasks } from "../presentation/tasks.ts"; +import { countTurnToolCalls } from "../presentation/toolCalls.ts"; +import { ThreadLinkStore } from "../store/ThreadLinkStore.ts"; +import { ThreadWarmCacheStore } from "../store/ThreadWarmCacheStore.ts"; +import { T3Session } from "../t3/T3Session.ts"; +import { formatAlertCause, postBridgeAlert, postFatalAlert } from "./Alerts.ts"; +import { BridgeHub, type BridgeControlSlot, type BridgeEnsureInput } from "./BridgeHub.ts"; +import { + assistantMessagesForDelivery, + beginDeliveryEpoch, + decideAssistantDelivery, + decideHeartbeat, + initialDeliveryEpochState, + retainUnfinalizedStreamText, + shouldRecreateTip, + unfinalizedPriorAssistantForCatchUp, + type DeliveryEpochState, +} from "./DiscordDelivery.ts"; +import { upsertThreadInfoPin } from "./ThreadInfoPin.ts"; + +const DISCORD_LIMIT = 2000; +const STREAM_CHUNK_LIMIT = inProgressChunkLimit(DISCORD_LIMIT); +const DISCORD_CONSERVATIVE_UPLOAD_LIMIT_BYTES = 10_000_000; + +interface BridgeState { + /** T3 orchestration turn currently tracked by this bridge. */ + readonly currentTurnId: string | null; + /** T3 orchestration assistant message id currently being streamed. */ + readonly t3AssistantMessageId: string | null; + /** Full assistant text last applied to the in-progress Discord stream. */ + readonly lastAssistantText: string; + /** + * Discord messages that carry the current turn's *in-progress* stream (ordered tip slots). + * On finalize these are deleted; their content is archived as stream-history.md. + * May include the pre-bridge Working.. ack (seeded at start). + */ + readonly discordMessageIds: ReadonlyArray; + /** + * Extra stream message ids that were abandoned (e.g. tip ownership lost and replaced). + * Always deleted on finalize / when starting a new assistant message. + */ + readonly staleStreamMessageIds: ReadonlyArray; + /** + * Full stream display text frozen when a user (or other) message displaced our tip. + * Active tip messages after the break only show the *suffix* after this prefix so we + * never re-copy pre-break content below the user message (order stays correct). + */ + readonly streamBreakPrefix: string; + readonly lastTasksKey: string; + readonly taskDiscordMessageId: string | null; + readonly lastApprovalKey: string; + /** Whether we already published a final answer for this T3 turn. */ + readonly finalizedTurnId: string | null; + /** Chat attachment ids already uploaded to Discord for the current T3 assistant message. */ + readonly postedAttachmentIds: ReadonlyArray; + /** Local markdown image srcs already uploaded for this T3 assistant message. */ + readonly postedMarkdownImageSrcs: ReadonlyArray; + /** Local markdown file srcs already uploaded for this T3 assistant message. */ + readonly postedMarkdownFileSrcs: ReadonlyArray; + /** Discord message ids of the final answer post(s), if any. */ + readonly finalDiscordMessageIds: ReadonlyArray; + /** Whether we already attached stream-history.md for this T3 assistant id. */ + readonly streamHistoryPosted: boolean; + /** + * After the first snapshot we adopt any prior completed assistant as "already + * finalized" so re-subscribing a long-lived thread does not re-post old answers. + */ + readonly adoptedInitialSnapshot: boolean; + /** Last Discord thread title we successfully mirrored from the T3 thread title. */ + readonly mirroredThreadTitle: string | null; + /** Title attempted by this bridge, preventing retries on every stream snapshot. */ + readonly attemptedThreadTitle: string | null; + /** + * A fresh Working.. ack was posted before `startTurn` dispatch. Keep it visible through + * the bridge's initial idle snapshot, and only clear it once the new turn actually starts + * (or explicit error cleanup removes it). + */ + readonly seededWorkingAckPending: boolean; + /** User message ids already observed by this bridge subscription. */ + readonly seenUserMessageIds: ReadonlyArray; + /** Whether the bridge has already treated one thread snapshot as baseline state. */ + readonly observedInitialUserSnapshot: boolean; + /** User message ids sent into T3 by this Discord bot and therefore not echoed back. */ + readonly sentDiscordUserMessageIds: ReadonlyArray; + /** + * Structural delivery epoch FSM (see DiscordDelivery.ts). Gates stream / finalize / + * heartbeat so a finalized answer cannot reappear as Working.. under itself. + */ + readonly delivery: DeliveryEpochState; + /** + * Converted an open Working tip into a wake-up notice for this bridge lifetime. + * Prevents re-editing / re-posting the same notice on every snapshot. + */ + readonly wakeUpNoticePosted: boolean; +} + +export type DiscordBridgePresentationMode = "full" | "final-only"; + +/** + * Discord Tasks side-channel lifecycle (one editable message per bridge). + * Independent of External User Input echo and of Working stream tips. + */ +export function resolveTaskMessageAction(input: { + readonly taskDiscordMessageId: string | null; + readonly lastTasksKey: string; + readonly nextTasksKey: string; +}): "skip" | "update" | "create" { + if (input.lastTasksKey === input.nextTasksKey) return "skip"; + return input.taskDiscordMessageId === null ? "create" : "update"; +} + +/** + * Message ids that must never steal Working tip ownership. + * Includes stream tips, finals, Tasks side-post, info pin, and durable stream markers. + */ +export function discordBridgeOwnedMessageIds(input: { + readonly discordMessageIds?: ReadonlyArray; + readonly staleStreamMessageIds?: ReadonlyArray; + readonly finalDiscordMessageIds?: ReadonlyArray; + readonly taskDiscordMessageId?: string | null | undefined; + readonly infoDiscordMessageId?: string | null | undefined; + readonly streamDiscordMessageIds?: ReadonlyArray; +}): ReadonlyArray { + const ids: string[] = []; + for (const group of [ + input.discordMessageIds, + input.staleStreamMessageIds, + input.finalDiscordMessageIds, + input.streamDiscordMessageIds, + ]) { + for (const id of group ?? []) { + const value = id?.trim() ?? ""; + if (value !== "") ids.push(value); + } + } + for (const id of [input.taskDiscordMessageId, input.infoDiscordMessageId]) { + const value = id?.trim() ?? ""; + if (value !== "") ids.push(value); + } + return ids; +} + +/** + * Normalize Discord message content for accept-without-ack idempotency checks. + * Collapses whitespace and strips Working indicators so chunk compares stay stable. + */ +export function normalizeDiscordContentForIdempotency(content: string): string { + return stripWorkingIndicator(content) + .replace(/\u200b/gu, "") + .replace(/\s+/gu, " ") + .trim(); +} + +/** + * Find bot-authored messages that already match the final answer chunks (oldest→newest). + * Used when Discord accepted createMessage but we timed out before recording state — + * retry must adopt those ids instead of posting a second final. + * + * Returns null when no complete contiguous match is found. + */ +export function findAlreadyPostedFinalChunkIds(input: { + readonly recentMessages: ReadonlyArray<{ + readonly id: string; + readonly authorId: string; + readonly content: string; + }>; + readonly botUserId: string; + readonly finalChunks: ReadonlyArray; + readonly excludeMessageIds?: ReadonlyArray; +}): ReadonlyArray | null { + const chunks = input.finalChunks + .map((chunk) => normalizeDiscordContentForIdempotency(chunk.trim() !== "" ? chunk : "_(done)_")) + .filter((chunk) => chunk !== ""); + if (chunks.length === 0) return null; + + const exclude = new Set((input.excludeMessageIds ?? []).filter((id) => id.trim() !== "")); + // listMessages is newest-first; walk oldest-first for contiguous chunk order. + const botMessages = input.recentMessages + .filter( + (message) => + message.authorId === input.botUserId && + !exclude.has(message.id) && + normalizeDiscordContentForIdempotency(message.content) !== "", + ) + .slice() + .reverse(); + + if (botMessages.length < chunks.length) return null; + + for (let start = 0; start <= botMessages.length - chunks.length; start += 1) { + let matched = true; + const ids: string[] = []; + for (let offset = 0; offset < chunks.length; offset += 1) { + const message = botMessages[start + offset]!; + const body = normalizeDiscordContentForIdempotency(message.content); + if (body !== chunks[offset]) { + matched = false; + break; + } + ids.push(message.id); + } + if (matched) return ids; + } + return null; +} + +/** + * Whether durable/in-memory finalize markers already claim this assistant was delivered. + */ +export function isAssistantAlreadyFinalizedOnDiscord(input: { + readonly assistantId: string; + readonly finalizedTurnId: string | null; + readonly turnId: string | null; + readonly lastFinalizedAssistantId: string | null | undefined; + readonly durableLastFinalizedAssistantId: string | null | undefined; +}): boolean { + if ( + input.finalizedTurnId !== null && + input.turnId !== null && + input.finalizedTurnId === input.turnId + ) { + return true; + } + if (input.lastFinalizedAssistantId === input.assistantId) return true; + if (input.durableLastFinalizedAssistantId === input.assistantId) return true; + return false; +} + +/** + * Discord message types that represent real chat content (user/bot). + * System messages (channel name change=4, pin=6, etc.) must NOT steal stream tip ownership — + * new threads rename early and otherwise freeze empty `_Working.._` while T3 streams. + * @see https://discord.com/developers/docs/resources/message#message-object-message-types + */ +export function isDiscordContentMessageType(type: number | null | undefined): boolean { + // 0 Default, 19 Reply. Treat missing type as content (older payloads). + return type === null || type === undefined || type === 0 || type === 19; +} + +/** + * Newest-first message list → latest content message id (skips channel renames / pins). + */ +export function pickLatestContentMessageId( + messages: ReadonlyArray<{ readonly id: string; readonly type?: number | null }>, +): string | null { + return pickLatestContentMessage(messages)?.id ?? null; +} + +/** + * Newest-first message list → latest content message (skips channel renames / pins). + */ +export function pickLatestContentMessage< + T extends { readonly id: string; readonly type?: number | null }, +>(messages: ReadonlyArray): T | null { + for (const message of messages) { + if (isDiscordContentMessageType(message.type)) { + const id = message.id.trim(); + if (id !== "") return message; + } + } + return null; +} + +export type DiscordChannelMessageForTipScan = { + readonly id: string; + readonly type?: number | null; + readonly author?: { readonly id?: string | null } | null; + readonly content?: string | null; +}; + +/** + * Cross-surface command echoed into Discord (`💭 from **user@desktop**:` …). + * These are new commands, not bot side-posts (Tasks / pins / Working). + */ +export function isDiscordEchoedCommandContent(text: string): boolean { + return text.trim().startsWith("💭 from **"); +} + +/** + * Whether a human (or other non-bot-owned) *content* message sits newer than the Working tip. + * + * Walks `recentMessagesNewestFirst` until the live tip. Bot side posts after the tip + * (Tasks, stream chunks, finals, external-input echoes) and Discord system messages + * (title renames, pins) are skipped. A human *between* Working and a later Tasks + * post **is** displaced, even when Tasks is the channel tip. + * + * Casual-chat displacement does **not** hop Working. Hop only when an echoed + * command sits newer than the tip ({@link isStreamTipDisplacedByEchoedCommand}) + * or a Discord `--steer` / idle turn posts a new Working ack. + */ +export function isStreamTipDisplacedByRecentMessages(input: { + readonly recentMessagesNewestFirst: ReadonlyArray; + readonly streamTipId: string | null; + readonly ownedMessageIds: ReadonlyArray; + readonly botUserId: string; +}): boolean { + const tip = input.streamTipId?.trim() ?? ""; + if (tip === "") return false; + const botUserId = input.botUserId.trim(); + + const owned = new Set(); + owned.add(tip); + for (const id of input.ownedMessageIds) { + const value = id?.trim() ?? ""; + if (value !== "") owned.add(value); + } + + for (const message of input.recentMessagesNewestFirst) { + if (!isDiscordContentMessageType(message.type)) continue; + const id = message.id.trim(); + if (id === "") continue; + // Reached the live tip — nothing newer is a foreign content message. + if (id === tip) return false; + const authorId = message.author?.id?.trim() ?? ""; + if (botUserId !== "" && authorId === botUserId) continue; + if (owned.has(id)) continue; + return true; + } + return false; +} + +/** + * Latest-only variant of {@link isStreamTipDisplacedByRecentMessages}. + * + * Prefer the recent-window scan in production: latest-only misses humans sitting + * between Working and a later bot side post (Tasks / echoes). + */ +export function isStreamTipDisplacedByForeignMessage(input: { + readonly latestMessageId: string | null; + readonly streamTipId: string | null; + readonly ownedMessageIds: ReadonlyArray; + /** + * When the latest content message was authored by this Discord bot, never treat it as + * foreign — side posts (Tasks, external echoes, info pins) often lack durable ownership + * tracking and used to freeze the Working tip mid-turn. + */ + readonly latestAuthorIsSelfBot?: boolean; +}): boolean { + const latest = input.latestMessageId?.trim() ?? ""; + if (latest === "") return false; + return isStreamTipDisplacedByRecentMessages({ + recentMessagesNewestFirst: [ + { + id: latest, + type: 0, + author: { id: input.latestAuthorIsSelfBot === true ? "__self_bot__" : "__foreign__" }, + }, + ], + streamTipId: input.streamTipId, + ownedMessageIds: input.ownedMessageIds, + botUserId: "__self_bot__", + }); +} + +/** + * Whether an echoed T3/GitHub command sits newer than the live Working tip. + * + * Echoes are bot-authored, so {@link isStreamTipDisplacedByRecentMessages} skips + * them. Casual Discord chat must not hop Working; a desktop/web/mobile (or + * GitHub) command echoed into the thread should. + */ +export function isStreamTipDisplacedByEchoedCommand(input: { + readonly recentMessagesNewestFirst: ReadonlyArray; + readonly streamTipId: string | null; +}): boolean { + const tip = input.streamTipId?.trim() ?? ""; + if (tip === "") return false; + for (const message of input.recentMessagesNewestFirst) { + if (!isDiscordContentMessageType(message.type)) continue; + const id = message.id.trim(); + if (id === "") continue; + if (id === tip) return false; + if (isDiscordEchoedCommandContent(message.content ?? "")) return true; + } + return false; +} + +export type WorkingTipDisplacementCause = "casual-chat" | "echoed-command"; + +/** + * Whether stream/heartbeat should delete `_Working.._` and re-post it below a + * later channel message. + * + * Casual thread chat and parked (queued) follow-ups leave the in-progress + * message in place. An echoed cross-surface command (desktop/web/mobile/GitHub) + * hops Working under that command. Discord `--steer` / idle turns post a new + * Working ack instead ({@link shouldPostWorkingAckForContinue}). + * + * Finalize always creates a new message, then deletes in-progress tips. + */ +export function shouldHopWorkingTipOnDisplacement(cause: WorkingTipDisplacementCause): boolean { + return cause === "echoed-command"; +} + +export function shouldPublishAssistantUpdate(input: { + readonly presentationMode: DiscordBridgePresentationMode; + readonly streaming: boolean; +}): boolean { + return input.presentationMode === "full" || !input.streaming; +} + +export function shouldArchiveStreamHistory(input: { + readonly presentationMode: DiscordBridgePresentationMode; + readonly hasStreamMessages: boolean; +}): boolean { + return input.presentationMode === "full" && input.hasStreamMessages; +} + +export function shouldReopenFinalizedDelivery(input: { + readonly finalizedTurnId: string | null; + readonly currentAssistantMessageId: string | null; + readonly turnId: string | null; + readonly nextAssistantMessageId: string; +}): boolean { + return ( + input.finalizedTurnId !== null && + (input.finalizedTurnId !== input.turnId || + input.currentAssistantMessageId !== input.nextAssistantMessageId) + ); +} + +/** + * Dual-cursor lag: orchestration has advanced past what Discord successfully applied. + * + * - `lastThreadSnapshotSequence` advances when T3 state is observed (performant resume). + * - `lastDeliveredSequence` advances only after `processThreadSnapshot` succeeds. + * + * When delivery is behind, keep HTTP-reconciling / rehydrating even if tips look clean + * (crash between sequence persist and Discord I/O, hung REST, worker death mid-queue). + * + * Storage/memory contract: both cursors are O(1) scalars on the link row. We never + * persist or keep an event log of pre-sync history — only these markers + tip ids. + */ +export function isDeliveryBehindOrchestration(input: { + readonly lastDeliveredSequence: number | null | undefined; + readonly lastThreadSnapshotSequence: number | null | undefined; +}): boolean { + const observed = input.lastThreadSnapshotSequence; + const delivered = input.lastDeliveredSequence; + // Both cursors must be known. A null delivery cursor means pre-dual-cursor links or + // a brand-new link — do not force rehydrate of every historical link on upgrade. + // Open tips / awaiting-final / turn-in-progress still drive recovery in those cases. + // Once delivery has been written at least once, lag is strict sequence comparison. + if (observed === null || observed === undefined || !Number.isFinite(observed)) { + return false; + } + if (delivered === null || delivered === undefined || !Number.isFinite(delivered)) { + return false; + } + return delivered < observed; +} + +/** + * How many sequences to rewind when resuming the WS stream so a mid-delivery race + * can re-observe a tiny tail. Not history storage — just a resume offset. + */ +export const SUBSCRIBE_SEQUENCE_BUFFER = 2 as const; + +function finiteSequenceOrNull(value: number | null | undefined): number | null { + if (value === null || value === undefined || !Number.isFinite(value)) return null; + return value; +} + +/** + * Choose `subscribeThread({ afterSequence })` so we do **not** re-walk the WS event + * log before what Discord has already synced (minus a small buffer). + * + * Preference order: + * 1. `lastDeliveredSequence` — safe high-water for "already applied to Discord" + * 2. else `lastThreadSnapshotSequence` — legacy / first-write before delivery cursor exists + * + * Returns null for cold subscribe (no durable cursor yet). Never returns a cursor that + * requires loading stored pre-sync event history — only a number for the server filter. + */ +export function resolveSubscribeAfterSequence(input: { + readonly lastDeliveredSequence: number | null | undefined; + readonly lastThreadSnapshotSequence: number | null | undefined; + readonly buffer?: number; +}): number | null { + const buffer = Math.max(0, input.buffer ?? SUBSCRIBE_SEQUENCE_BUFFER); + const delivered = finiteSequenceOrNull(input.lastDeliveredSequence); + const observed = finiteSequenceOrNull(input.lastThreadSnapshotSequence); + // Prefer delivery cursor: skip everything Discord already applied. + // When lagging, this is *behind* orchestration — intentional: re-sync only the + // unsynced tail (+buffer), not the whole thread event log from 0. + const anchor = delivered ?? observed; + if (anchor === null) return null; + return Math.max(0, anchor - buffer); +} + +/** + * How many already-finalized messages to keep before `lastFinalizedAssistantId` + * for growth reopen / settle edge cases. Everything older is dropped from the + * in-memory and warm-cache OrchestrationThread. + */ +export const DISCORD_DELIVERED_MESSAGE_MEMORY_BUFFER = 2 as const; + +/** + * Drop messages Discord has already successfully finalized, keeping a small + * buffer before the finalize watermark plus everything after it (active turn). + */ +export function trimOrchestrationThreadForDiscordMemory(input: { + readonly thread: OrchestrationThread; + readonly lastFinalizedAssistantId: string | null | undefined; + readonly buffer?: number; +}): OrchestrationThread { + const finalizedId = input.lastFinalizedAssistantId?.trim() ?? ""; + if (finalizedId === "") return input.thread; + const buffer = Math.max(0, input.buffer ?? DISCORD_DELIVERED_MESSAGE_MEMORY_BUFFER); + const messages = input.thread.messages; + const finalizedIdx = messages.findIndex((message) => message.id === finalizedId); + if (finalizedIdx < 0) return input.thread; + const start = Math.max(0, finalizedIdx - buffer); + if (start === 0) return input.thread; + return { + ...input.thread, + messages: messages.slice(start), + }; +} + +/** + * Prefer durable warm base (like web/desktop cache) over HTTP full tip when present. + */ +export function resolveThreadSubscribeSeed(input: { + readonly warm: { + readonly snapshotSequence: number; + readonly thread: OrchestrationThread; + } | null; + readonly afterSequence: number | null; +}): + | { readonly kind: "warm"; readonly thread: OrchestrationThread; readonly afterSequence: number } + | { readonly kind: "http"; readonly afterSequence: number } + | { readonly kind: "cold" } { + if ( + input.warm !== null && + Number.isFinite(input.warm.snapshotSequence) && + input.warm.snapshotSequence >= 0 + ) { + return { + kind: "warm", + thread: input.warm.thread, + afterSequence: input.warm.snapshotSequence, + }; + } + if (input.afterSequence !== null && input.afterSequence >= 0) { + return { kind: "http", afterSequence: input.afterSequence }; + } + return { kind: "cold" }; +} + +/** + * Whether the bridge should poll T3 over HTTP for a fresh snapshot. + * + * WS event delivery can stall (no thread updates for long stretches while the agent + * still works). Open Working.. tips / in-progress turns must not rely on WS alone. + * + * Also keeps polling after a Discord-originated user turn until we finalize at least + * once for that bridge session — covers turns that never posted a Working tip and + * never received WS assistant events (T3 UI still advances). + * + * Dual-cursor lag (`deliveryLagging`) recovers cases where orchestration advanced but + * Discord I/O never completed for that sequence. + */ +export function bridgeNeedsHttpReconcile(input: { + readonly openStreamTipCount: number; + readonly seededWorkingAckPending: boolean; + readonly turnInProgress: boolean; + /** + * True when we still owe Discord a final answer for work this bridge started + * (e.g. sent a user message / Working ack but finalizedTurnId is still null). + */ + readonly awaitingDiscordFinal: boolean; + /** True when lastDeliveredSequence lags lastThreadSnapshotSequence. */ + readonly deliveryLagging?: boolean; +}): boolean { + if (input.seededWorkingAckPending) return true; + if (input.openStreamTipCount > 0) return true; + if (input.turnInProgress) return true; + if (input.awaitingDiscordFinal) return true; + if (input.deliveryLagging === true) return true; + return false; +} + +/** How often each live bridge re-fetches thread state when {@link bridgeNeedsHttpReconcile}. */ +export const BRIDGE_HTTP_RECONCILE_INTERVAL = "12 seconds" as const; + +/** Cap Discord finalize create/edit work so a hung REST call cannot pin the delivery queue. */ +export const BRIDGE_FINALIZE_DISCORD_TIMEOUT = "45 seconds" as const; + +/** + * Cap live stream tip create/edit work. Stream path previously had no timeout; a hung + * Discord REST call held the delivery lock forever so later assistants never reached + * Discord while T3 kept advancing (stuck `_Working.._` with live intermediate text in T3). + */ +export const BRIDGE_STREAM_DISCORD_TIMEOUT = "30 seconds" as const; + +/** + * Outer cap for one coalesced `processThreadSnapshot` pass (primary stream/finalize + + * best-effort secondary). Kept high enough for a finalize multipart upload. + */ +export const BRIDGE_PROCESS_SNAPSHOT_TIMEOUT = "90 seconds" as const; + +/** + * Cap title / pin / tasks / approvals so secondary Discord work cannot burn the whole + * processThreadSnapshot budget and trip the outer TimeoutError while the tip already + * has (or needs) stream content. + */ +export const BRIDGE_SECONDARY_DISCORD_TIMEOUT = "20 seconds" as const; + +/** Immediate in-worker retries after processThreadSnapshot failure before deferring to HTTP reconcile. */ +export const BRIDGE_DELIVERY_FAILURE_MAX_RETRIES = 5 as const; + +/** + * Backoff between in-worker delivery retries after TimeoutError / process failure. + * failureCount is 1-based (after increment). Caps at 30s. + */ +export function deliveryFailureBackoffSeconds(failureCount: number): number { + const n = Math.max(1, Math.floor(failureCount)); + return Math.min(30, 2 ** Math.min(n, 5)); +} + +export function shouldRetryDeliveryFailure(input: { + readonly failureCount: number; + readonly maxRetries?: number; +}): boolean { + const max = input.maxRetries ?? BRIDGE_DELIVERY_FAILURE_MAX_RETRIES; + return input.failureCount >= 1 && input.failureCount <= max; +} + +/** + * On bridge fiber stop (restart, reconnect dropAll, channel re-ensure), keep open + * stream tips on Discord when a turn is still running so rehydrate can resume them. + * + * This is the correct mid-turn resume strategy — **not** repainting the previous + * turn's final answer under a new Working tip. New interactive turns orphan-clean + * prior tip ids via {@link seedStreamMessageIds} / {@link nextBridgeStateAfterAdoptWorkingAck}. + */ +export function shouldPreserveStreamTipsOnBridgeStop(input: { + readonly turnInProgress: boolean; + readonly openStreamTipCount: number; +}): boolean { + return input.turnInProgress && input.openStreamTipCount > 0; +} + +/** Stable synthetic assistant id used only to reseed a Working tip with no prose yet. */ +export const REHYDRATE_WORKING_PLACEHOLDER_ID = "rehydrate:working-tip"; + +/** + * Body text for the Working heartbeat tip. + * + * While a fresh Working ack is pending for a new user turn, never paint prior-turn + * `lastAssistantText` (that re-shows the previous answer under Working..). + */ +export function streamTipBodyForHeartbeat(input: { + readonly seededWorkingAckPending: boolean; + readonly lastAssistantText: string; + readonly streamBreakPrefix: string; +}): string { + if (input.seededWorkingAckPending) return ""; + return activeStreamTipText(streamDisplayText(input.lastAssistantText), input.streamBreakPrefix); +} + +/** + * Hold a fresh Working ack without painting snapshot assistant body. + * + * Only while the *current* turn has no assistant bubbles yet. Blanket holding for + * the whole `seededWorkingAckPending` lifetime blocked legitimate new-turn stream + * writes (pending never cleared) or, when pending was cleared elsewhere, still + * allowed prior-turn bodies through once latestTurn lagged. + */ +export function shouldHoldFreshWorkingAck(input: { + readonly mode: "interactive" | "rehydrate"; + readonly seededWorkingAckPending: boolean; + /** Assistants belonging to the active turn only (see {@link assistantMessagesThisTurn}). */ + readonly currentTurnAssistantCount: number; +}): boolean { + return ( + input.mode === "interactive" && + input.seededWorkingAckPending && + input.currentTurnAssistantCount === 0 + ); +} + +/** + * Active tip message ids for a streaming write. + * + * On a new delivery (new turn / fresh Working ack), keep only the newest tip slot + * so we never edit prior-turn message ids (Discord 10008 Unknown Message). + */ +export function activeStreamTipIdsForDelivery(input: { + readonly startsNewDelivery: boolean; + readonly discordMessageIds: ReadonlyArray; + readonly staleStreamMessageIds: ReadonlyArray; +}): { + readonly discordMessageIds: ReadonlyArray; + readonly staleStreamMessageIds: ReadonlyArray; +} { + if (!input.startsNewDelivery) { + return { + discordMessageIds: [...input.discordMessageIds], + staleStreamMessageIds: [...input.staleStreamMessageIds], + }; + } + const tip = + input.discordMessageIds.length > 0 + ? input.discordMessageIds[input.discordMessageIds.length - 1]! + : null; + return { + discordMessageIds: tip !== null ? [tip] : [], + staleStreamMessageIds: uniqueDiscordMessageIds([ + ...input.staleStreamMessageIds, + ...input.discordMessageIds.slice(0, -1), + ]), + }; +} + +/** + * Whether streaming should treat this write as a brand-new tip delivery + * (clear last body / tip history), not a mid-turn edit of the same turn. + */ +export function startsNewStreamDelivery(input: { + readonly currentTurnId: string | null; + readonly nextTurnId: string | null; + readonly reopensFinalizedDelivery: boolean; + readonly seededWorkingAckPending: boolean; +}): boolean { + return ( + input.currentTurnId !== input.nextTurnId || + input.reopensFinalizedDelivery || + input.seededWorkingAckPending + ); +} + +/** + * When a new user turn / Working ack starts, any substantial stream tip body + * that was never finalized must be posted as a durable final **before** the + * tip is cleared. Queue-drain races finish the prior answer into the tip and + * immediately open the next Working epoch — without this, the final only + * lived as an editable tip and is deleted when the new epoch starts. + * + * Mirrors the server/web queue-drain final orphan problem (turnId restamp / + * fold rehome): Discord's presentation boundary is the Working tip lifecycle. + */ +export function shouldFinalizeStreamBeforeNewDelivery(input: { + readonly startsNewDelivery: boolean; + readonly lastAssistantText: string; + readonly t3AssistantMessageId: string | null; + readonly finalizedTurnId: string | null; + readonly currentTurnId: string | null; +}): boolean { + if (!input.startsNewDelivery) return false; + if (input.t3AssistantMessageId === null || input.t3AssistantMessageId.trim() === "") { + return false; + } + // Already finalized this tip's turn — nothing left to promote. + if ( + input.finalizedTurnId !== null && + input.currentTurnId !== null && + input.finalizedTurnId === input.currentTurnId + ) { + return false; + } + const text = input.lastAssistantText.trim(); + if (text === "" || text === "…") return false; + // Working-only placeholder with no prose yet. + if (/^_Working/i.test(text) && text.length < 40) return false; + return true; +} + +/** + * Pure state patch when a Discord Working.. ack is adopted for a new user turn + * (or mid-turn steer) on a reused bridge. Clears prior stream body and points the + * live tip at the new Working ack only. + * + * `orphanTipsToDelete` is misnamed historically: callers **freeze** those tips + * (strip Working.. + Stop) and leave them as channel history above the human message; + * only empty Working-only orphans are deleted. + */ +export function nextBridgeStateAfterAdoptWorkingAck(input: { + readonly priorDiscordMessageIds: ReadonlyArray; + readonly priorStaleStreamMessageIds: ReadonlyArray; + readonly workingAckMessageId: string; +}): { + readonly discordMessageIds: ReadonlyArray; + readonly staleStreamMessageIds: ReadonlyArray; + /** Prior tip ids to freeze (or delete if empty Working-only). */ + readonly orphanTipsToDelete: ReadonlyArray; + readonly lastAssistantText: string; + readonly streamBreakPrefix: string; + readonly currentTurnId: null; + readonly t3AssistantMessageId: null; + readonly finalizedTurnId: null; + readonly finalDiscordMessageIds: ReadonlyArray; + readonly streamHistoryPosted: false; + readonly postedAttachmentIds: ReadonlyArray; + readonly postedMarkdownImageSrcs: ReadonlyArray; + readonly postedMarkdownFileSrcs: ReadonlyArray; + readonly seededWorkingAckPending: true; +} { + const orphanTipsToDelete = input.priorDiscordMessageIds.filter( + (id) => id !== input.workingAckMessageId, + ); + return { + discordMessageIds: [input.workingAckMessageId], + // Do not re-queue orphans as stale live tips — they become frozen history. + staleStreamMessageIds: [...input.priorStaleStreamMessageIds].filter( + (id) => id !== input.workingAckMessageId && !orphanTipsToDelete.includes(id), + ), + orphanTipsToDelete, + lastAssistantText: "", + streamBreakPrefix: "", + currentTurnId: null, + t3AssistantMessageId: null, + finalizedTurnId: null, + finalDiscordMessageIds: [], + streamHistoryPosted: false, + postedAttachmentIds: [], + postedMarkdownImageSrcs: [], + postedMarkdownFileSrcs: [], + seededWorkingAckPending: true, + }; +} + +/** + * After a stream tip update fails (e.g. Discord 10008 Unknown Message), recreate + * when the turn is still running so Discord does not go dark. + */ +export function shouldRecreateStreamTipOnUpdateFailure(input: { + readonly turnInProgress: boolean; + readonly updateFailed: boolean; +}): boolean { + return input.updateFailed && input.turnInProgress; +} + +/** + * Rehydrate/resume should always attempt a streaming tip write for a running turn, + * including empty progress (Working-only), so restarts never leave Discord without + * a liveness bubble while T3 is still busy. + */ +export function shouldPublishRehydrateResumeTip(input: { + readonly presentationMode: DiscordBridgePresentationMode; + readonly turnInProgress: boolean; +}): boolean { + return ( + input.turnInProgress && + shouldPublishAssistantUpdate({ + presentationMode: input.presentationMode, + streaming: true, + }) + ); +} + +const emptyState = (seed?: { + readonly workingAckMessageId?: string | null; + readonly lastFinalizedAssistantId?: string | null; +}): BridgeState => { + const hasWorkingAck = + seed?.workingAckMessageId !== undefined && + seed.workingAckMessageId !== null && + seed.workingAckMessageId !== ""; + const lastFinalized = seed?.lastFinalizedAssistantId ?? null; + return { + currentTurnId: null, + t3AssistantMessageId: null, + lastAssistantText: "", + // Reuse the router's Working.. ack as the first stream tip so it is edited/deleted. + discordMessageIds: hasWorkingAck ? [seed!.workingAckMessageId!] : [], + staleStreamMessageIds: [], + streamBreakPrefix: "", + lastTasksKey: "", + taskDiscordMessageId: null, + lastApprovalKey: "", + finalizedTurnId: null, + postedAttachmentIds: [], + postedMarkdownImageSrcs: [], + postedMarkdownFileSrcs: [], + finalDiscordMessageIds: [], + streamHistoryPosted: false, + adoptedInitialSnapshot: false, + mirroredThreadTitle: null, + attemptedThreadTitle: null, + seededWorkingAckPending: hasWorkingAck, + seenUserMessageIds: [], + observedInitialUserSnapshot: false, + sentDiscordUserMessageIds: [], + delivery: initialDeliveryEpochState({ + epoch: hasWorkingAck ? 1 : 0, + phase: hasWorkingAck ? "awaiting" : "idle", + lastFinalizedAssistantId: lastFinalized, + lastFinalizedText: null, + settleReady: false, + }), + wakeUpNoticePosted: false, + }; +}; + +function uniqueDiscordMessageIds(ids: ReadonlyArray): ReadonlyArray { + return [...new Set(ids.filter((id) => id.trim() !== ""))]; +} + +function uniqueMessageIds(ids: ReadonlyArray): ReadonlyArray { + return [...new Set(ids.filter((id) => id.trim() !== ""))]; +} + +/** + * Live bridge handle per Discord channel. + * Mid-turn follow-ups re-use this handle instead of interrupting the fiber + * (which used to drop in-memory stream tips and re-seed a blank Working.. tip). + */ +export type { LiveDiscordBridge } from "./BridgeHub.ts"; + +export const getLiveDiscordBridge = (discordChannelId: string, t3ThreadId: string) => + Effect.gen(function* () { + const hub = yield* BridgeHub; + return yield* hub.getLive(discordChannelId, t3ThreadId); + }); + +function summarizeBridgeStateForLog(state: BridgeState) { + return { + currentTurnId: state.currentTurnId, + t3AssistantMessageId: state.t3AssistantMessageId, + discordMessageIds: [...state.discordMessageIds], + staleStreamMessageIds: [...state.staleStreamMessageIds], + streamBreakPrefixLen: state.streamBreakPrefix.length, + finalDiscordMessageIds: [...state.finalDiscordMessageIds], + taskDiscordMessageId: state.taskDiscordMessageId, + lastAssistantTextLength: state.lastAssistantText.length, + finalizedTurnId: state.finalizedTurnId, + streamHistoryPosted: state.streamHistoryPosted, + adoptedInitialSnapshot: state.adoptedInitialSnapshot, + seededWorkingAckPending: state.seededWorkingAckPending, + deliveryEpoch: state.delivery.epoch, + deliveryPhase: state.delivery.phase, + lastFinalizedAssistantId: state.delivery.lastFinalizedAssistantId, + }; +} + +/** + * True when the T3 UI would show "Wake Required" for this thread snapshot. + * Requires incomplete-turn evidence so zombie interrupted sessions stay quiet. + */ +export function isSessionWakeRequired( + thread: { + readonly session?: { + readonly status?: string | null; + readonly activeTurnId?: string | null; + } | null; + readonly latestTurn?: { + readonly state?: string | null; + readonly completedAt?: string | null; + } | null; + } | null, +): boolean { + if (thread === null) return false; + return sessionNeedsWakeUp({ + sessionStatus: thread.session?.status ?? null, + activeTurnId: thread.session?.activeTurnId ?? null, + latestTurnState: thread.latestTurn?.state ?? null, + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + }); +} + +/** + * Discord "in progress" is turn-scoped, not message-scoped. + * + * Codex/ACP often emits several assistant bubbles per turn (between tools). Each + * bubble ends with `message.streaming === false` while `latestTurn.state` is still + * `running`. Treating that as finalize posts stream-history.md mid-turn and + * creates new Discord messages instead of editing the tip. + * + * Only leave stream mode when the turn itself is no longer running. + * Interrupted sessions that need wake-up are never treated as live streaming. + */ +function isTurnInProgress(thread: OrchestrationThread): boolean { + if (isSessionWakeRequired(thread)) return false; + // Authoritative: turn still running (multi-step agents keep this while tools run). + if (thread.latestTurn?.state === "running") return true; + // No turn object yet but session already spinning up / running. + if ( + (thread.latestTurn === null || thread.latestTurn === undefined) && + (thread.session?.status === "running" || thread.session?.status === "starting") + ) { + return true; + } + return false; +} + +/** + * When a Working tip is still open after a real mid-turn interrupt (server + * restart / orphan settle), convert it to a wake-up notice instead of deleting it. + * Does not fire for zombie interrupted sessions with no unfinished turn. + */ +export function shouldConvertWorkingTipsToWakeUp(input: { + readonly sessionStatus: string | null | undefined; + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly latestTurnCompletedAt?: string | null | undefined; + readonly turnInProgress: boolean; + readonly openStreamTipCount: number; + readonly wakeUpNoticePosted: boolean; +}): boolean { + if (input.wakeUpNoticePosted) return false; + if (input.turnInProgress) return false; + if (input.openStreamTipCount <= 0) return false; + return sessionNeedsWakeUp({ + sessionStatus: input.sessionStatus, + activeTurnId: input.activeTurnId, + latestTurnState: input.latestTurnState, + latestTurnCompletedAt: input.latestTurnCompletedAt, + }); +} + +function isAssistantStreaming(thread: OrchestrationThread, assistantId: string): boolean { + if (isTurnInProgress(thread)) return true; + const message = thread.messages.find((entry) => entry.id === assistantId); + return message?.streaming === true; +} + +export function shouldDropSeededWorkingAckOnInitialSnapshot(input: { + readonly adoptedInitialSnapshot: boolean; + readonly seededWorkingAckPending: boolean; + readonly streaming: boolean; + readonly turnInProgress: boolean; +}): boolean { + void input; + // The initial Discord ack exists specifically to cover the gap before the next + // stream or final state is ready. Clearing it on the first pre-start snapshot + // causes a visible blink: Working.. disappears, then reappears once streaming starts. + // Keep it until a replacement is posted or the turn later settles with nothing to show. + return false; +} + +/** + * Decide how the first thread snapshot should be applied to Discord. + * + * Important: do not require `!streaming` here. Turn-in-progress always reports + * streaming=true, and the old guard made rehydrate-of-running-turns unreachable. + */ +export function firstSnapshotBridgeAction(input: { + readonly mode: "interactive" | "rehydrate"; + readonly turnInProgress: boolean; + readonly hasContent: boolean; + readonly alreadyFinalizedOnDiscord: boolean; + readonly hasOpenTips: boolean; +}): "catch-up-finalize" | "rehydrate-resume" | "adopt-completed" | "interactive-resume" | "skip" { + if (input.mode === "rehydrate" && !input.turnInProgress) { + if (input.hasContent && (!input.alreadyFinalizedOnDiscord || input.hasOpenTips)) { + return "catch-up-finalize"; + } + return "adopt-completed"; + } + if (input.mode === "rehydrate" && input.turnInProgress) { + return "rehydrate-resume"; + } + if (!input.turnInProgress) { + return "adopt-completed"; + } + return "interactive-resume"; +} + +/** + * Where a user-role T3 message came from, inferred from prompt envelopes. + * + * OrchestrationMessage has no first-class `source` field yet, so surfaces are classified + * from known ingress builders (Discord bot, GitHub PR bridge, agent harness). Plain text + * defaults to `t3-client` (web / desktop / mobile / API). + * + * Cross-surface policy: a surface should only *echo* messages from other surfaces. + * Discord bot echoes `github` + `t3-client`, never `discord` or `internal`. + * + * **Discord Tasks are not an ingress surface.** They are a first-class side-channel + * projected from `turn.plan.updated` activities via {@link presentTasks} / + * {@link formatTasksForDiscord} / `taskDiscordMessageId` — never from user-message echo. + * Tasks posts must stay bot-owned (do not freeze Working tips) and keep updating mid-turn. + */ +export type UserMessageIngressSurface = "discord" | "github" | "t3-client" | "internal"; + +/** Surfaces Discord may post as External User Input (whitelist). */ +export const DISCORD_EXTERNAL_ECHO_SURFACES: ReadonlySet = new Set([ + "github", + "t3-client", +]); + +/** + * True when text matches the Discord Tasks side-post body (`**Tasks N/M**`…). + * Those posts are bot-authored progress UI, not External User Input and not stream tips. + */ +export function isDiscordTasksSidePostContent(text: string): boolean { + return /^\*\*Tasks\s+\d+\s*\/\s*\d+\*\*/u.test(text.trim()); +} + +/** + * Classify a user-role message body by ingress surface (content heuristics). + * Prefer durable message ids (`sentDiscordUserMessageIds`) when available; this is the + * content fallback for rehydrate / id mismatch / non-Discord injectors. + */ +export function classifyUserMessageIngress(text: string): UserMessageIngressSurface { + const body = text.trim(); + if (body === "") return "t3-client"; + + // Agent harness / runtime scaffolding (not a human client). + if (isInternalAgentScaffoldingUserText(body)) return "internal"; + + // Never re-echo our own Tasks side-post body if it somehow re-enters as user text. + if (isDiscordTasksSidePostContent(body)) return "internal"; + + // Discord mention / bootstrap path (buildDiscordTurnPrompt / buildSentryBootstrapPrompt). + if (isDiscordOriginatedUserPrompt(body)) return "discord"; + + // GitHub PR bridge (buildGitHubTurnPrompt). + if (isGitHubOriginatedUserPrompt(body)) return "github"; + + // Default: T3 client (web/desktop/mobile) or unlabeled API turn. + return "t3-client"; +} + +/** + * User prompts this bot injected into T3 (Discord mention / bootstrap path). + * Never mirror these back into Discord as "External User Input" — they originated here. + */ +export function isDiscordOriginatedUserPrompt(text: string): boolean { + const body = text.trim(); + if (body === "") return false; + // buildDiscordTurnPrompt / buildSentryBootstrapPrompt markers. + if (body.includes("## Discord conversation context")) return true; + // Compact turn format: `rules:` / `req:` lines under the Discord header region. + if (/(?:^|\n)rules:\s+\//u.test(body) && body.includes("## User request")) return true; + if (/(?:^|\n)req:\s+\S/u.test(body) && body.includes("## User request")) return true; + if (body.includes("## Discord investigation bootstrap")) return true; + // Older / compact Discord turn envelopes still include these sections together. + if (body.includes("### Current requester") && body.includes("## User request")) return true; + return false; +} + +/** + * GitHub PR App turns (buildGitHubTurnPrompt). Echo these on Discord; do not treat as Discord. + */ +export function isGitHubOriginatedUserPrompt(text: string): boolean { + const body = text.trim(); + if (body === "") return false; + if (body.includes("## GitHub pull request context")) return true; + // Visible header after HTML comment strip: "From GH [login](...) on [PR #N](...):" + if (/^From GH\s+\[/mu.test(body) || /\nFrom GH\s+\[/u.test(body)) return true; + return false; +} + +/** + * Internal agent / runtime scaffolding that can appear as user-role text in T3 + * (tool completion notices, harness reminders). Not a real human/web/GitHub client. + */ +export function isInternalAgentScaffoldingUserText(text: string): boolean { + const body = text.trim(); + if (body === "") return false; + // Grok / agent harness system reminders (background task completion, etc.). + if (/<\s*system-reminder\b/iu.test(body)) return true; + if (/<\/\s*system-reminder\s*>/iu.test(body)) return true; + // Common body when the wrapper tag is stripped but the notice remains. + if (/^Background task\s+"/iu.test(body) && /completed\s*\(exit code:/iu.test(body)) { + return true; + } + // Other harness / tool XML shells that sometimes land as user-role text. + if (/<\s*system(?:-|\s)?(?:message|context|notification)\b/iu.test(body)) return true; + if (/<\s*tool_(?:result|response|call)\b/iu.test(body)) return true; + return false; +} + +/** + * True when a user-role message must not be mirrored to Discord as External User Input. + * Prefer {@link classifyUserMessageIngress} + whitelist; this remains for call sites/tests. + */ +export function shouldSuppressExternalUserEcho(text: string): boolean { + return !DISCORD_EXTERNAL_ECHO_SURFACES.has(classifyUserMessageIngress(text)); +} + +/** + * Whether Discord should post this user message as External User Input. + * Whitelist: github + t3-client only (never same-surface Discord, never internal). + */ +export function shouldEchoUserMessageToDiscord(input: { + readonly text: string; + readonly messageId: string; + readonly seenUserMessageIds: ReadonlySet | ReadonlyArray; + readonly sentDiscordUserMessageIds: ReadonlySet | ReadonlyArray; +}): boolean { + const seen = + input.seenUserMessageIds instanceof Set + ? input.seenUserMessageIds + : new Set(input.seenUserMessageIds); + const sentByDiscord = + input.sentDiscordUserMessageIds instanceof Set + ? input.sentDiscordUserMessageIds + : new Set(input.sentDiscordUserMessageIds); + if (seen.has(input.messageId) || sentByDiscord.has(input.messageId)) return false; + return DISCORD_EXTERNAL_ECHO_SURFACES.has(classifyUserMessageIngress(input.text)); +} + +export function externalUserMessagesToEcho(input: { + readonly messages: OrchestrationThread["messages"]; + readonly observedInitialUserSnapshot: boolean; + readonly seenUserMessageIds: ReadonlyArray; + readonly sentDiscordUserMessageIds: ReadonlyArray; +}): ReadonlyArray { + if (!input.observedInitialUserSnapshot) return []; + const seen = new Set(input.seenUserMessageIds); + const sentByDiscord = new Set(input.sentDiscordUserMessageIds); + return input.messages.filter( + (message) => + message.role === "user" && + shouldEchoUserMessageToDiscord({ + text: message.text, + messageId: message.id, + seenUserMessageIds: seen, + sentDiscordUserMessageIds: sentByDiscord, + }), + ); +} + +export function summarizeExternalUserInput(text: string): string { + // Drop HTML comment blocks (GitHub PR context) and system-reminder envelopes so + // anything that still slips through the echo filter is less noisy. + return text + .replace(/\s*/gu, "") + .replace(/<\s*system-reminder\b[^>]*>[\s\S]*?<\/\s*system-reminder\s*>/giu, "") + .replace(/\n{3,}/gu, "\n\n") + .trim(); +} + +export function threadTitleChangeRequestState( + thread: Pick, + pr: Pick | null | undefined, +): "initialized" | "open" | "merged" | "closed" | null { + const hasAssistantMessage = thread.messages.some((message) => message.role === "assistant"); + if (!hasAssistantMessage) return null; + if (thread.branch === null || thread.worktreePath === null) return null; + return pr?.state ?? "initialized"; +} + +/** + * Sticky PR evidence for Discord title badges. + * Transient null lookups must not erase a previously observed PR — that is the + * ▫️ ⇄ ❌🔀 flip-flop when VCS stream starts before remote is warm, or GH rate-limits. + */ +export type StickyTitlePrEvidence = Pick & { + readonly hasFailingChecks?: boolean; +}; + +export function toStickyTitlePrEvidence( + pr: + | (Pick & { + readonly hasFailingChecks?: boolean | undefined; + }) + | null + | undefined, +): StickyTitlePrEvidence | null { + if (pr === null || pr === undefined) return null; + return { + state: pr.state, + number: pr.number, + ...(pr.hasFailingChecks === undefined ? {} : { hasFailingChecks: pr.hasFailingChecks }), + }; +} + +/** + * Merge PR observations into sticky evidence. + * - null/undefined next = unknown (keep previous) + * - same open PR keeps hasFailingChecks=true until an explicit false arrives + */ +export function mergeStickyTitlePr( + previous: StickyTitlePrEvidence | null, + next: StickyTitlePrEvidence | null | undefined, +): StickyTitlePrEvidence | null { + if (next === null || next === undefined) return previous; + if (previous === null) return next; + + const keepFailing = + previous.number === next.number && + previous.state === "open" && + next.state === "open" && + previous.hasFailingChecks === true && + next.hasFailingChecks !== false; + + return { + state: next.state, + number: next.number, + ...(keepFailing + ? { hasFailingChecks: true } + : next.hasFailingChecks === undefined + ? {} + : { hasFailingChecks: next.hasFailingChecks }), + }; +} + +/** + * Single place to decide PR evidence for Discord title sync. + * + * Prefer one warm source (VCS remote status) once observed; optional GH branch + * lookup only bootstraps when remote has not been observed yet. Never treat + * "remote not loaded" as "no PR" — that paints ▫️ and thrash-renames old threads. + */ +export function resolveDiscordTitlePrEvidence(input: { + readonly stickyPr: StickyTitlePrEvidence | null; + readonly statusPr: StickyTitlePrEvidence | null | undefined; + readonly remoteStatusObserved: boolean; + readonly branchLookupPr?: StickyTitlePrEvidence | null; + readonly branchLookupCompleted?: boolean; +}): { + readonly stickyPr: StickyTitlePrEvidence | null; + readonly effectivePr: StickyTitlePrEvidence | null; + /** True only when we may paint the no-PR `initialized` (▫️) badge. */ + readonly canApplyNoPrBadge: boolean; +} { + let sticky = input.stickyPr; + // Positive observations always stick. + sticky = mergeStickyTitlePr(sticky, input.statusPr); + if (input.branchLookupCompleted === true) { + sticky = mergeStickyTitlePr(sticky, input.branchLookupPr ?? null); + } + + const canApplyNoPrBadge = + sticky === null && (input.remoteStatusObserved || input.branchLookupCompleted === true); + + return { + stickyPr: sticky, + effectivePr: sticky, + canApplyNoPrBadge, + }; +} + +/** PR / change-request title column (optional). */ +export type DiscordThreadPrBadgeState = "initialized" | "open" | "merged" | "closed" | null; + +/** Working / lifecycle title column (optional). */ +export type DiscordThreadActivityBadgeState = "busy" | "wake-required" | null; + +/** + * Dual-slot Discord title badges (matches T3 client: PR icon + status pill). + * Layout: `| PR | activity | Title` — each slot optional. + */ +export type DiscordThreadTitleBadges = { + readonly pr: DiscordThreadPrBadgeState; + readonly activity: DiscordThreadActivityBadgeState; +}; + +/** + * @deprecated Exclusive single-slot union kept for older tests/callers. + * Prefer `DiscordThreadTitleBadges` / dual-slot helpers. + */ +export type DiscordThreadTitleBadgeState = + | DiscordThreadActivityBadgeState + | DiscordThreadPrBadgeState; + +/** + * Whether Discord is actively Working (turn in progress). + * Mirrors `isTurnInProgress` without the wake-required gate. + */ +function isDiscordThreadTurnBusy(input: { + readonly sessionStatus: string | null | undefined; + readonly latestTurnState?: string | null | undefined; +}): boolean { + if (input.latestTurnState === "running") return true; + if ( + (input.latestTurnState === null || input.latestTurnState === undefined) && + (input.sessionStatus === "running" || input.sessionStatus === "starting") + ) { + return true; + } + return false; +} + +/** + * Working/lifecycle column only (busy / wake-required). Independent of PR badges. + */ +export function resolveDiscordThreadActivityBadgeState(input: { + readonly sessionStatus: string | null | undefined; + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly latestTurnCompletedAt?: string | null | undefined; +}): DiscordThreadActivityBadgeState { + if ( + sessionNeedsWakeUp({ + sessionStatus: input.sessionStatus, + activeTurnId: input.activeTurnId, + latestTurnState: input.latestTurnState, + latestTurnCompletedAt: input.latestTurnCompletedAt, + }) + ) { + return "wake-required"; + } + if ( + isDiscordThreadTurnBusy({ + sessionStatus: input.sessionStatus, + latestTurnState: input.latestTurnState, + }) + ) { + return "busy"; + } + return null; +} + +/** + * @deprecated Prefer dual-slot resolve (`activity` + `pr` separately). + * Returns activity if present, otherwise the PR state (legacy exclusive behavior). + */ +export function resolveDiscordThreadTitleBadgeState(input: { + readonly sessionStatus: string | null | undefined; + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly latestTurnCompletedAt?: string | null | undefined; + readonly prState: DiscordThreadPrBadgeState; +}): DiscordThreadTitleBadgeState { + const activity = resolveDiscordThreadActivityBadgeState(input); + if (activity !== null) return activity; + return input.prState; +} + +/** Compose PR + activity for the current snapshot. */ +export function resolveDiscordThreadTitleBadges(input: { + readonly sessionStatus: string | null | undefined; + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly latestTurnCompletedAt?: string | null | undefined; + readonly prState: DiscordThreadPrBadgeState; +}): DiscordThreadTitleBadges { + return { + pr: input.prState, + activity: resolveDiscordThreadActivityBadgeState(input), + }; +} + +/** Rank used to prevent PR badge flip-flops (higher = more advanced / sticky). */ +export function discordThreadTitleBadgeRank(state: DiscordThreadTitleBadgeState): number { + switch (state) { + case null: + return 0; + case "initialized": + return 1; + case "open": + return 2; + case "closed": + return 3; + case "merged": + return 4; + case "busy": + return 50; + case "wake-required": + return 100; + } +} + +/** + * Parse dual-slot badges from a Discord thread title. + * Accepts new `PR activity Title` order and legacy single-slot / activity-first titles. + */ +export function parseDiscordThreadTitleBadges( + title: string | null | undefined, +): DiscordThreadTitleBadges { + if (title === null || title === undefined || title.trim() === "") { + return { pr: null, activity: null }; + } + let rest = title.trimStart(); + let pr: DiscordThreadPrBadgeState = null; + let activity: DiscordThreadActivityBadgeState = null; + + const takePr = (): boolean => { + // Open + failing checks: standalone ❌ (preferred) or legacy "❌ 🔀". + if (/^❌\s+🔀\s+/u.test(rest) || /^❌\s+/u.test(rest)) { + pr = "open"; + rest = rest.replace(/^❌\s+🔀\s+/u, "").replace(/^❌\s+/u, ""); + return true; + } + if (/^🔀\s+/u.test(rest)) { + pr = "open"; + rest = rest.replace(/^🔀\s+/u, ""); + return true; + } + if (/^✔️\s+/u.test(rest) || /^✓\s+/u.test(rest)) { + pr = "merged"; + rest = rest.replace(/^(?:✔️|✓)\s+/u, ""); + return true; + } + if (/^✖️\s+/u.test(rest) || /^✕\s+/u.test(rest)) { + pr = "closed"; + rest = rest.replace(/^(?:✖️|✕)\s+/u, ""); + return true; + } + if ( + /^▫️\s+/u.test(rest) || + /^·\s+/u.test(rest) || + /^🍴\s+/u.test(rest) || + /^✅\s+/u.test(rest) + ) { + pr = "initialized"; + rest = rest.replace(/^(?:▫️|·|🍴|✅)\s+/u, ""); + return true; + } + return false; + }; + + const takeActivity = (): boolean => { + if (/^❗\s+/u.test(rest)) { + activity = "wake-required"; + rest = rest.replace(/^❗\s+/u, ""); + return true; + } + if (/^⏳\s+/u.test(rest)) { + activity = "busy"; + rest = rest.replace(/^⏳\s+/u, ""); + return true; + } + return false; + }; + + // Preferred order: PR then activity. Also accept legacy activity-first. + if (!takePr()) { + takeActivity(); + takePr(); + } else { + takeActivity(); + } + + return { pr, activity }; +} + +/** + * Parse a single exclusive badge (legacy). Prefer `parseDiscordThreadTitleBadges`. + * When both slots are present, returns the PR badge (activity is independent now). + */ +export function parseDiscordThreadTitleBadgeState( + title: string | null | undefined, +): DiscordThreadTitleBadgeState { + const badges = parseDiscordThreadTitleBadges(title); + // Prefer PR for sticky demotion checks; fall back to activity for pure activity titles. + if (badges.pr !== null) return badges.pr; + return badges.activity; +} + +/** + * Whether applying PR badge `next` over `current` is allowed. + * Never demote open/merged/closed → initialized/plain from transient missing PR data. + * Activity badges are independent and not governed by this helper. + */ +export function shouldApplyDiscordThreadPrBadge( + current: DiscordThreadPrBadgeState, + next: DiscordThreadPrBadgeState, +): boolean { + if (current === next) return true; + if (current === "closed" && next === "open") return true; + if ( + current === "merged" && + (next === "open" || next === "closed" || next === "initialized" || next === null) + ) { + return false; + } + if ( + (current === "open" || current === "merged" || current === "closed") && + (next === "initialized" || next === null) + ) { + return false; + } + return discordThreadTitleBadgeRank(next) >= discordThreadTitleBadgeRank(current); +} + +/** + * Silence: never thrash-rename `⏳ Title` → `▫️ ⏳ Title` mid-turn. + * + * Busy is painted first (before VCS confirms no PR). Adding only the no-PR ▫️ + * badge while still busy is a second channel-name system message with no user + * value — settle can compose ▫️ and clear ⏳ in one rename. + * + * Real PR upgrades (🔀 / ❌ / ✔️ / ✖️) still apply mid-turn. + */ +export function shouldDeferInitializedPrWhileBusy(input: { + readonly currentPr: DiscordThreadPrBadgeState; + readonly nextPr: DiscordThreadPrBadgeState; + readonly currentActivity: DiscordThreadActivityBadgeState; + readonly nextActivity: DiscordThreadActivityBadgeState; +}): boolean { + return ( + input.nextPr === "initialized" && + input.currentPr === null && + input.currentActivity === "busy" && + input.nextActivity === "busy" + ); +} + +/** + * PR column after demotion guards + mid-busy ▫️ silence. + */ +export function resolveSilentDiscordThreadPrBadge(input: { + readonly currentPr: DiscordThreadPrBadgeState; + readonly nextPr: DiscordThreadPrBadgeState; + readonly currentActivity: DiscordThreadActivityBadgeState; + readonly nextActivity: DiscordThreadActivityBadgeState; +}): DiscordThreadPrBadgeState { + const prAllowed = shouldApplyDiscordThreadPrBadge(input.currentPr, input.nextPr); + const appliedPr = prAllowed ? input.nextPr : input.currentPr; + if ( + shouldDeferInitializedPrWhileBusy({ + currentPr: input.currentPr, + nextPr: appliedPr, + currentActivity: input.currentActivity, + nextActivity: input.nextActivity, + }) + ) { + return input.currentPr; + } + return appliedPr; +} + +/** + * @deprecated Dual-slot: use `shouldApplyDiscordThreadPrBadge` for PR; activity always applies. + * Kept for older tests that still pass exclusive states. + */ +export function shouldApplyDiscordThreadTitleBadge( + current: DiscordThreadTitleBadgeState, + next: DiscordThreadTitleBadgeState, +): boolean { + if (current === next) return true; + // Activity transitions always allowed (legacy exclusive API). + if ( + next === "wake-required" || + next === "busy" || + current === "wake-required" || + current === "busy" + ) { + return true; + } + return shouldApplyDiscordThreadPrBadge(current, next); +} + +/** + * Desired Discord title after a prior plain-title settle. + * + * Composes optional PR + activity badges (client-style dual indicators). + * Returns null when the settled title already matches, or when applying would + * demote a stronger PR badge without a usable PR replacement. + * + * `canApplyNoPrBadge` must be true before painting ▫️ from a null PR — unknown + * remote status is not evidence of "no PR". + */ +export function resolveSettledDiscordThreadTitleUpgrade(input: { + readonly thread: Pick & { + readonly session?: OrchestrationThread["session"]; + readonly latestTurn?: OrchestrationThread["latestTurn"]; + }; + readonly mirroredThreadTitle: string | null; + readonly attemptedThreadTitle: string | null; + readonly cachedPr: + | (Pick & { + readonly number?: number; + readonly hasFailingChecks?: boolean; + }) + | null + | undefined; + /** When false, skip upgrades that would paint ▫️ from null/unknown PR evidence. */ + readonly canApplyNoPrBadge?: boolean; +}): string | null { + const rawPrState = threadTitleChangeRequestState(input.thread, input.cachedPr); + const prState: DiscordThreadPrBadgeState = + rawPrState === "initialized" && input.canApplyNoPrBadge === false ? null : rawPrState; + const activity = resolveDiscordThreadActivityBadgeState({ + sessionStatus: input.thread.session?.status ?? null, + activeTurnId: input.thread.session?.activeTurnId ?? null, + latestTurnState: input.thread.latestTurn?.state ?? null, + latestTurnCompletedAt: input.thread.latestTurn?.completedAt ?? null, + }); + + const mirroredBadges = parseDiscordThreadTitleBadges(input.mirroredThreadTitle); + const currentBadges = + mirroredBadges.pr !== null || mirroredBadges.activity !== null + ? mirroredBadges + : parseDiscordThreadTitleBadges(input.attemptedThreadTitle); + + // Sticky PR: refuse demotion; keep current PR column when next would weaken it. + // Also silence mid-busy ▫️-only upgrades (⏳ Title → ▫️ ⏳ Title thrash). + const prAllowed = shouldApplyDiscordThreadPrBadge(currentBadges.pr, prState); + const appliedPr = resolveSilentDiscordThreadPrBadge({ + currentPr: currentBadges.pr, + nextPr: prState, + currentActivity: currentBadges.activity, + nextActivity: activity, + }); + + // Demotion refused and activity unchanged → leave the mirrored title alone + // (preserves ❌ 🔀 etc. without re-decorating from a null PR cache). + // Same for deferred ▫️ while still busy: nothing to rename until settle. + if (appliedPr === currentBadges.pr && activity === currentBadges.activity) { + return null; + } + + // When keeping a sticky open PR without fresh PR evidence, preserve failing-check + // decoration already on the Discord title (standalone ❌ or legacy ❌ 🔀). + const mirroredTitle = input.mirroredThreadTitle ?? ""; + const mirroredHasFailingOpen = + appliedPr === "open" && (/^❌\s+🔀\s+/u.test(mirroredTitle) || /^❌\s+/u.test(mirroredTitle)); + const hasFailingChecks = + appliedPr === "open" && + (input.cachedPr?.hasFailingChecks === true || (!prAllowed && mirroredHasFailingOpen)); + + const desiredTitle = decorateDiscordThreadTitle( + input.thread.title, + { + pr: appliedPr, + activity, + hasFailingChecks, + }, + 100, + ); + // Only treat successfully mirrored titles as settled. + if (desiredTitle === input.mirroredThreadTitle) { + return null; + } + // Nothing to add and Discord title is already plain → wait for PR evidence / assistant. + // Still allow clearing a previous activity-only badge (⏳ → plain). + if ( + appliedPr === null && + activity === null && + currentBadges.pr === null && + currentBadges.activity === null + ) { + return null; + } + return desiredTitle; +} + +/** + * Temporary activity badge only (busy / wake-required). PR stays independent. + */ +export function resolveTemporaryDiscordThreadTitleBadge(input: { + readonly sessionStatus: string | null | undefined; + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly latestTurnCompletedAt?: string | null | undefined; +}): DiscordThreadActivityBadgeState { + return resolveDiscordThreadActivityBadgeState(input); +} + +/** + * Desired-state plan for Discord thread renames. + * + * Title apply must be durable and coalesced: + * - Never apply a previously captured thread snapshot (VCS races re-painted ⏳ + * after settle when the callback held a stale "running" thread). + * - On REST failure / rate-limit / interrupt, keep `pending` so a later tick retries. + * - Only clear pending when Discord already shows that exact name. + */ +export function planDiscordThreadTitleApply(input: { + readonly mirroredThreadTitle: string | null; + readonly pendingDesiredThreadTitle: string | null; + /** Freshly computed desired name, or null when compute has nothing new. */ + readonly computedDesiredTitle: string | null; +}): { + readonly pendingDesiredThreadTitle: string | null; + readonly applyTitle: string | null; +} { + if (input.computedDesiredTitle !== null) { + if (input.computedDesiredTitle === input.mirroredThreadTitle) { + return { pendingDesiredThreadTitle: null, applyTitle: null }; + } + return { + pendingDesiredThreadTitle: input.computedDesiredTitle, + applyTitle: input.computedDesiredTitle, + }; + } + // No fresh compute — retry a prior failed apply if Discord still lags. + if ( + input.pendingDesiredThreadTitle !== null && + input.pendingDesiredThreadTitle !== input.mirroredThreadTitle + ) { + return { + pendingDesiredThreadTitle: input.pendingDesiredThreadTitle, + applyTitle: input.pendingDesiredThreadTitle, + }; + } + return { pendingDesiredThreadTitle: null, applyTitle: null }; +} + +/** + * Commit or roll back after a Discord channel rename attempt. + * Success updates mirrored; failure keeps pending so settle/busy is retried. + */ +export function nextMirroredThreadTitleAfterApply(input: { + readonly mirroredThreadTitle: string | null; + readonly pendingDesiredThreadTitle: string | null; + readonly appliedTitle: string; + readonly success: boolean; +}): { + readonly mirroredThreadTitle: string | null; + readonly pendingDesiredThreadTitle: string | null; + readonly attemptedThreadTitle: string | null; +} { + if (!input.success) { + return { + mirroredThreadTitle: input.mirroredThreadTitle, + pendingDesiredThreadTitle: input.appliedTitle, + // Do not poison attempted with a name Discord never accepted. + attemptedThreadTitle: null, + }; + } + const pendingCleared = + input.pendingDesiredThreadTitle === null || + input.pendingDesiredThreadTitle === input.appliedTitle; + return { + mirroredThreadTitle: input.appliedTitle, + pendingDesiredThreadTitle: pendingCleared ? null : input.pendingDesiredThreadTitle, + attemptedThreadTitle: input.appliedTitle, + }; +} + +export function resolveThreadTitleChangeRequestFromStatus( + thread: Pick, + status: VcsStatusResult | null, +): VcsStatusChangeRequest | null { + return resolveThreadChangeRequest(thread.branch, status); +} + +export function resolveThreadChangeRequestLookupCwds( + thread: Pick, + project: { readonly workspaceRoot: string }, +): ReadonlyArray { + return [ + ...new Set( + [thread.worktreePath, project.workspaceRoot].filter( + (value): value is string => value !== null, + ), + ), + ]; +} + +/** + * Structural view of a transcript message for Discord echo labels. + * + * Accepts both plain orchestration messages and identity-overlay `SourceRef` + * provenance without `exactOptionalPropertyTypes` friction on `source`. + */ +type SourceAwareOrchestrationMessage = { + readonly text: string; + readonly attachments?: ReadonlyArray | null | undefined; + readonly source?: + | { + readonly channel?: string | null | undefined; + readonly username?: string | null | undefined; + } + | null + | undefined; +}; + +function echoedUserSourceLabel(message: SourceAwareOrchestrationMessage): string { + const username = message.source?.username?.trim() || "unknown"; + const channel = message.source?.channel?.trim() || "unknown"; + // Thought-bubble marks cross-client (app) input so Discord readers can + // spot it at a glance next to native channel messages. + return `💭 from **${username}@${channel}**:`; +} + +export function formatEchoedUserMessage(message: SourceAwareOrchestrationMessage): string { + const body = summarizeExternalUserInput(message.text); + const sourceLabel = echoedUserSourceLabel(message); + const attachmentCount = message.attachments?.length ?? 0; + const attachmentNote = + attachmentCount === 0 + ? "" + : attachmentCount === 1 + ? "\n\n_(1 attachment included in the external input)_" + : `\n\n_(${attachmentCount} attachments included in the external input)_`; + if (body === "") { + return attachmentCount === 0 + ? `${sourceLabel}\n_(empty message)_` + : `${sourceLabel}\n${attachmentNote.trim()}`; + } + return `${sourceLabel}\n${body}${attachmentNote}`; +} + +/** + * Assistant messages that belong to the active/latest turn. + * + * Prefer `turnId` matching so a mid-turn steer (extra user message) does not + * orphan pre-steer assistant progress when computing the Discord stream tip or + * final answer. Fall back to "after last user message" when turn ids are missing. + * + * Critical: if we have a turn id and *no* assistants for that turn yet, return + * empty — do **not** fall back to the previous turn's bubbles. That regression + * re-posted the prior final answer on the next Discord Working tip / finalize. + */ +export function assistantMessagesThisTurn( + thread: OrchestrationThread, +): ReadonlyArray { + const turnId = thread.latestTurn?.turnId ?? thread.session?.activeTurnId ?? null; + const selected = assistantMessagesForDelivery({ + messages: thread.messages.map((message) => ({ + id: message.id, + role: message.role, + turnId: message.turnId, + text: message.text, + })), + turnId, + turnInProgress: isTurnInProgress(thread), + hasLatestTurn: thread.latestTurn !== null && thread.latestTurn !== undefined, + // Callers that need lastFinalized filtering use the delivery path with explicit id. + lastFinalizedAssistantId: null, + }); + const ids = new Set(selected.map((entry) => entry.id)); + return thread.messages.filter((message) => message.role === "assistant" && ids.has(message.id)); +} + +/** + * Skip re-delivering an assistant Discord already finalized (prevents re-posting + * the previous final answer when a new user turn starts before latestTurn advances). + * + * Applies even while turnInProgress: a new turn can be running while the snapshot + * still only exposes the prior finalized bubble (time-query race). + */ +export function shouldSkipAlreadyDeliveredAssistant(input: { + readonly assistantId: string; + readonly lastFinalizedAssistantId: string | null; + readonly turnInProgress: boolean; +}): boolean { + void input.turnInProgress; + if (input.lastFinalizedAssistantId === null) return false; + return input.lastFinalizedAssistantId === input.assistantId; +} + +/** + * Seed Discord stream tip slots when a bridge starts/restarts. + * + * - **Mid-turn / rehydrate:** prior stream message ids stay **active** so we keep + * editing the same tip history. + * - **Fresh Working ack (new user turn):** do **not** re-seed prior tip ids. Those + * messages still hold the previous turn's body; attaching them next to a blank + * Working.. then partially rewriting only the first chunk leaves old bubbles + * visible ("old tip + new answer"). Discard them so the new turn starts clean. + */ +export function seedStreamMessageIds(input: { + readonly workingAckMessageId?: string | null | undefined; + readonly persistedStreamMessageIds: ReadonlyArray; + /** + * When true with a working ack, ignore persisted tip ids (new user turn). + * When false/omitted, rehydrate mid-turn history as active tips. + */ + readonly discardPersistedTips?: boolean; +}): { + readonly discordMessageIds: ReadonlyArray; + readonly staleStreamMessageIds: ReadonlyArray; + /** Persisted tip ids that must be deleted from Discord for a clean new turn. */ + readonly orphanTipIdsToDelete: ReadonlyArray; +} { + const ack = + input.workingAckMessageId !== undefined && + input.workingAckMessageId !== null && + input.workingAckMessageId.trim() !== "" + ? input.workingAckMessageId + : null; + const persisted = uniqueDiscordMessageIds(input.persistedStreamMessageIds).filter( + (id) => id !== ack, + ); + const discardPersisted = input.discardPersistedTips === true && ack !== null; + if (discardPersisted) { + return { + discordMessageIds: [ack], + staleStreamMessageIds: [], + orphanTipIdsToDelete: persisted, + }; + } + return { + discordMessageIds: uniqueDiscordMessageIds([...persisted, ...(ack !== null ? [ack] : [])]), + staleStreamMessageIds: [], + orphanTipIdsToDelete: [], + }; +} + +/** Concatenate this turn's assistant bubbles — for live stream tip + stream-history.md. */ +function turnProgressText(thread: OrchestrationThread): string { + return assistantMessagesThisTurn(thread) + .map((message) => message.text.trimEnd()) + .filter((text) => text.trim() !== "") + .join("\n\n") + .trimEnd(); +} + +/** + * User-visible final Discord answer (not the live tip). + * + * Multi-step agents emit many short interim bubbles ("I'm checking…") then a long + * Findings answer. Joining them all into the "final" post looks like the in-progress + * stream was never cleaned up. Prefer the last bubble when it's substantial; otherwise + * the longest bubble of the turn. + * + * Important: a later medium-length delivery (draft PR summary, approach notes) must + * not lose to an earlier longer Findings bubble — that buried PR links in + * stream-history.md only (see the related Discord discussion). + */ +export function finalAnswerText(thread: OrchestrationThread): string { + const texts = assistantMessagesThisTurn(thread) + .map((message) => message.text.trimEnd()) + .filter((text) => text.trim() !== ""); + if (texts.length === 0) return ""; + if (texts.length === 1) return texts[0]!; + + const last = texts[texts.length - 1]!; + const longest = texts.reduce((a, b) => (a.length >= b.length ? a : b)); + + // True short trailer after a long Findings (e.g. ~120 chars after ~3200) → keep Findings. + // Absolute cap matters: 969-char draft PR after 2811-char analysis is *not* a trailer + // (old ratio-only check used 0.5 and discarded the PR). + const SHORT_TRAILER_MAX_CHARS = 400; + if ( + longest.length >= 800 && + last.length < SHORT_TRAILER_MAX_CHARS && + last.length < longest.length * 0.35 + ) { + return longest; + } + // Otherwise prefer the last bubble (natural end of the turn). + return last; +} + +function allStreamIds(state: BridgeState): ReadonlyArray { + return [...new Set([...state.discordMessageIds, ...state.staleStreamMessageIds])]; +} + +function formatMarkdownLocalFileRefForDiscord(input: { + readonly ref: MarkdownLocalFileRef; + readonly githubUrlsBySrc: ReadonlyMap; + readonly attachedFileNames?: ReadonlySet | undefined; + readonly oversizedByName?: ReadonlySet | undefined; +}): string { + const display = + input.ref.label.trim() !== "" ? input.ref.label : fileNameForLocalFileRef(input.ref); + const githubUrl = input.githubUrlsBySrc.get(input.ref.target); + if (githubUrl) { + return `[${display}](${githubUrl})`; + } + + const uploadName = fileNameForLocalFileRef(input.ref); + if (input.oversizedByName?.has(uploadName)) { + return `${display} (too large to attach in Discord)`; + } + if (input.attachedFileNames?.has(uploadName)) { + return `${display} (attached below)`; + } + if (input.attachedFileNames || input.oversizedByName) { + return `${display} (attachment unavailable)`; + } + return input.ref.match; +} + +export function rewriteMarkdownLocalFileLinksForDiscord(input: { + readonly text: string; + readonly githubUrlsBySrc: ReadonlyMap; + readonly attachedFileNames?: ReadonlySet | undefined; + readonly oversizedByName?: ReadonlySet | undefined; +}): string { + return replaceMarkdownLocalFileLinks(input.text, (ref) => + formatMarkdownLocalFileRefForDiscord({ + ref, + githubUrlsBySrc: input.githubUrlsBySrc, + attachedFileNames: input.attachedFileNames, + oversizedByName: input.oversizedByName, + }), + ); +} + +interface InlinePathCodeSpanRef { + readonly match: string; + readonly token: string; +} + +const INLINE_PATH_CODE_SPAN = + /`([^`\n]*\/[^`\n]*\.[A-Za-z0-9_-]{1,16}(?::\d+(?:-\d+)?(?:,\d+(?:-\d+)?)*)?)`/gu; + +function extractInlinePathCodeSpanRefs(text: string): ReadonlyArray { + const refs: InlinePathCodeSpanRef[] = []; + const seen = new Set(); + for (const match of text.matchAll(INLINE_PATH_CODE_SPAN)) { + const full = match[0]; + const token = match[1]?.trim() ?? ""; + if (full === undefined || token === "" || seen.has(full)) continue; + seen.add(full); + refs.push({ match: full, token }); + } + return refs; +} + +const resolveGitHubLinksForInlinePathCodeSpans = ( + refs: ReadonlyArray, + cwd: string | null, +) => + Effect.tryPromise({ + try: async () => { + if (cwd === null) return new Map(); + const urls = new Map(); + const repoContextCache = new Map(); + for (const ref of refs) { + const url = await resolveGitHubBlobUrlForPathReference(ref.token, { + cwd, + repoContextCache, + }); + if (url) { + urls.set(ref.token, url); + } + } + return urls; + }, + catch: (cause) => cause, + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to resolve GitHub links for inline path code spans").pipe( + Effect.andThen(Effect.logError(cause)), + Effect.as(new Map()), + ), + ), + ); + +export function rewriteInlinePathCodeSpansForDiscord(input: { + readonly text: string; + readonly githubUrlsByToken: ReadonlyMap; +}): string { + let out = input.text; + const ordered = [...extractInlinePathCodeSpanRefs(input.text)].sort( + (a, b) => b.match.length - a.match.length, + ); + for (const ref of ordered) { + const githubUrl = input.githubUrlsByToken.get(ref.token); + if (!githubUrl) continue; + out = out.split(ref.match).join(`[\`${ref.token}\`](${githubUrl})`); + } + return out; +} + +const resolveGitHubLinksForMarkdownFiles = (refs: ReadonlyArray) => + Effect.tryPromise({ + try: async () => { + const urls = new Map(); + const repoContextCache = new Map(); + for (const ref of refs) { + const url = await resolveGitHubBlobUrlForLocalPath(ref.target, { repoContextCache }); + if (url) { + urls.set(ref.target, url); + } + } + return urls; + }, + catch: (cause) => cause, + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to resolve GitHub links for markdown files").pipe( + Effect.andThen(Effect.logError(cause)), + Effect.as(new Map()), + ), + ), + ); + +/** Text shown while streaming — drop unreadable local markdown image embeds. */ +function streamDisplayText(text: string): string { + const withoutImages = stripMarkdownImages(text, (ref) => isLocalImageSrc(ref.src)); + const stripped = stripMarkdownLocalFileLinks(withoutImages); + const imageCount = extractMarkdownImages(text).filter((ref) => isLocalImageSrc(ref.src)).length; + const fileCount = extractMarkdownLocalFileLinks(text).filter((ref) => + isLocalFileSrc(ref.src), + ).length; + const localCount = imageCount + fileCount; + if (localCount === 0) return stripped; + const note = + localCount === 1 + ? "_(attachment will attach when done)_" + : `_(${localCount} attachments will attach when done)_`; + return stripped.trim() === "" ? note : `${stripped.trimEnd()}\n\n${note}`; +} + +/** + * After a tip break (user message displaced us), only stream the suffix that is + * new relative to the frozen prefix. Prevents re-copying pre-break content below + * the user message while keeping chronological order. + */ +export function activeStreamTipText(fullDisplayText: string, breakPrefix: string): string { + if (breakPrefix === "") return fullDisplayText; + if (fullDisplayText.startsWith(breakPrefix)) { + return fullDisplayText.slice(breakPrefix.length).replace(/^\n+/u, ""); + } + // Progress rewound / rewritten — show full text on the post-break tip. + return fullDisplayText; +} + +/** + * When a human (or other foreign) message displaces the Working tip, freeze only what + * Discord already showed and set the break prefix to that already-shown text. + * + * Bug this prevents: setting breakPrefix to the *incoming* full body (which had never + * been painted) made post-break tipDisplayText empty — Discord kept a bare Working.. + * above the user and never showed the assistant stream after mid-turn mentions. + */ +export function planStreamTipFreezeOnDisplacement(input: { + /** Cumulative assistant text already applied to the tip before this write. */ + readonly previousFullDisplayText: string; + /** Active tip body after prior break prefixes (what freeze should paint). */ + readonly previousTipBody: string; + /** Raw lastAssistantText before this write (kept for stream diffs). */ + readonly previousLastAssistantText: string; +}): { + /** Idle freeze body for the displaced tip, or null to skip the freeze edit. */ + readonly freezeContent: string | null; + /** Break prefix for subsequent post-break tips (already-shown display text only). */ + readonly nextBreakPrefix: string; + /** lastAssistantText after freeze (raw text already shown). */ + readonly nextLastAssistantText: string; +} { + const tipBody = input.previousTipBody.trim(); + // Never freeze an empty Working-only tip as a blank message; drop it and re-show + // the current write fully on a new tip under the user message. + if (tipBody === "" || tipBody === "…") { + return { + freezeContent: null, + nextBreakPrefix: "", + nextLastAssistantText: "", + }; + } + const freezeChunk = + chunkDiscordContent(input.previousTipBody, STREAM_CHUNK_LIMIT).at(-1) ?? input.previousTipBody; + return { + freezeContent: stripWorkingIndicator(freezeChunk), + nextBreakPrefix: input.previousFullDisplayText, + nextLastAssistantText: input.previousLastAssistantText, + }; +} + +/** + * Move a displaced Working tip: create the replacement first, then delete the old + * message(s). Create-before-delete so Discord never sits without a Working bubble. + * + * Used when an echoed cross-surface command lands below Working. A Discord + * `--steer` / idle Working ack uses {@link nextBridgeStateAfterAdoptWorkingAck} + * instead. Finalize creates a new message and deletes in-progress tips separately. + */ +export function nextStateAfterMovingWorkingTip(input: { + readonly priorDiscordMessageIds: ReadonlyArray; + readonly priorStaleStreamMessageIds: ReadonlyArray; + readonly newTipIds: ReadonlyArray; +}): { + readonly discordMessageIds: ReadonlyArray; + readonly staleStreamMessageIds: ReadonlyArray; + readonly streamBreakPrefix: ""; + readonly oldIdsToDelete: ReadonlyArray; +} { + const newTipIds = [...new Set(input.newTipIds.map((id) => id.trim()).filter((id) => id !== ""))]; + const newSet = new Set(newTipIds); + const oldIdsToDelete = [ + ...new Set(input.priorDiscordMessageIds.map((id) => id.trim()).filter((id) => id !== "")), + ].filter((id) => !newSet.has(id)); + const oldSet = new Set(oldIdsToDelete); + const staleStreamMessageIds = [ + ...new Set(input.priorStaleStreamMessageIds.map((id) => id.trim()).filter((id) => id !== "")), + ].filter((id) => !oldSet.has(id) && !newSet.has(id)); + return { + discordMessageIds: newTipIds, + staleStreamMessageIds, + streamBreakPrefix: "", + oldIdsToDelete, + }; +} + +/** + * Ensure a live bridge is subscribed for this Discord channel. + * Thin wrapper around {@link BridgeHub.ensure} (singleflight + fiber registry + cap). + */ +export const bridgeThreadToDiscord = (input: { + readonly discordChannelId: string; + readonly t3ThreadId: string; + /** Pre-posted "_Working.._" message — reused as stream tip and deleted on finalize. */ + readonly workingAckMessageId?: string | null; + /** Discord-originated T3 user message ids that may appear immediately after subscribe. */ + readonly sentDiscordUserMessageIds?: ReadonlyArray; + /** Final-only avoids progress chatter for ambient conversational turns. */ + readonly presentationMode?: DiscordBridgePresentationMode; + readonly mode?: BridgeEnsureInput["mode"]; + readonly lastActivityAt?: string; + readonly preferred?: boolean; +}) => + Effect.gen(function* () { + const hub = yield* BridgeHub; + yield* hub.ensure({ + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + ...(input.workingAckMessageId === undefined + ? {} + : { workingAckMessageId: input.workingAckMessageId }), + ...(input.sentDiscordUserMessageIds === undefined + ? {} + : { sentDiscordUserMessageIds: input.sentDiscordUserMessageIds }), + ...(input.presentationMode === undefined ? {} : { presentationMode: input.presentationMode }), + mode: input.mode ?? "interactive", + ...(input.lastActivityAt === undefined ? {} : { lastActivityAt: input.lastActivityAt }), + ...(input.preferred === undefined ? {} : { preferred: input.preferred }), + }); + }); + +/** + * Bridge fiber body — owned by ResponseBridge, started via BridgeHub. + * Exported for {@link BridgeHub} layer wiring only. + */ +export const runBridge = ( + input: BridgeEnsureInput, + ready: Deferred.Deferred, + controlSlot: BridgeControlSlot, +) => + Effect.gen(function* () { + const mode = input.mode ?? "interactive"; + yield* Effect.logInfo("Starting Discord↔T3 bridge", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + mode, + hasWorkingAck: Boolean(input.workingAckMessageId), + presentationMode: input.presentationMode ?? "full", + }); + + const t3 = yield* T3Session; + const rest = yield* DiscordREST; + const discordConfig = yield* DiscordConfig.DiscordConfig; + const links = yield* ThreadLinkStore; + const warmCache = yield* ThreadWarmCacheStore; + const me = yield* rest.getMyUser(); + const botUserId = me.id; + const persistedLink = yield* links.getByDiscordThreadId(input.discordChannelId); + const warmCacheEntry = yield* warmCache + .load(input.t3ThreadId) + .pipe(Effect.catchCause(() => Effect.succeed(null))); + // Fresh interactive Working ack = new user turn (not mid-turn steer / rehydrate). + // Do not re-attach previous-turn tip ids — that flashes/keeps old bodies next to + // the new Working bubble until finalize. + const freshWorkingTurn = + mode === "interactive" && + input.workingAckMessageId !== undefined && + input.workingAckMessageId !== null && + input.workingAckMessageId !== ""; + const streamSeed = seedStreamMessageIds({ + workingAckMessageId: input.workingAckMessageId ?? null, + persistedStreamMessageIds: persistedLink?.streamDiscordMessageIds ?? [], + discardPersistedTips: freshWorkingTurn, + }); + const seedLastFinalized = + persistedLink?.lastFinalizedAssistantId ?? warmCacheEntry?.lastFinalizedAssistantId ?? null; + const stateRef = yield* Ref.make({ + ...emptyState({ + workingAckMessageId: freshWorkingTurn ? (input.workingAckMessageId ?? null) : null, + lastFinalizedAssistantId: seedLastFinalized, + }), + discordMessageIds: streamSeed.discordMessageIds, + staleStreamMessageIds: streamSeed.staleStreamMessageIds, + seededWorkingAckPending: freshWorkingTurn, + taskDiscordMessageId: persistedLink?.taskDiscordMessageId ?? null, + // Rehydrate: seed finalizedTurnId later from catch-up / adopt path using durable hints. + sentDiscordUserMessageIds: uniqueMessageIds([ + ...(persistedLink?.sentDiscordUserMessageIds ?? []), + ...(input.sentDiscordUserMessageIds ?? []), + ]), + delivery: initialDeliveryEpochState({ + epoch: freshWorkingTurn ? 1 : 0, + phase: freshWorkingTurn ? "awaiting" : "idle", + lastFinalizedAssistantId: seedLastFinalized, + }), + }); + const latestThreadRef = yield* Ref.make(null); + const latestVcsStatusRef = yield* Ref.make(null); + /** Sticky PR evidence — never cleared by transient null lookups (only force-refresh). */ + const stickyTitlePrRef = yield* Ref.make(null); + /** + * True after VCS stream delivered a real remote payload (remoteUpdated or snapshot + * with remote). local-only events with fabricated pr:null must not count. + */ + const vcsRemoteObservedRef = yield* Ref.make(false); + const vcsStatusSubscriptionRef = yield* Ref.make<{ + readonly cwd: string; + readonly fiber: Fiber.Fiber; + } | null>(null); + + const streamWriteLock = yield* Semaphore.make(1); + const titleSyncLock = yield* Semaphore.make(1); + /** + * Latest desired Discord thread name that has not been confirmed on Discord yet. + * Survives REST failures / secondary timeouts so heartbeat can retry without + * waiting for another T3 snapshot (idle threads used to stay on ⏳ forever). + */ + const pendingDesiredThreadTitleRef = yield* Ref.make(null); + + // Seed title settle cache from Discord's live name so rehydrate demotion guards + // work immediately (in-memory mirrored starts null after every bridge restart). + yield* rest.getChannel(input.discordChannelId).pipe( + Effect.flatMap((channel) => { + const name = "name" in channel && typeof channel.name === "string" ? channel.name : null; + if (name === null || name.trim() === "") return Effect.void; + return Ref.update(stateRef, (current) => ({ + ...current, + mirroredThreadTitle: current.mirroredThreadTitle ?? name, + attemptedThreadTitle: current.attemptedThreadTitle ?? name, + })); + }), + Effect.catchCause((cause) => + Effect.logWarning("Failed to seed Discord thread title from channel", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 200), + }), + ), + ); + // Mutable watermark for trim + warm cache (updated on finalize). + const deliveredMemoryTrim = { + lastFinalizedAssistantId: (persistedLink?.lastFinalizedAssistantId ?? + warmCacheEntry?.lastFinalizedAssistantId ?? + null) as string | null, + }; + const projectThreadForDiscordMemory = (thread: OrchestrationThread): OrchestrationThread => + trimOrchestrationThreadForDiscordMemory({ + thread, + lastFinalizedAssistantId: deliveredMemoryTrim.lastFinalizedAssistantId, + buffer: DISCORD_DELIVERED_MESSAGE_MEMORY_BUFFER, + }); + const persistWarmThreadCache = (thread: OrchestrationThread, sequence: number) => + warmCache + .save({ + threadId: input.t3ThreadId, + snapshotSequence: sequence, + thread: projectThreadForDiscordMemory(thread), + lastFinalizedAssistantId: deliveredMemoryTrim.lastFinalizedAssistantId, + }) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to persist warm thread cache", { + t3ThreadId: input.t3ThreadId, + sequence, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + const persistStreamMessageIds = (ids: ReadonlyArray) => + links.setStreamDiscordMessageIds(input.discordChannelId, uniqueDiscordMessageIds(ids)); + const persistFinalizedAssistant = (assistantId: string) => + Effect.gen(function* () { + deliveredMemoryTrim.lastFinalizedAssistantId = assistantId; + yield* links.updateBridgeHints(input.discordChannelId, { + lastFinalizedAssistantId: assistantId, + streamDiscordMessageIds: [], + }); + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to persist finalize bridge hints").pipe( + Effect.andThen(Effect.logError(cause)), + ), + ), + Effect.asVoid, + ); + + // Best-effort delete of orphaned previous-turn tips so they never sit beside the + // new Working.. as "old body + new answer". + if (streamSeed.orphanTipIdsToDelete.length > 0) { + yield* Effect.logInfo("Deleting leftover stream tips before fresh Working turn", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + count: streamSeed.orphanTipIdsToDelete.length, + ids: streamSeed.orphanTipIdsToDelete, + }); + for (const id of streamSeed.orphanTipIdsToDelete) { + yield* rest.deleteMessage(input.discordChannelId, id).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to delete leftover stream tip", { + id, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + } + } + + yield* persistStreamMessageIds([ + ...streamSeed.discordMessageIds, + ...streamSeed.staleStreamMessageIds, + ]); + yield* links.touch(input.discordChannelId).pipe(Effect.ignore); + + controlSlot.noteSentUserMessageIds = (ids) => + Ref.update(stateRef, (current) => ({ + ...current, + sentDiscordUserMessageIds: uniqueMessageIds([...current.sentDiscordUserMessageIds, ...ids]), + })).pipe(Effect.asVoid); + + controlSlot.adoptWorkingAckMessageId = (messageId) => + Effect.gen(function* () { + if (messageId.trim() === "") return; + // Mid-turn / new user turn on a reused bridge: switch to the new Working tip. + // - Strip Working.. + Stop from prior tips (freeze idle) so they stay as history + // above the human message — do not keep editing them. + // - Clear lastAssistantText so stream/heartbeat paint only under the new tip. + const prior = yield* Ref.get(stateRef); + const next = nextBridgeStateAfterAdoptWorkingAck({ + priorDiscordMessageIds: prior.discordMessageIds, + priorStaleStreamMessageIds: prior.staleStreamMessageIds, + workingAckMessageId: messageId, + }); + const orphanTips = next.orphanTipsToDelete; + const frozenBody = stripWorkingIndicator(prior.lastAssistantText).trim(); + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: next.discordMessageIds, + // Orphans are frozen channel history, not live tips — drop from stale so finalize + // does not delete the pre-steer progress bubble above the human message. + staleStreamMessageIds: next.staleStreamMessageIds.filter( + (id) => !orphanTips.includes(id), + ), + lastAssistantText: next.lastAssistantText, + streamBreakPrefix: next.streamBreakPrefix, + currentTurnId: next.currentTurnId, + t3AssistantMessageId: next.t3AssistantMessageId, + finalizedTurnId: next.finalizedTurnId, + finalDiscordMessageIds: next.finalDiscordMessageIds, + streamHistoryPosted: next.streamHistoryPosted, + postedAttachmentIds: next.postedAttachmentIds, + postedMarkdownImageSrcs: next.postedMarkdownImageSrcs, + postedMarkdownFileSrcs: next.postedMarkdownFileSrcs, + seededWorkingAckPending: next.seededWorkingAckPending, + // New user turn clears prior wake-up notice so a later restart can convert again. + wakeUpNoticePosted: false, + // Structural: bump delivery epoch so finalized prior answer cannot re-stream. + delivery: beginDeliveryEpoch(current.delivery), + })); + // Freeze prior tips: remove Working.. + Stop. Empty Working-only tips are deleted. + if (orphanTips.length > 0) { + const emptyOrphans: string[] = []; + for (const id of orphanTips) { + // Only the last active tip carried streamed prose; earlier slots were chunks. + const isLastActiveTip = + prior.discordMessageIds.length > 0 && + id === prior.discordMessageIds[prior.discordMessageIds.length - 1]; + const body = isLastActiveTip ? frozenBody : ""; + if (body === "" || body === "…") { + emptyOrphans.push(id); + continue; + } + yield* rest + .updateMessage(input.discordChannelId, id, { + ...idleMessageFields(body), + }) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to freeze prior Working tip on mid-turn ack", { + id, + cause: formatAlertCause(cause, 300), + }).pipe( + Effect.andThen( + Effect.sync(() => { + emptyOrphans.push(id); + }), + ), + ), + ), + Effect.asVoid, + ); + } + if (emptyOrphans.length > 0) { + yield* deleteMessages(emptyOrphans).pipe( + Effect.catchCause(Effect.logWarning), + Effect.asVoid, + ); + } + } + const state = yield* Ref.get(stateRef); + yield* persistStreamMessageIds([ + ...state.discordMessageIds, + ...state.staleStreamMessageIds, + ]); + yield* Effect.logInfo("Adopted fresh Working ack for new Discord turn", { + t3ThreadId: input.t3ThreadId, + workingAckMessageId: messageId, + frozenPriorTips: orphanTips.length, + }); + }).pipe(Effect.asVoid); + + yield* Effect.logInfo("Bridge restored persisted Discord state", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + mode, + workingAckMessageId: input.workingAckMessageId ?? null, + persistedTaskDiscordMessageId: persistedLink?.taskDiscordMessageId ?? null, + lastFinalizedAssistantId: persistedLink?.lastFinalizedAssistantId ?? null, + activeStreamTips: streamSeed.discordMessageIds, + state: summarizeBridgeStateForLog(yield* Ref.get(stateRef)), + }); + yield* Effect.logInfo("Bridge services ready; subscribing to T3 thread", { + botUserId, + t3ThreadId: input.t3ThreadId, + mode, + activeStreamTips: streamSeed.discordMessageIds.length, + }); + + const deleteMessages = (ids: ReadonlyArray) => + Effect.gen(function* () { + const unique = [...new Set(ids.filter((id) => id.trim() !== ""))]; + if (unique.length === 0) return; + yield* Effect.logInfo("Deleting Discord in-progress stream messages", { + count: unique.length, + ids: unique, + }); + for (const id of unique) { + yield* rest.deleteMessage(input.discordChannelId, id).pipe( + Effect.tap(() => Effect.logInfo("Deleted stream message", { id })), + Effect.catchCause((cause) => + Effect.logWarning("Failed to delete stream message", { id }).pipe( + Effect.andThen(Effect.logError(cause)), + ), + ), + Effect.asVoid, + ); + } + }).pipe(Effect.asVoid); + + const clearInProgressMessages = (reason: string) => + streamWriteLock.withPermit( + Effect.gen(function* () { + const state = yield* Ref.get(stateRef); + const ids = allStreamIds(state); + if (ids.length === 0) return; + + yield* Effect.logInfo("Clearing Discord in-progress stream messages", { + t3ThreadId: input.t3ThreadId, + reason, + count: ids.length, + state: summarizeBridgeStateForLog(state), + }); + yield* deleteMessages(ids); + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [], + staleStreamMessageIds: [], + streamBreakPrefix: "", + seededWorkingAckPending: false, + })); + yield* persistStreamMessageIds([]); + }).pipe(Effect.asVoid), + ); + + /** + * Replace the latest Working tip with a wake-up notice + Continue button. + * Keeps partial stream prose; removes Working.. and Stop. + */ + const convertWorkingTipsToWakeUp = (reason: string) => + streamWriteLock.withPermit( + Effect.gen(function* () { + const state = yield* Ref.get(stateRef); + if (state.wakeUpNoticePosted) return; + const tipIds = allStreamIds(state); + if (tipIds.length === 0) return; + + // Prefer the active tip slot (last discordMessageIds entry); fall back to any open id. + const tipId = + state.discordMessageIds.length > 0 + ? state.discordMessageIds[state.discordMessageIds.length - 1]! + : tipIds[tipIds.length - 1]!; + + const existingContent = yield* rest.getMessage(input.discordChannelId, tipId).pipe( + Effect.map((message) => message.content ?? ""), + Effect.catchCause(() => Effect.succeed(state.lastAssistantText)), + ); + const content = formatWakeUpTipContent( + existingContent.trim() !== "" ? existingContent : state.lastAssistantText, + ); + const fields = wakeUpMessageFields(content, input.t3ThreadId); + + const updated = yield* rest + .updateMessage(input.discordChannelId, tipId, { ...fields }) + .pipe(Effect.result); + + let wakeMessageId = tipId; + if (Result.isFailure(updated)) { + yield* Effect.logWarning("Wake-up tip update failed; posting a new wake-up message", { + t3ThreadId: input.t3ThreadId, + tipId, + cause: formatAlertCause(updated.failure, 300), + }); + // Drop dead tip ids so they do not linger as "stream" state. + yield* deleteMessages(tipIds).pipe(Effect.ignore); + const created = yield* rest.createMessage(input.discordChannelId, { ...fields }); + wakeMessageId = created.id; + } else { + // Older multi-chunk stream slots: leave history, only the tip is wake-up. + // Clear stream tracking so finalize/stop cleanup does not delete the notice. + const otherIds = tipIds.filter((id) => id !== tipId); + if (otherIds.length > 0) { + // Non-tip chunks keep partial prose; strip any stale Stop via idle edit best-effort. + for (const id of otherIds) { + yield* rest.getMessage(input.discordChannelId, id).pipe( + Effect.flatMap((message) => + rest.updateMessage(input.discordChannelId, id, { + ...idleMessageFields(stripWorkingIndicator(message.content ?? "")), + }), + ), + Effect.catchCause(() => Effect.void), + ); + } + } + } + + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [], + staleStreamMessageIds: [], + streamBreakPrefix: "", + seededWorkingAckPending: false, + wakeUpNoticePosted: true, + adoptedInitialSnapshot: true, + finalDiscordMessageIds: uniqueDiscordMessageIds([ + ...current.finalDiscordMessageIds, + wakeMessageId, + ]), + delivery: { + ...current.delivery, + phase: "finalized" as const, + streamText: "", + settleReady: false, + }, + })); + yield* persistStreamMessageIds([]); + yield* Effect.logInfo("Converted Working tip to wake-up notice", { + t3ThreadId: input.t3ThreadId, + reason, + wakeMessageId, + previousTipIds: tipIds, + }); + }).pipe(Effect.asVoid), + ); + + const persistSentDiscordUserMessageIds = (ids: ReadonlyArray) => + links.setSentDiscordUserMessageIds(input.discordChannelId, uniqueMessageIds(ids)); + + const postExternalUserMessages = ( + messages: ReadonlyArray, + ) => + Effect.gen(function* () { + for (const message of messages) { + yield* rest.createMessage(input.discordChannelId, { + content: formatEchoedUserMessage(message), + }); + } + }).pipe(Effect.asVoid); + + const postOrEditTasks = (content: string, taskKey: string) => + Effect.gen(function* () { + const state = yield* Ref.get(stateRef); + const action = resolveTaskMessageAction({ + taskDiscordMessageId: state.taskDiscordMessageId, + lastTasksKey: state.lastTasksKey, + nextTasksKey: taskKey, + }); + if (action === "skip") return; + + if (action === "update" && state.taskDiscordMessageId !== null) { + yield* rest.updateMessage(input.discordChannelId, state.taskDiscordMessageId, { + content, + }); + yield* Ref.update(stateRef, (current) => ({ + ...current, + lastTasksKey: taskKey, + })); + return; + } + + const created = yield* rest.createMessage(input.discordChannelId, { + content, + }); + yield* Ref.update(stateRef, (current) => ({ + ...current, + taskDiscordMessageId: created.id, + lastTasksKey: taskKey, + })); + yield* links.setTaskDiscordMessageId(input.discordChannelId, created.id); + }).pipe(Effect.asVoid); + + /** + * Download T3 chat image attachments into raw bytes for Discord multipart upload. + */ + const loadAttachmentFiles = ( + attachments: ReadonlyArray, + maxFiles: number, + ) => + Effect.gen(function* () { + const limited = attachments.slice(0, Math.max(0, maxFiles)); + const files: DiscordUploadFile[] = []; + for (const attachment of limited) { + const file = yield* Effect.gen(function* () { + const url = yield* t3.createAttachmentUrl(attachment.id); + const response = yield* Effect.tryPromise({ + try: () => globalThis.fetch(url), + catch: (cause) => cause, + }); + if (!response.ok) { + yield* Effect.logWarning( + `Attachment download failed (${response.status}) for ${attachment.id}`, + ); + return null; + } + const buffer = yield* Effect.tryPromise({ + try: () => response.arrayBuffer(), + catch: (cause) => cause, + }); + return { + name: attachment.name, + mimeType: attachment.mimeType, + data: new Uint8Array(buffer), + } satisfies DiscordUploadFile; + }).pipe( + Effect.catchCause((cause) => + Effect.logError(cause).pipe(Effect.as(null as DiscordUploadFile | null)), + ), + ); + if (file !== null) files.push(file); + } + return files as ReadonlyArray; + }); + + /** + * Load Codex/ACP markdown image embeds as real binary files for Discord multipart. + * 1) Local disk (after stripping attachment:/file://) + * 2) Fallback: T3 assets.createUrl (workspace-file) + HTTP fetch + */ + const loadMarkdownImageFiles = ( + refs: ReadonlyArray, + alreadyPosted: ReadonlyArray, + maxFiles: number, + ) => + Effect.gen(function* () { + const posted = new Set(alreadyPosted); + // Deduplicate by normalized filesystem path so html+link of same file upload once. + const pendingByPath = new Map(); + for (const ref of refs) { + if (!isLocalImageSrc(ref.rawSrc || ref.src)) continue; + if (posted.has(ref.src) || pendingByPath.has(ref.src)) continue; + pendingByPath.set(ref.src, ref); + } + const pending = [...pendingByPath.values()].slice(0, Math.max(0, maxFiles)); + const files: DiscordUploadFile[] = []; + const loadedSrcs: string[] = []; + for (const ref of pending) { + // Grok emits session-relative `images/1.jpg`; Codex usually absolute. + // Resolve before disk read / assets so relative embeds actually upload. + const resolved = + resolveImagePathOnDisk(ref.src) ?? + resolveImagePathOnDisk(ref.rawSrc) ?? + assertFilesystemPath(ref.src); + const filePath = resolved; + const name = fileNameForImageRef(ref); + const mime = guessImageMimeType(filePath); + + yield* Effect.logInfo("Loading markdown image for Discord multipart", { + rawSrc: ref.rawSrc, + filePath, + resolvedFrom: ref.src, + name, + }); + + const fromDisk = yield* Effect.tryPromise({ + try: async () => { + const safePath = assertFilesystemPath(filePath); + const bytes = await NodeFSP.readFile(safePath); + return { + name, + mimeType: mime, + data: new Uint8Array(bytes), + } satisfies DiscordUploadFile; + }, + catch: (cause) => cause, + }).pipe(Effect.option); + + if (fromDisk._tag === "Some") { + files.push(fromDisk.value); + loadedSrcs.push(ref.src); + yield* Effect.logInfo("Loaded image from disk for Discord", { + filePath, + bytes: fromDisk.value.data.byteLength, + }); + continue; + } + + const fromAsset = yield* Effect.gen(function* () { + // Assets API needs a workspace-relative path; absolute agent paths rarely work. + // Prefer original relative src for workspace lookup when we failed disk resolve. + const assetPath = assertFilesystemPath(ref.src); + const url = yield* t3.createWorkspaceFileUrl({ + threadId: input.t3ThreadId as ThreadId, + path: assetPath, + }); + const response = yield* Effect.tryPromise({ + try: () => globalThis.fetch(url), + catch: (cause) => cause, + }); + if (!response.ok) { + yield* Effect.logWarning( + `Asset image download failed (${response.status}) for ${assetPath}`, + ); + return null as DiscordUploadFile | null; + } + const buffer = yield* Effect.tryPromise({ + try: () => response.arrayBuffer(), + catch: (cause) => cause, + }); + return { + name, + mimeType: mime, + data: new Uint8Array(buffer), + } satisfies DiscordUploadFile; + }).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + yield* Effect.logWarning( + `Could not load markdown image for Discord (disk+asset): raw=${ref.rawSrc} path=${filePath}`, + ); + yield* Effect.logError(cause); + return null as DiscordUploadFile | null; + }), + ), + ); + + if (fromAsset !== null) { + files.push(fromAsset); + loadedSrcs.push(ref.src); + yield* Effect.logInfo("Loaded image via T3 assets for Discord", { + filePath, + bytes: fromAsset.data.byteLength, + }); + } + } + return { + files: files as ReadonlyArray, + loadedSrcs: loadedSrcs as ReadonlyArray, + }; + }); + + const loadMarkdownLinkedFiles = ( + refs: ReadonlyArray, + alreadyPosted: ReadonlyArray, + maxFiles: number, + worktreePath: string | null, + ) => + Effect.gen(function* () { + const posted = new Set(alreadyPosted); + const pendingByPath = new Map(); + for (const ref of refs) { + if (!isLocalFileSrc(ref.rawSrc || ref.src)) continue; + if (posted.has(ref.src) || pendingByPath.has(ref.src)) continue; + pendingByPath.set(ref.src, ref); + } + const pending = [...pendingByPath.values()].slice(0, Math.max(0, maxFiles)); + const files: DiscordUploadFile[] = []; + const loadedSrcs: string[] = []; + for (const ref of pending) { + // Agents write worktree-relative paths (e.g. `.plans/note.md`). Resolve + // against the thread worktree before reading — bot cwd is not the project. + const resolved = + resolveLocalFilePathOnDisk(ref.src, worktreePath) ?? + resolveLocalFilePathOnDisk(ref.rawSrc, worktreePath) ?? + assertFilesystemFilePath(ref.src); + const filePath = resolved; + const name = fileNameForLocalFileRef(ref); + const mime = guessFileMimeType(filePath); + + yield* Effect.logInfo("Loading markdown file for Discord multipart", { + rawSrc: ref.rawSrc, + filePath, + worktreePath, + name, + }); + + const fromDisk = yield* Effect.tryPromise({ + try: async () => { + const safePath = assertFilesystemFilePath(filePath); + const bytes = await NodeFSP.readFile(safePath); + return { + name, + mimeType: mime, + data: new Uint8Array(bytes), + } satisfies DiscordUploadFile; + }, + catch: (cause) => cause, + }).pipe(Effect.option); + + if (fromDisk._tag === "Some") { + files.push(fromDisk.value); + loadedSrcs.push(ref.src); + continue; + } + + // Asset URL preview rejects most text types (.md). Prefer a worktree-relative + // path for the RPC so the server can resolve under the project root. + const assetPathForUrl = (() => { + const raw = assertFilesystemFilePath(ref.src); + if (!NodePath.isAbsolute(raw)) return raw.replace(/^\.\//u, ""); + const root = worktreePath?.trim() ?? ""; + if (root !== "" && raw.startsWith(root)) { + const rel = raw.slice(root.length).replace(/^[/\\]+/u, ""); + if (rel !== "") return rel; + } + return raw; + })(); + + const fromAsset = yield* Effect.gen(function* () { + const url = yield* t3.createWorkspaceFileUrl({ + threadId: input.t3ThreadId as ThreadId, + path: assetPathForUrl, + }); + const response = yield* Effect.tryPromise({ + try: () => globalThis.fetch(url), + catch: (cause) => cause, + }); + if (!response.ok) { + yield* Effect.logWarning( + `Asset file download failed (${response.status}) for ${assetPathForUrl}`, + ); + return null as DiscordUploadFile | null; + } + const buffer = yield* Effect.tryPromise({ + try: () => response.arrayBuffer(), + catch: (cause) => cause, + }); + return { + name, + mimeType: mime, + data: new Uint8Array(buffer), + } satisfies DiscordUploadFile; + }).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + yield* Effect.logWarning( + `Could not load markdown file for Discord (disk+asset): raw=${ref.rawSrc} path=${filePath} worktree=${worktreePath ?? "null"}`, + ); + yield* Effect.logError(cause); + return null as DiscordUploadFile | null; + }), + ), + ); + + if (fromAsset !== null) { + files.push(fromAsset); + loadedSrcs.push(ref.src); + } + } + return { + files: files as ReadonlyArray, + loadedSrcs: loadedSrcs as ReadonlyArray, + }; + }); + + const splitFilesForDiscordUpload = (files: ReadonlyArray) => { + const batches: DiscordUploadFile[][] = []; + const oversized: DiscordUploadFile[] = []; + let current: DiscordUploadFile[] = []; + let currentBytes = 0; + + for (const file of files) { + if (file.data.byteLength > DISCORD_CONSERVATIVE_UPLOAD_LIMIT_BYTES) { + oversized.push(file); + continue; + } + const nextTooLarge = + current.length > 0 && + currentBytes + file.data.byteLength > DISCORD_CONSERVATIVE_UPLOAD_LIMIT_BYTES; + const nextTooMany = current.length >= DISCORD_MAX_FILES_PER_MESSAGE; + if (nextTooLarge || nextTooMany) { + batches.push(current); + current = []; + currentBytes = 0; + } + current.push(file); + currentBytes += file.data.byteLength; + } + + if (current.length > 0) { + batches.push(current); + } + + return { + batches: batches as ReadonlyArray>, + oversized: oversized as ReadonlyArray, + }; + }; + + /** + * Create a Discord message. Binary files use native multipart FormData + fetch + * (HTTP/1.1). dfx `withFiles` goes through Effect/Undici HTTP2 and dies with + * NGHTTP2_PROTOCOL_ERROR on ~1MB payloads — never updateMessage with files. + * + * Empty contentLength is expected for image-only replies after markdown embeds + * are stripped; Discord allows content="" when files are present. + */ + const createMessageWithFiles = (content: string, files: ReadonlyArray) => + Effect.gen(function* () { + const body = stripWorkingIndicator(content); + if (files.length === 0) { + const message = yield* rest.createMessage(input.discordChannelId, { + content: body.trim() !== "" ? body : "\u200b", + }); + return { id: message.id as string }; + } + + yield* Effect.logInfo("Discord multipart createMessage (native FormData)", { + contentLen: body.length, + imageOnly: body.trim() === "", + files: files.map((f) => ({ + name: f.name, + mimeType: f.mimeType, + bytes: f.data.byteLength, + })), + }); + + const message = yield* Effect.tryPromise({ + try: () => + createMessageWithAttachments({ + baseUrl: discordConfig.rest.baseUrl, + botToken: Redacted.value(discordConfig.token), + channelId: input.discordChannelId, + content: body, + files, + }), + catch: (cause) => + cause instanceof DiscordUploadError + ? cause + : new DiscordUploadError(cause instanceof Error ? cause.message : String(cause)), + }); + + yield* Effect.logInfo("Discord multipart createMessage ok", { + messageId: message.id, + fileCount: files.length, + }); + return { id: message.id }; + }); + + const currentTurnToolCallCount = (thread: OrchestrationThread | null): number => { + if (thread === null) return 0; + // Latest in-progress work segment only (after last settled assistant for this turn). + return countTurnToolCalls( + thread.activities, + thread.latestTurn?.turnId ?? null, + thread.messages.map((message) => ({ + role: message.role, + turnId: message.turnId, + streaming: message.streaming, + createdAt: message.createdAt, + })), + ); + }; + + /** + * In-progress stream only: + * - edit latest bot message while it remains the channel tip and under 2000 chars + * - if someone posts after us, open a new message (old tip stays tracked for delete) + * - tip ends with italic _Working.._ (optional · N tool calls on the same line) + * + * On turn complete: stream messages are deleted, archived as stream-history.md, + * and the final answer is posted as Discord markdown (links live; no ASCII tables), + * with a T3 deep link always on the stats footer. + */ + const postOrEditAssistantUnlocked = (args: { + readonly turnId: string | null; + readonly t3MessageId: string; + readonly text: string; + readonly streaming: boolean; + readonly images: ReadonlyArray; + readonly worktreePath: string | null; + }) => + Effect.gen(function* () { + const { turnId, t3MessageId, text, streaming, images, worktreePath } = args; + let state = yield* Ref.get(stateRef); + const reopensFinalizedDelivery = shouldReopenFinalizedDelivery({ + finalizedTurnId: state.finalizedTurnId, + currentAssistantMessageId: state.t3AssistantMessageId, + turnId, + nextAssistantMessageId: t3MessageId, + }); + + if ( + state.currentTurnId === turnId && + state.t3AssistantMessageId === t3MessageId && + state.lastAssistantText === text && + (state.discordMessageIds.length > 0 || state.finalDiscordMessageIds.length > 0) && + streaming + ) { + return; + } + + const markdownImages = extractMarkdownImages(text).filter((ref) => + isLocalImageSrc(ref.src), + ); + const pendingMarkdown = markdownImages.filter( + (ref) => !state.postedMarkdownImageSrcs.includes(ref.src), + ); + const markdownFiles = extractMarkdownLocalFileLinks(text).filter((ref) => + isLocalFileSrc(ref.src), + ); + const pendingMarkdownFiles = markdownFiles.filter( + (ref) => !state.postedMarkdownFileSrcs.includes(ref.src), + ); + + // Finished turn with same text already finalized and attachments posted — skip. + if ( + !streaming && + !reopensFinalizedDelivery && + state.finalizedTurnId === turnId && + state.lastAssistantText === text && + unpostedAttachments(images, state.postedAttachmentIds).length === 0 && + pendingMarkdown.length === 0 && + pendingMarkdownFiles.length === 0 + ) { + return; + } + + // After finalize, only late-arriving images are handled (no more stream edits). + if (!streaming && !reopensFinalizedDelivery && state.finalizedTurnId === turnId) { + yield* finalizeAssistantMessage({ + turnId, + t3MessageId, + text, + images, + streamHistoryText: "", + worktreePath, + }); + return; + } + + // Structural gate: never stream after this epoch finalized (avoids final+Working mess). + if (streaming && state.delivery.phase === "finalized" && !reopensFinalizedDelivery) { + yield* Effect.logInfo("Skipping stream write; delivery epoch already finalized", { + t3ThreadId: input.t3ThreadId, + turnId, + t3MessageId, + epoch: state.delivery.epoch, + }); + return; + } + + if (streaming) { + const startsNewDelivery = startsNewStreamDelivery({ + currentTurnId: state.currentTurnId, + nextTurnId: turnId, + reopensFinalizedDelivery, + seededWorkingAckPending: state.seededWorkingAckPending, + }); + + // Queue drain / new Working: promote the prior tip body to a durable final + // before we wipe tip state. Otherwise the real answer only lived as an + // editable tip and vanishes when the next epoch starts (t3vm + // 16feaadd… / segment:5 lost under Working). + if ( + shouldFinalizeStreamBeforeNewDelivery({ + startsNewDelivery, + lastAssistantText: state.lastAssistantText, + t3AssistantMessageId: state.t3AssistantMessageId, + finalizedTurnId: state.finalizedTurnId, + currentTurnId: state.currentTurnId, + }) + ) { + const priorText = state.lastAssistantText; + const priorAssistantId = state.t3AssistantMessageId!; + const priorTurnId = state.currentTurnId; + yield* Effect.logInfo( + "Finalizing prior stream tip before new delivery (queue-drain / turn boundary)", + { + t3ThreadId: input.t3ThreadId, + priorTurnId, + priorAssistantId, + nextTurnId: turnId, + textLen: priorText.length, + }, + ); + yield* finalizeAssistantMessage({ + turnId: priorTurnId, + t3MessageId: priorAssistantId, + text: priorText, + images: [], + streamHistoryText: priorText, + worktreePath, + }).pipe( + Effect.catchCause((cause) => + Effect.logError("Failed to finalize prior stream before new delivery", { + t3ThreadId: input.t3ThreadId, + priorTurnId, + priorAssistantId, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + // Re-read state after finalize (tips deleted, lastFinalized updated). + const afterPriorFinalize = yield* Ref.get(stateRef); + state = afterPriorFinalize; + } + + // Multi-step agents open a new assistant id per bubble while the turn runs. + // Keep the same Discord tip(s) and edit them — never delete/recreate mid-turn + // because humans chatted. Working hops below an echoed command, or relocates + // when a Discord `--steer` / idle turn posts a new Working ack. + // Working.. ack (if seeded) is already in discordMessageIds. + // On a new delivery, only keep the newest tip slot (the Working ack) so we never + // try to edit prior-turn message ids (Discord 10008 Unknown Message). + const tipSlots = activeStreamTipIdsForDelivery({ + startsNewDelivery, + discordMessageIds: state.discordMessageIds, + staleStreamMessageIds: state.staleStreamMessageIds, + }); + let discordMessageIds: readonly string[] = [...tipSlots.discordMessageIds]; + let staleStreamMessageIds: readonly string[] = [...tipSlots.staleStreamMessageIds]; + let streamBreakPrefix = startsNewDelivery ? "" : state.streamBreakPrefix; + // Force a full content rewrite when the tracked assistant id changes so a + // shorter replacement bubble doesn't leave stale suffix text. + let lastText = startsNewDelivery ? "" : state.lastAssistantText; + + const fullDisplayText = streamDisplayText(text); + const previousFullDisplayText = streamDisplayText(lastText); + + // Discord cannot render GFM pipe tables — rewrite complete tables to bullets. + const tipDisplayText = rewriteMarkdownTablesForDiscord( + activeStreamTipText(fullDisplayText, streamBreakPrefix), + ); + const previousTipDisplayText = rewriteMarkdownTablesForDiscord( + activeStreamTipText(previousFullDisplayText, streamBreakPrefix), + ); + + // Always keep a Working tip for liveness even when the model is only running + // tools (no new prose yet). + const desiredChunks = + tipDisplayText.trim() === "" + ? ([""] as string[]) + : chunkDiscordContent(tipDisplayText, STREAM_CHUNK_LIMIT); + + // Preserve tool-call progress on the Working line when stream text changes so the + // 10s heartbeat is not the only place the count can appear mid-prose. + const latestForTools = yield* Ref.get(latestThreadRef); + const toolCallCount = currentTurnToolCallCount(latestForTools); + + for (let index = 0; index < desiredChunks.length; index += 1) { + const chunk = desiredChunks[index] ?? ""; + const existingId = discordMessageIds[index] ?? null; + const isLastChunk = index === desiredChunks.length - 1; + const content = formatInProgressChunk( + chunk, + isLastChunk, + DISCORD_LIMIT, + 2, + toolCallCount, + ); + + if (existingId !== null) { + const previousChunks = chunkDiscordContent( + previousTipDisplayText, + STREAM_CHUNK_LIMIT, + ); + const previousChunk = previousChunks[index] ?? ""; + const previousIsLastChunk = index === previousChunks.length - 1; + const contentChanged = previousChunk !== chunk; + const stopButtonVisibilityChanged = previousIsLastChunk !== isLastChunk; + + if (contentChanged || isLastChunk || stopButtonVisibilityChanged) { + // Edit the original tip in place even if humans posted below it. + // After bot restart, durable tip ids may point at deleted messages — recreate. + const fields = isLastChunk + ? workingMessageFields(content, input.t3ThreadId) + : idleMessageFields(content); + const updated = yield* rest + .updateMessage(input.discordChannelId, existingId, { ...fields }) + .pipe(Effect.result); + if ( + shouldRecreateStreamTipOnUpdateFailure({ + turnInProgress: true, + updateFailed: Result.isFailure(updated), + }) + ) { + yield* Effect.logWarning( + "Stream tip update failed (likely deleted on restart); creating replacement", + { + t3ThreadId: input.t3ThreadId, + deadTipId: existingId, + cause: formatAlertCause( + Result.isFailure(updated) ? updated.failure : "unknown", + 300, + ), + }, + ); + staleStreamMessageIds = uniqueDiscordMessageIds([ + ...staleStreamMessageIds, + existingId, + ]); + const created = yield* rest.createMessage(input.discordChannelId, { + ...fields, + }); + discordMessageIds = [ + ...discordMessageIds.slice(0, index), + created.id, + ...discordMessageIds.slice(index + 1), + ]; + } + } + } else { + const created = yield* rest.createMessage(input.discordChannelId, { + ...(isLastChunk + ? workingMessageFields(content, input.t3ThreadId) + : idleMessageFields(content)), + }); + discordMessageIds = [...discordMessageIds, created.id]; + } + } + + // Messages beyond the new post-break chunk count are obsolete (shorter rewrite). + // Mark stale for finalize cleanup — do not delete mid-turn (preserves order). + if (discordMessageIds.length > desiredChunks.length) { + const extra = discordMessageIds.slice(desiredChunks.length); + staleStreamMessageIds = uniqueDiscordMessageIds([...staleStreamMessageIds, ...extra]); + discordMessageIds = discordMessageIds.slice(0, desiredChunks.length); + } + + yield* Ref.update(stateRef, (current) => ({ + ...current, + currentTurnId: turnId, + t3AssistantMessageId: t3MessageId, + lastAssistantText: text, + discordMessageIds, + staleStreamMessageIds, + streamBreakPrefix, + postedAttachmentIds: startsNewDelivery ? [] : current.postedAttachmentIds, + postedMarkdownImageSrcs: startsNewDelivery ? [] : current.postedMarkdownImageSrcs, + postedMarkdownFileSrcs: startsNewDelivery ? [] : current.postedMarkdownFileSrcs, + finalizedTurnId: startsNewDelivery ? null : current.finalizedTurnId, + finalDiscordMessageIds: startsNewDelivery ? [] : current.finalDiscordMessageIds, + streamHistoryPosted: startsNewDelivery ? false : current.streamHistoryPosted, + seededWorkingAckPending: false, + })); + yield* persistStreamMessageIds([...discordMessageIds, ...staleStreamMessageIds]); + return; + } + + // Turn finished — archive stream tips as stream-history.md, post final answer, + // delete in-progress messages. stream-history is ONLY produced here (not mid-turn). + const prior = yield* Ref.get(stateRef); + const streamHistoryText = shouldArchiveStreamHistory({ + presentationMode: input.presentationMode ?? "full", + hasStreamMessages: allStreamIds(prior).length > 0, + }) + ? prior.lastAssistantText + : ""; + + yield* Ref.update(stateRef, (current) => { + // Keep tip ids for deletion; reset attachment bookkeeping only if this is a + // new assistant id after a prior finalize (should be rare with turn-scoped stream). + const freshAfterFinalize = shouldReopenFinalizedDelivery({ + finalizedTurnId: current.finalizedTurnId, + currentAssistantMessageId: current.t3AssistantMessageId, + turnId, + nextAssistantMessageId: t3MessageId, + }); + return { + ...current, + currentTurnId: turnId, + t3AssistantMessageId: t3MessageId, + lastAssistantText: text, + discordMessageIds: current.discordMessageIds, + staleStreamMessageIds: current.staleStreamMessageIds, + postedAttachmentIds: freshAfterFinalize ? [] : current.postedAttachmentIds, + postedMarkdownImageSrcs: freshAfterFinalize ? [] : current.postedMarkdownImageSrcs, + postedMarkdownFileSrcs: freshAfterFinalize ? [] : current.postedMarkdownFileSrcs, + finalizedTurnId: freshAfterFinalize ? null : current.finalizedTurnId, + finalDiscordMessageIds: freshAfterFinalize ? [] : current.finalDiscordMessageIds, + streamHistoryPosted: freshAfterFinalize ? false : current.streamHistoryPosted, + seededWorkingAckPending: false, + }; + }); + yield* finalizeAssistantMessage({ + turnId, + t3MessageId, + text, + images, + streamHistoryText, + worktreePath, + }); + }).pipe(Effect.asVoid); + + const postOrEditAssistant = (args: Parameters[0]) => { + // Finalize has its own inner timeouts; stream path needs an outer cap so a + // hung listMessages/updateMessage cannot pin delivery + streamWrite locks. + const write = postOrEditAssistantUnlocked(args); + if (!args.streaming) { + return streamWriteLock.withPermit(write); + } + return streamWriteLock.withPermit( + Effect.gen(function* () { + const outcome = yield* write.pipe( + Effect.timeout(BRIDGE_STREAM_DISCORD_TIMEOUT), + Effect.result, + ); + if (Result.isFailure(outcome)) { + yield* Effect.logError("Discord stream tip write failed or timed out", { + t3ThreadId: input.t3ThreadId, + turnId: args.turnId, + t3MessageId: args.t3MessageId, + timeout: BRIDGE_STREAM_DISCORD_TIMEOUT, + cause: formatAlertCause(outcome.failure, 300), + }); + } + }), + ); + }; + + /** + * Final delivery for a completed assistant turn: + * 1. Post Discord markdown content (chunked if needed; links stay clickable) + * 2. Always append · [T3](…#message-…) on the stats footer + * 3. Attach stream-history.md + chat/local images as files + * 4. Delete the in-progress stream messages so only the final answer remains visible + */ + const finalizeAssistantMessage = (args: { + readonly turnId: string | null; + readonly t3MessageId: string; + readonly text: string; + readonly images: ReadonlyArray; + readonly streamHistoryText: string; + readonly worktreePath: string | null; + }) => + Effect.gen(function* () { + const { turnId, t3MessageId, text, images, streamHistoryText, worktreePath } = args; + const state = yield* Ref.get(stateRef); + // Turn-id mismatch used to hard-return with no log, which left Working.. tips + // stranded when catch-up/rehydrate raced a mid-turn id reset. Prefer finishing + // delivery when we still have open tips or non-empty final text. + if (state.currentTurnId !== turnId) { + const openTips = allStreamIds(state).length; + const hasText = text.trim() !== ""; + if (openTips === 0 && !hasText) { + yield* Effect.logInfo("Skipping finalize: turn id mismatch and nothing to post", { + t3ThreadId: input.t3ThreadId, + expectedTurnId: turnId, + currentTurnId: state.currentTurnId, + t3MessageId, + }); + return; + } + yield* Effect.logWarning("Finalize turn id mismatch; proceeding to clear tips / post", { + t3ThreadId: input.t3ThreadId, + expectedTurnId: turnId, + currentTurnId: state.currentTurnId, + t3MessageId, + openTips, + textLen: text.length, + }); + } + + const pendingImages = unpostedAttachments(images, state.postedAttachmentIds); + const markdownRefs = extractMarkdownImages(text).filter((ref) => isLocalImageSrc(ref.src)); + const pendingMarkdown = markdownRefs.filter( + (ref) => !state.postedMarkdownImageSrcs.includes(ref.src), + ); + const markdownFileRefs = extractMarkdownLocalFileLinks(text).filter((ref) => + isLocalFileSrc(ref.src), + ); + const githubUrlsBySrc = yield* resolveGitHubLinksForMarkdownFiles(markdownFileRefs); + const pendingMarkdownFiles = markdownFileRefs.filter( + (ref) => !state.postedMarkdownFileSrcs.includes(ref.src) && !githubUrlsBySrc.has(ref.src), + ); + const durableLink = yield* links + .getByDiscordThreadId(input.discordChannelId) + .pipe(Effect.catchCause(() => Effect.succeed(null))); + const alreadyFinalized = isAssistantAlreadyFinalizedOnDiscord({ + assistantId: t3MessageId, + finalizedTurnId: state.finalizedTurnId, + turnId, + lastFinalizedAssistantId: state.delivery.lastFinalizedAssistantId, + durableLastFinalizedAssistantId: durableLink?.lastFinalizedAssistantId ?? null, + }); + + // Nothing left to do. + if ( + alreadyFinalized && + pendingImages.length === 0 && + pendingMarkdown.length === 0 && + pendingMarkdownFiles.length === 0 + ) { + // Still clear any leftover Working tips if durable finalize outran tip cleanup. + if (allStreamIds(state).length > 0) { + yield* deleteMessages(allStreamIds(state)); + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [], + staleStreamMessageIds: [], + streamBreakPrefix: "", + finalizedTurnId: turnId ?? current.finalizedTurnId, + seededWorkingAckPending: false, + })); + yield* persistStreamMessageIds([]); + } + return; + } + + // Late images after a prior finalize: must be a *new* createMessage with files. + if ( + alreadyFinalized && + (pendingImages.length > 0 || + pendingMarkdown.length > 0 || + pendingMarkdownFiles.length > 0) + ) { + const imageFiles = yield* loadAttachmentFiles( + pendingImages, + DISCORD_MAX_FILES_PER_MESSAGE, + ); + const slotsLeft = DISCORD_MAX_FILES_PER_MESSAGE - imageFiles.length; + const mdLoaded = yield* loadMarkdownImageFiles( + pendingMarkdown, + state.postedMarkdownImageSrcs, + slotsLeft, + ); + const fileSlotsLeft = slotsLeft - mdLoaded.files.length; + const linkedFilesLoaded = yield* loadMarkdownLinkedFiles( + pendingMarkdownFiles, + state.postedMarkdownFileSrcs, + fileSlotsLeft, + worktreePath, + ); + const files = [...imageFiles, ...mdLoaded.files, ...linkedFilesLoaded.files]; + if (files.length === 0) return; + const created = yield* createMessageWithFiles("", files); + const postedFromFiles = pendingImages + .slice(0, imageFiles.length) + .map((entry) => entry.id); + yield* Ref.update(stateRef, (current) => ({ + ...current, + postedAttachmentIds: [...new Set([...current.postedAttachmentIds, ...postedFromFiles])], + postedMarkdownImageSrcs: [ + ...new Set([...current.postedMarkdownImageSrcs, ...mdLoaded.loadedSrcs]), + ], + postedMarkdownFileSrcs: [ + ...new Set([...current.postedMarkdownFileSrcs, ...linkedFilesLoaded.loadedSrcs]), + ], + finalDiscordMessageIds: [...current.finalDiscordMessageIds, created.id], + })); + return; + } + + // Archive in-progress stream as .md only when it has intermediate progress beyond the + // final answer (not a lone Working.. tip, and not message body === stream body). + const historySource = stripWorkingIndicator( + streamHistoryText.trim() !== "" + ? streamHistoryText + : state.t3AssistantMessageId === t3MessageId + ? state.lastAssistantText + : "", + ); + const hadStreamMessages = allStreamIds(state).length > 0; + const finalSource = stripWorkingIndicator(text); + const shouldAttachStreamHistory = + !state.streamHistoryPosted && + hadStreamMessages && + streamHistoryHasAdditionalContent(historySource, finalSource); + + let streamHistoryTextBody: string | null = null; + if (shouldAttachStreamHistory) { + const historyMarkdownFiles = extractMarkdownLocalFileLinks(historySource).filter((ref) => + isLocalFileSrc(ref.src), + ); + const historyGitHubUrlsBySrc = + yield* resolveGitHubLinksForMarkdownFiles(historyMarkdownFiles); + const rewrittenHistorySource = rewriteMarkdownLocalFileLinksForDiscord({ + text: historySource, + githubUrlsBySrc: historyGitHubUrlsBySrc, + }); + const historyInlineGitHubUrlsByToken = yield* resolveGitHubLinksForInlinePathCodeSpans( + extractInlinePathCodeSpanRefs(rewrittenHistorySource), + worktreePath, + ); + const renderedHistorySource = rewriteInlinePathCodeSpansForDiscord({ + text: rewrittenHistorySource, + githubUrlsByToken: historyInlineGitHubUrlsByToken, + }); + streamHistoryTextBody = buildStreamHistoryMarkdownText(renderedHistorySource); + } + + let slots = DISCORD_MAX_FILES_PER_MESSAGE; + const files: DiscordUploadFile[] = []; + if (streamHistoryTextBody !== null) { + files.push(textFile(STREAM_HISTORY_MARKDOWN_NAME, streamHistoryTextBody)); + slots -= 1; + } + + const imageFiles = yield* loadAttachmentFiles(pendingImages, slots); + files.push(...imageFiles); + slots -= imageFiles.length; + + const mdLoaded = yield* loadMarkdownImageFiles( + pendingMarkdown, + state.postedMarkdownImageSrcs, + slots, + ); + files.push(...mdLoaded.files); + slots -= mdLoaded.files.length; + + const linkedFilesLoaded = yield* loadMarkdownLinkedFiles( + pendingMarkdownFiles, + state.postedMarkdownFileSrcs, + slots, + worktreePath, + ); + files.push(...linkedFilesLoaded.files); + + yield* Effect.logInfo("Discord finalize attachments ready", { + fileCount: files.length, + names: files.map((f) => f.name), + totalBytes: files.reduce((sum, f) => sum + f.data.byteLength, 0), + }); + + const postedFromFiles = pendingImages.slice(0, imageFiles.length).map((entry) => entry.id); + + // Split once for local-file rewrite notes (no table .txt attachments). + const { batches: uploadBatches, oversized: oversizedFiles } = + splitFilesForDiscordUpload(files); + const oversizedByName = new Set(oversizedFiles.map((file) => file.name)); + const attachedFileNames = new Set( + uploadBatches.flatMap((batch) => batch.map((file) => file.name)), + ); + + // Final channel text: strip image embeds but keep readable local file references. + // Never leave Working.. or the stream placeholder. + // Keep Discord markdown as-is (links stay clickable). GFM pipe tables → bullets + // (Discord does not render tables; ASCII grids were tried and removed). + // Stats footer always gets · [T3](deep link) when the web UI base is configured. + const finalText = rewriteMarkdownTablesForDiscord( + rewriteMarkdownLocalFileLinksForDiscord({ + text: stripWorkingIndicator(stripMarkdownImages(text)), + githubUrlsBySrc, + attachedFileNames, + oversizedByName, + }) + .replace(/_\(attachment will attach when done\)_/giu, "") + .replace(/_\(\d+ attachments will attach when done\)_/giu, "") + .replace(/\n{3,}/g, "\n\n") + .trim(), + ); + const finalInlineGitHubUrlsByToken = yield* resolveGitHubLinksForInlinePathCodeSpans( + extractInlinePathCodeSpanRefs(finalText), + worktreePath, + ); + const renderedFinalText = rewriteInlinePathCodeSpansForDiscord({ + text: finalText, + githubUrlsByToken: finalInlineGitHubUrlsByToken, + }); + + // Avoid posting a lone "…" placeholder (what you saw in Discord when an image-only + // turn failed to attach and had no remaining text). Prefer empty content + files, + // or a short failure note if we expected images but loaded none. + const baseFinalChunks: string[] = + renderedFinalText !== "" + ? chunkDiscordContent(renderedFinalText, DISCORD_LIMIT) + : files.length > 0 + ? [""] + : pendingMarkdown.length > 0 || + pendingImages.length > 0 || + pendingMarkdownFiles.length > 0 + ? ["_(Could not attach file.)_"] + : text.trim() !== "" + ? ["_(done)_"] + : []; + + // Small italic turn stats on the final answer (model / effort / duration / tokens), + // then always append · [T3](deep link) on that footer section when the URL is known. + const statsThread = yield* Ref.get(latestThreadRef); + const statsLine = formatTurnResponseStatsLine({ + modelSelection: statsThread?.modelSelection ?? null, + ...(statsThread?.activities !== undefined ? { activities: statsThread.activities } : {}), + turnId, + latestTurn: statsThread?.latestTurn ?? null, + }); + let finalChunks = appendStatsToMessageChunks(baseFinalChunks, statsLine, DISCORD_LIMIT); + + const botConfig = yield* DiscordBotConfig; + const t3Url = buildOmegentThreadMessageUrl({ + webUiBaseUrl: botConfig.webUiBaseUrl, + threadId: input.t3ThreadId, + messageId: t3MessageId, + }); + finalChunks = appendT3DeepLinkToChunks(finalChunks, t3Url, DISCORD_LIMIT); + + if (finalChunks.length === 0 && files.length === 0) { + // Nothing useful to post — just clear any leftover Working.. stream messages. + yield* deleteMessages(allStreamIds(state)); + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [], + staleStreamMessageIds: [], + streamBreakPrefix: "", + currentTurnId: turnId, + lastAssistantText: text, + finalizedTurnId: turnId, + finalDiscordMessageIds: [], + streamHistoryPosted: current.streamHistoryPosted || streamHistoryTextBody !== null, + postedAttachmentIds: [...new Set([...current.postedAttachmentIds, ...postedFromFiles])], + postedMarkdownImageSrcs: [ + ...new Set([...current.postedMarkdownImageSrcs, ...mdLoaded.loadedSrcs]), + ], + postedMarkdownFileSrcs: [ + ...new Set([...current.postedMarkdownFileSrcs, ...linkedFilesLoaded.loadedSrcs]), + ], + seededWorkingAckPending: false, + })); + yield* persistStreamMessageIds([]); + yield* persistFinalizedAssistant(t3MessageId); + return; + } + + const streamIds = [...state.discordMessageIds]; + const staleIds = [...state.staleStreamMessageIds]; + const toDelete = [...streamIds, ...staleIds]; + yield* Effect.logInfo("Finalizing Discord assistant delivery", { + t3ThreadId: input.t3ThreadId, + turnId, + t3MessageId, + hadPriorFinalize: alreadyFinalized, + finalTextLength: finalText.length, + finalChunkCount: finalChunks.length, + pendingChatImageCount: pendingImages.length, + pendingMarkdownImageCount: pendingMarkdown.length, + pendingMarkdownFileCount: pendingMarkdownFiles.length, + streamHistoryWillPost: streamHistoryTextBody !== null, + streamIds, + staleIds, + }); + + /** + * Always create final message(s) then delete every in-progress tip. + * Never edit stream tips in place: multi-bubble turns leave long interim + * narration in those tips, and "edit to final" either keeps that text or + * fails to drop extra Working.. chunks. Discord cannot add attachments via edit. + * + * Accept-without-ack: if a prior attempt already landed text chunks (timeout + * before we recorded ids), adopt those message ids instead of createMessage again. + */ + const createFinalWithAttachments = Effect.gen(function* () { + const ids: string[] = []; + for (let index = 0; index < finalChunks.length; index += 1) { + const chunk = finalChunks[index] ?? ""; + const content = chunk.trim() !== "" ? chunk : "_(done)_"; + const created = yield* createMessageWithFiles(content, []); + ids.push(created.id); + // Persist durable finalize marker as soon as the first text chunk lands so a + // later timeout cannot treat this assistant as undelivered and re-post. + if (index === 0) { + yield* persistFinalizedAssistant(t3MessageId); + yield* Ref.update(stateRef, (current) => ({ + ...current, + finalizedTurnId: turnId, + t3AssistantMessageId: t3MessageId, + delivery: { + ...current.delivery, + lastFinalizedAssistantId: t3MessageId, + lastFinalizedText: text, + phase: "finalized" as const, + }, + })); + } + } + + for (const batch of uploadBatches) { + yield* Effect.logInfo("Creating Discord attachment batch", { + files: batch.map((f) => ({ + name: f.name, + mimeType: f.mimeType, + bytes: f.data.byteLength, + })), + totalBytes: batch.reduce((sum, f) => sum + f.data.byteLength, 0), + }); + const created = yield* createMessageWithFiles("", batch); + ids.push(created.id); + } + + if (oversizedFiles.length > 0) { + const note = [ + "**Some files could not be attached due to Discord upload limits:**", + ...oversizedFiles.map( + (file) => `- \`${file.name}\` (${Math.ceil(file.data.byteLength / 1_000_000)} MB)`, + ), + ].join("\n"); + const created = yield* rest.createMessage(input.discordChannelId, { content: note }); + ids.push(created.id); + } + return ids; + }); + + let createdIds: ReadonlyArray = []; + + // Scan recent channel messages for an already-landed final (retry after timeout). + const recent = yield* rest.listMessages(input.discordChannelId, { limit: 25 }).pipe( + Effect.catchCause(() => + Effect.succeed( + [] as ReadonlyArray<{ + readonly id: string; + readonly content?: string; + readonly author?: { readonly id: string }; + }>, + ), + ), + ); + const adoptedFinalIds = findAlreadyPostedFinalChunkIds({ + recentMessages: recent.map((message) => ({ + id: message.id, + authorId: message.author?.id ?? "", + content: message.content ?? "", + })), + botUserId, + finalChunks, + excludeMessageIds: toDelete, + }); + if (adoptedFinalIds !== null) { + yield* Effect.logInfo( + "Finalize adopting already-posted Discord final chunks (idempotent retry)", + { + t3ThreadId: input.t3ThreadId, + turnId, + t3MessageId, + adoptedIds: adoptedFinalIds, + }, + ); + createdIds = adoptedFinalIds; + // Claim durable finalize before tip cleanup so concurrent recover cannot re-create. + yield* persistFinalizedAssistant(t3MessageId); + } else { + const primary = yield* createFinalWithAttachments.pipe( + Effect.timeout(BRIDGE_FINALIZE_DISCORD_TIMEOUT), + Effect.result, + ); + if (Result.isSuccess(primary)) { + createdIds = primary.success; + } else { + yield* Effect.logError(primary.failure); + // Re-scan before fallback create — primary may have partially landed. + const recentAfterTimeout = yield* rest + .listMessages(input.discordChannelId, { limit: 25 }) + .pipe( + Effect.catchCause(() => + Effect.succeed( + [] as ReadonlyArray<{ + readonly id: string; + readonly content?: string; + readonly author?: { readonly id: string }; + }>, + ), + ), + ); + const adoptedAfterTimeout = findAlreadyPostedFinalChunkIds({ + recentMessages: recentAfterTimeout.map((message) => ({ + id: message.id, + authorId: message.author?.id ?? "", + content: message.content ?? "", + })), + botUserId, + finalChunks, + excludeMessageIds: toDelete, + }); + if (adoptedAfterTimeout !== null) { + yield* Effect.logInfo( + "Finalize adopting partial Discord final after timeout (skip fallback create)", + { + t3ThreadId: input.t3ThreadId, + adoptedIds: adoptedAfterTimeout, + }, + ); + createdIds = adoptedAfterTimeout; + yield* persistFinalizedAssistant(t3MessageId); + } else { + // Last resort: text createMessages, then a separate multipart create for files only. + // Also bounded so a hung Discord REST call cannot pin the bridge forever. + const fallback = Effect.gen(function* () { + const ids: string[] = []; + for (const chunk of finalChunks.length > 0 ? finalChunks : ([] as string[])) { + const created = yield* rest.createMessage(input.discordChannelId, { + content: stripWorkingIndicator(chunk.trim() !== "" ? chunk : "_(done)_"), + }); + ids.push(created.id); + if (ids.length === 1) { + yield* persistFinalizedAssistant(t3MessageId); + } + } + if (files.length > 0) { + const fileResult = yield* createMessageWithFiles("", files).pipe(Effect.result); + if (Result.isSuccess(fileResult)) { + ids.push(fileResult.success.id); + } else { + yield* Effect.logError(fileResult.failure); + } + } + return ids; + }).pipe(Effect.timeout(BRIDGE_FINALIZE_DISCORD_TIMEOUT), Effect.result); + const fallbackResult = yield* fallback; + if (Result.isSuccess(fallbackResult)) { + createdIds = fallbackResult.success; + } else { + yield* Effect.logError(fallbackResult.failure); + createdIds = []; + } + } + } + } + + // Always wipe in-progress tips (including Working.. ack), even if create failed + // partially — better empty channel than a stuck interim stream. + yield* deleteMessages(toDelete); + + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [], + staleStreamMessageIds: [], + streamBreakPrefix: "", + currentTurnId: turnId, + lastAssistantText: text, + finalizedTurnId: turnId, + t3AssistantMessageId: t3MessageId, + finalDiscordMessageIds: [...createdIds], + streamHistoryPosted: current.streamHistoryPosted || streamHistoryTextBody !== null, + postedAttachmentIds: [...new Set([...current.postedAttachmentIds, ...postedFromFiles])], + postedMarkdownImageSrcs: [ + ...new Set([...current.postedMarkdownImageSrcs, ...mdLoaded.loadedSrcs]), + ], + postedMarkdownFileSrcs: [ + ...new Set([...current.postedMarkdownFileSrcs, ...linkedFilesLoaded.loadedSrcs]), + ], + seededWorkingAckPending: false, + delivery: { + ...current.delivery, + phase: "finalized" as const, + lastFinalizedAssistantId: t3MessageId, + lastFinalizedText: text, + finalizedAssistantId: t3MessageId, + streamText: "", + settleReady: false, + }, + })); + yield* persistStreamMessageIds([]); + // Durable marker may already be set after first chunk; write again is a no-op merge. + yield* persistFinalizedAssistant(t3MessageId); + + // Collect any GitHub PR URLs from the finalized answer into the pinned thread-info. + const prUrlsFromAnswer = extractPullRequestUrls(text); + if (prUrlsFromAnswer.length > 0) { + const botConfig = yield* DiscordBotConfig; + yield* upsertThreadInfoPin({ + discordThreadId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + botConfig, + incomingPrUrls: prUrlsFromAnswer, + worktreePath, + local: worktreePath === null, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to refresh thread info pin with PR links", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + error: String(error), + }), + ), + ); + } + + yield* Effect.logInfo("Discord assistant delivery finalized", { + t3ThreadId: input.t3ThreadId, + turnId, + t3MessageId, + createdIds, + deletedInProgressIds: toDelete, + postedFromFiles, + uploadedMarkdownImageSrcs: mdLoaded.loadedSrcs, + uploadedMarkdownFileSrcs: linkedFilesLoaded.loadedSrcs, + }); + }).pipe(Effect.asVoid); + + const postApprovals = (approvals: ReadonlyArray) => + Effect.gen(function* () { + if (approvals.length === 0) return; + const key = approvals.map((entry) => entry.requestId).join(","); + const state = yield* Ref.get(stateRef); + if (state.lastApprovalKey === key) return; + + for (const approval of approvals) { + yield* rest.createMessage(input.discordChannelId, { + content: [ + `**Approval required** (${approval.requestKind})`, + approval.detail ?? "_No detail provided_", + ].join("\n"), + components: UI.grid([ + [ + UI.button({ + custom_id: `t3_approve:${input.t3ThreadId}:${approval.requestId}`, + label: "Allow", + style: Discord.ButtonStyleTypes.SUCCESS, + }), + UI.button({ + custom_id: `t3_deny:${input.t3ThreadId}:${approval.requestId}`, + label: "Deny", + style: Discord.ButtonStyleTypes.DANGER, + }), + ], + ]), + }); + } + + yield* Ref.update(stateRef, (current) => ({ + ...current, + lastApprovalKey: key, + })); + }).pipe(Effect.asVoid); + + /** + * Apply a Discord thread title only after a successful rename. + * Never mark `attemptedThreadTitle` / `mirroredThreadTitle` before the REST call — + * a rate-limit / network failure used to poison retries so busy/wake badges never + * appeared. Failed applies keep `pendingDesiredThreadTitle` for heartbeat retry. + * + * Must run under `titleSyncLock`. + */ + const applyDiscordThreadTitle = (desiredTitle: string, reason: string) => + Effect.gen(function* () { + const latest = yield* Ref.get(stateRef); + if (latest.mirroredThreadTitle === desiredTitle) { + yield* Ref.set(pendingDesiredThreadTitleRef, null); + return; + } + // Record desired *before* REST so interrupt/timeout/rate-limit still retries. + yield* Ref.set(pendingDesiredThreadTitleRef, desiredTitle); + const result = yield* rest + .updateChannel(input.discordChannelId, { name: desiredTitle }) + .pipe(Effect.result); + const pending = yield* Ref.get(pendingDesiredThreadTitleRef); + if (Result.isFailure(result)) { + const afterFail = nextMirroredThreadTitleAfterApply({ + mirroredThreadTitle: latest.mirroredThreadTitle, + pendingDesiredThreadTitle: pending, + appliedTitle: desiredTitle, + success: false, + }); + yield* Ref.set(pendingDesiredThreadTitleRef, afterFail.pendingDesiredThreadTitle); + yield* Effect.logWarning("Discord thread title rename failed; will retry", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + desiredTitle, + reason, + cause: formatAlertCause(result.failure, 300), + }); + return; + } + const afterOk = nextMirroredThreadTitleAfterApply({ + mirroredThreadTitle: latest.mirroredThreadTitle, + pendingDesiredThreadTitle: pending, + appliedTitle: desiredTitle, + success: true, + }); + yield* Effect.logInfo("Discord thread title mirrored to Discord", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + desiredTitle, + reason, + }); + yield* Ref.set(pendingDesiredThreadTitleRef, afterOk.pendingDesiredThreadTitle); + yield* Ref.update(stateRef, (current) => ({ + ...current, + attemptedThreadTitle: afterOk.attemptedThreadTitle ?? desiredTitle, + mirroredThreadTitle: afterOk.mirroredThreadTitle, + })); + }); + + /** + * Idempotent, desired-state title badge sync. + * + * Dual optional columns (like T3 client): `| PR | activity | Title`. + * Activity (busy / wake-required) is independent of sticky PR evidence. + * Unknown remote never paints ▫️. + * + * **Always re-reads `latestThreadRef` under the lock** — never apply a caller- + * captured thread snapshot for activity. VCS callbacks used to re-paint ⏳ after + * settle when they held a stale "running" thread across the lock queue. + * + * Callers must publish the latest orchestration thread to `latestThreadRef` + * (via `ensureVcsStatusSubscription` / snapshot path) *before* invoking this. + */ + const syncDiscordThreadTitle = () => + titleSyncLock + .withPermit( + Effect.gen(function* () { + const commitComputedTitle = (desiredTitle: string | null, reason: string) => + Effect.gen(function* () { + const latest = yield* Ref.get(stateRef); + const pending = yield* Ref.get(pendingDesiredThreadTitleRef); + const plan = planDiscordThreadTitleApply({ + mirroredThreadTitle: latest.mirroredThreadTitle, + pendingDesiredThreadTitle: pending, + computedDesiredTitle: desiredTitle, + }); + yield* Ref.set(pendingDesiredThreadTitleRef, plan.pendingDesiredThreadTitle); + if (plan.applyTitle === null) return; + yield* applyDiscordThreadTitle(plan.applyTitle, reason); + }); + + // Coalesce: re-read the latest thread under the lock before every compute + // and again right before apply so a settle that landed while we held the + // lock (or during GH lookup) always wins over a stale busy state. + for (let attempt = 0; attempt < 3; attempt += 1) { + const thread = yield* Ref.get(latestThreadRef); + if (thread === null) { + const pendingOnly = yield* Ref.get(pendingDesiredThreadTitleRef); + const stateOnly = yield* Ref.get(stateRef); + const planOnly = planDiscordThreadTitleApply({ + mirroredThreadTitle: stateOnly.mirroredThreadTitle, + pendingDesiredThreadTitle: pendingOnly, + computedDesiredTitle: null, + }); + yield* Ref.set(pendingDesiredThreadTitleRef, planOnly.pendingDesiredThreadTitle); + if (planOnly.applyTitle !== null) { + yield* applyDiscordThreadTitle(planOnly.applyTitle, "pending-retry-no-thread"); + } + return; + } + + const state = yield* Ref.get(stateRef); + const titleBase = (value: string) => + decorateDiscordThreadTitle(value, null, 100, false); + const currentBase = titleBase(thread.title); + const alreadySettled = + (state.mirroredThreadTitle !== null && + titleBase(state.mirroredThreadTitle) === currentBase) || + (state.attemptedThreadTitle !== null && + titleBase(state.attemptedThreadTitle) === currentBase); + + const cachedStatus = yield* Ref.get(latestVcsStatusRef); + const remoteObserved = yield* Ref.get(vcsRemoteObservedRef); + const stickyBefore = yield* Ref.get(stickyTitlePrRef); + const statusPr = toStickyTitlePrEvidence( + resolveThreadTitleChangeRequestFromStatus(thread, cachedStatus), + ); + + // Fast path: settled base + no new PR evidence from warm VCS — compose + // PR (sticky) + activity without GH dual-lookup. Covers turn start/end + // busy toggles so settle never waits on branch lookup. + if (alreadySettled && statusPr === null) { + const evidence = resolveDiscordTitlePrEvidence({ + stickyPr: stickyBefore, + statusPr: null, + remoteStatusObserved: remoteObserved, + }); + yield* Ref.set(stickyTitlePrRef, evidence.stickyPr); + + // Re-read immediately before decorating activity so we do not paint ⏳ + // from a thread that settled while we waited for this lock. + const threadNow = (yield* Ref.get(latestThreadRef)) ?? thread; + if (threadNow !== thread && attempt < 2) { + continue; + } + const upgradeTitle = resolveSettledDiscordThreadTitleUpgrade({ + thread: threadNow, + mirroredThreadTitle: state.mirroredThreadTitle, + attemptedThreadTitle: state.attemptedThreadTitle, + cachedPr: evidence.effectivePr, + canApplyNoPrBadge: evidence.canApplyNoPrBadge, + }); + const activityNow = resolveDiscordThreadActivityBadgeState({ + sessionStatus: threadNow.session?.status ?? null, + activeTurnId: threadNow.session?.activeTurnId ?? null, + latestTurnState: threadNow.latestTurn?.state ?? null, + latestTurnCompletedAt: threadNow.latestTurn?.completedAt ?? null, + }); + yield* commitComputedTitle( + upgradeTitle, + activityNow !== null ? "dual-badge-settled" : "settled-title-badge-upgrade", + ); + return; + } + + const project = yield* t3.getProjectShell(thread.projectId); + const branch = thread.branch; + + // Prefer warm VCS stream. Only cold-start GH lookup when remote is unknown + // and sticky is empty — never dual-source every snapshot. + let branchLookupPr: StickyTitlePrEvidence | null = null; + let branchLookupCompleted = false; + let prSource: "vcs-status-stream" | "sticky" | "branch-lookup" | "none" = "none"; + let lookupCwds: ReadonlyArray = []; + + if (statusPr !== null) { + prSource = "vcs-status-stream"; + } else if (stickyBefore !== null) { + prSource = "sticky"; + } else if (!remoteObserved && branch !== null && project !== null) { + lookupCwds = resolveThreadChangeRequestLookupCwds(thread, project); + for (const cwd of lookupCwds) { + const resolved = yield* t3 + .resolveBranchChangeRequest({ + cwd, + refName: branch, + }) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Discord thread title PR lookup failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + title: thread.title, + branch, + cwd, + cause: formatAlertCause(cause, 400), + }).pipe(Effect.as({ pr: null })), + ), + ); + yield* Effect.logInfo("Discord thread title PR lookup result", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + title: thread.title, + branch, + cwd, + prNumber: resolved.pr?.number ?? null, + prState: resolved.pr?.state ?? null, + prHeadRef: resolved.pr?.headRef ?? null, + prBaseRef: resolved.pr?.baseRef ?? null, + }); + if (resolved.pr !== null) { + branchLookupPr = toStickyTitlePrEvidence(resolved.pr); + prSource = "branch-lookup"; + break; + } + } + // Completed the cold-start lookup path (possibly with no PR). + branchLookupCompleted = true; + if (prSource === "none") prSource = "branch-lookup"; + } else if (branch === null || project === null) { + yield* Effect.logInfo("Discord thread title sync skipping PR lookup", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + title: thread.title, + branch, + hasProject: project !== null, + worktreePath: thread.worktreePath, + }); + } + + const evidence = resolveDiscordTitlePrEvidence({ + stickyPr: stickyBefore, + statusPr, + remoteStatusObserved: remoteObserved, + branchLookupPr, + branchLookupCompleted, + }); + yield* Ref.set(stickyTitlePrRef, evidence.stickyPr); + + // Re-read after slow GH lookup — settle may have landed mid-wait. + const threadAfterLookup = (yield* Ref.get(latestThreadRef)) ?? thread; + if (threadAfterLookup !== thread && attempt < 2) { + continue; + } + + const activityAfterLookup = resolveDiscordThreadActivityBadgeState({ + sessionStatus: threadAfterLookup.session?.status ?? null, + activeTurnId: threadAfterLookup.session?.activeTurnId ?? null, + latestTurnState: threadAfterLookup.latestTurn?.state ?? null, + latestTurnCompletedAt: threadAfterLookup.latestTurn?.completedAt ?? null, + }); + + const prState = threadTitleChangeRequestState( + threadAfterLookup, + evidence.effectivePr, + ); + // Unknown evidence: do not paint ▫️ / no-PR from missing data. + const effectivePrState: DiscordThreadPrBadgeState = + prState === "initialized" && !evidence.canApplyNoPrBadge ? null : prState; + + const latest = yield* Ref.get(stateRef); + const mirroredBadges = parseDiscordThreadTitleBadges(latest.mirroredThreadTitle); + const currentBadges = + mirroredBadges.pr !== null || mirroredBadges.activity !== null + ? mirroredBadges + : parseDiscordThreadTitleBadges(latest.attemptedThreadTitle); + const prAllowed = shouldApplyDiscordThreadPrBadge(currentBadges.pr, effectivePrState); + // Silence mid-busy ▫️-only upgrades so VCS "no PR" does not second-rename + // after the busy paint (⏳ → ▫️ ⏳ thrash). Settle composes both later. + const appliedPr = resolveSilentDiscordThreadPrBadge({ + currentPr: currentBadges.pr, + nextPr: effectivePrState, + currentActivity: currentBadges.activity, + nextActivity: activityAfterLookup, + }); + + // Still nothing actionable (no PR column, no activity, nothing mirrored). + if (appliedPr === null && activityAfterLookup === null && currentBadges.pr === null) { + yield* Effect.logInfo("Discord thread title sync deferred; PR evidence not ready", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + remoteObserved, + stickyPr: evidence.stickyPr?.number ?? null, + prSource, + activity: activityAfterLookup, + }); + yield* commitComputedTitle(null, "pending-retry-deferred"); + return; + } + + // Deferred ▫️ while still busy and activity already matches → no rename. + if ( + appliedPr === currentBadges.pr && + activityAfterLookup === currentBadges.activity && + latest.mirroredThreadTitle !== null + ) { + yield* commitComputedTitle(null, "silence-defer-initialized-while-busy"); + return; + } + + const desiredTitle = decorateDiscordThreadTitle( + threadAfterLookup.title, + { + pr: appliedPr, + activity: activityAfterLookup, + hasFailingChecks: + appliedPr === "open" && evidence.effectivePr?.hasFailingChecks === true, + }, + 100, + ); + yield* Effect.logInfo("Discord thread title sync resolved", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + title: threadAfterLookup.title, + branch, + worktreePath: threadAfterLookup.worktreePath, + projectWorkspaceRoot: project?.workspaceRoot ?? null, + lookupCwds, + cachedStatusRefName: cachedStatus?.refName ?? null, + prNumber: evidence.effectivePr?.number ?? null, + prState: effectivePrState, + appliedPr, + activity: activityAfterLookup, + sessionStatus: threadAfterLookup.session?.status ?? null, + prSource, + remoteObserved, + canApplyNoPrBadge: evidence.canApplyNoPrBadge, + desiredTitle, + currentBadges, + prAllowed, + mirroredThreadTitle: latest.mirroredThreadTitle, + attemptedThreadTitle: latest.attemptedThreadTitle, + }); + + yield* commitComputedTitle(desiredTitle, "title-sync"); + return; + } + }), + ) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to mirror T3 thread title to Discord thread", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 400), + }), + ), + Effect.asVoid, + ); + + controlSlot.refreshThreadIndicators = () => + Effect.gen(function* () { + let thread = yield* Ref.get(latestThreadRef); + if (thread === null) { + for (let attempt = 0; attempt < 20; attempt += 1) { + yield* Effect.sleep("100 millis"); + thread = yield* Ref.get(latestThreadRef); + if (thread !== null) break; + } + } + if (thread === null) { + return { + ok: false as const, + error: "T3 thread not available yet for indicator refresh; try again in a moment", + }; + } + + // Force full re-evaluation: drop settle cache, sticky PR, and VCS cache. + yield* Ref.update(stateRef, (current) => ({ + ...current, + mirroredThreadTitle: null, + attemptedThreadTitle: null, + })); + yield* Ref.set(latestVcsStatusRef, null); + yield* Ref.set(stickyTitlePrRef, null); + yield* Ref.set(vcsRemoteObservedRef, false); + + if (thread.worktreePath !== null) { + yield* t3.refreshVcsStatus(thread.worktreePath).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Forced VCS status refresh failed during indicator refresh", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 300), + }), + ), + ); + } + + yield* Ref.set(latestThreadRef, thread); + yield* syncDiscordThreadTitle(); + const state = yield* Ref.get(stateRef); + if (state.mirroredThreadTitle !== null) { + yield* Effect.logInfo("Discord thread indicators refreshed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + title: state.mirroredThreadTitle, + }); + return { ok: true as const, title: state.mirroredThreadTitle }; + } + + // Last resort: mirror plain decorated title without PR (still clears stale badges). + const fallbackTitle = decorateDiscordThreadTitle( + thread.title, + threadTitleChangeRequestState(thread, null), + 100, + false, + ); + yield* rest.updateChannel(input.discordChannelId, { name: fallbackTitle }); + yield* Ref.update(stateRef, (current) => ({ + ...current, + mirroredThreadTitle: fallbackTitle, + attemptedThreadTitle: fallbackTitle, + })); + yield* Effect.logInfo("Discord thread indicators refreshed (fallback title)", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + title: fallbackTitle, + }); + return { ok: true as const, title: fallbackTitle }; + }).pipe( + Effect.catch((error: unknown) => + Effect.succeed({ + ok: false as const, + error: error instanceof Error ? error.message : String(error), + }), + ), + ); + + const stopVcsStatusSubscription = Effect.gen(function* () { + const subscription = yield* Ref.get(vcsStatusSubscriptionRef); + if (subscription === null) return; + yield* Fiber.interrupt(subscription.fiber).pipe(Effect.ignore); + yield* Ref.set(vcsStatusSubscriptionRef, null); + yield* Ref.set(latestVcsStatusRef, null); + // Keep sticky PR + remoteObserved across cwd resubscribe so a worktree path + // bounce does not re-open the null→▫️ window. Force-refresh clears them. + yield* Effect.logInfo("Discord thread title VCS status subscription stopped", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cwd: subscription.cwd, + }); + }); + + const ensureVcsStatusSubscription = (thread: OrchestrationThread) => + Effect.gen(function* () { + yield* Ref.set(latestThreadRef, thread); + + const cwd = thread.worktreePath; + const subscription = yield* Ref.get(vcsStatusSubscriptionRef); + if (cwd === null) { + yield* stopVcsStatusSubscription; + return; + } + if (subscription?.cwd === cwd) { + return; + } + + yield* stopVcsStatusSubscription; + // Server-side VcsStatusBroadcaster already runs one remote poller per cwd when + // clients subscribe. Do NOT also force-refresh every 30s from the bot — that + // doubled GitHub/gh fan-out across every Discord bridge and starved the server. + // forkDetach (not forkScoped): bridge fibers are started with forkDetach and + // have no ambient Scope. forkScoped here used to fail every onThread after + // rehydrate, so Discord stream/finalize never ran while T3 kept working. + const fiber = yield* t3 + .subscribeVcsStatus(cwd, (event) => + Effect.gen(function* () { + // Only real remote payloads count as observed. localUpdated / snapshot + // with remote:null must not unlock the no-PR (▫️) badge. + if ( + event._tag === "remoteUpdated" || + (event._tag === "snapshot" && event.remote !== null) + ) { + yield* Ref.set(vcsRemoteObservedRef, true); + } + yield* Ref.update(latestVcsStatusRef, (current) => + applyGitStatusStreamEvent(current, event), + ); + // Do not capture a thread snapshot here — activity must be re-read under + // titleSyncLock from latestThreadRef so a concurrent settle cannot lose to + // a stale "running" VCS callback (⏳ flip-flop after the turn ends). + if ((yield* Ref.get(latestThreadRef)) === null) return; + + yield* Effect.logInfo("Discord thread title VCS status update received", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cwd, + eventTag: event._tag, + remoteObserved: + event._tag === "remoteUpdated" || + (event._tag === "snapshot" && event.remote !== null), + }); + yield* syncDiscordThreadTitle(); + }), + ) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Discord thread title VCS status subscription failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cwd, + cause: formatAlertCause(cause, 400), + }), + ), + Effect.asVoid, + Effect.forkDetach, + ); + yield* Ref.set(vcsStatusSubscriptionRef, { cwd, fiber }); + yield* Effect.logInfo("Discord thread title VCS status subscription started", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cwd, + }); + }).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + yield* Effect.logWarning("ensureVcsStatusSubscription failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 400), + }); + yield* postBridgeAlert( + `vcs-sub:${input.discordChannelId}`, + "VCS title subscription failed", + [ + `channel=\`${input.discordChannelId}\``, + `thread=\`${input.t3ThreadId}\``, + formatAlertCause(cause), + ].join("\n"), + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + }).pipe(Effect.asVoid), + ), + ); + + let subscriptionReady = false; + const signalReady = Effect.gen(function* () { + if (subscriptionReady) return; + subscriptionReady = true; + yield* Deferred.succeed(ready, undefined); + yield* Effect.logInfo("First T3 thread snapshot received; subscription live", { + t3ThreadId: input.t3ThreadId, + }); + }); + + /** + * Re-post the live Working tip at the channel end (create first, then delete + * the old one). Used when an echoed desktop/web/mobile/GitHub command landed + * below Working. + */ + const hopWorkingTipToChannelEnd = (reason: string) => + Effect.gen(function* () { + const state = yield* Ref.get(stateRef); + const tipId = state.discordMessageIds.at(-1) ?? null; + if (tipId === null) return; + const latest = yield* Ref.get(latestThreadRef); + const turnRunning = latest !== null && isTurnInProgress(latest); + const hb = decideHeartbeat({ + state: state.delivery, + turnInProgress: turnRunning, + hasOpenTip: true, + }); + if (hb._tag === "noop") return; + + const toolCallCount = currentTurnToolCallCount(latest); + const tipDisplay = rewriteMarkdownTablesForDiscord(streamDisplayText(hb.tipBody)); + const chunks = + tipDisplay.trim() === "" + ? ([""] as string[]) + : chunkDiscordContent(tipDisplay, STREAM_CHUNK_LIMIT); + const tipChunk = chunks.at(-1) ?? ""; + const hopContent = formatInProgressChunk(tipChunk, true, DISCORD_LIMIT, 2, toolCallCount); + const created = yield* rest.createMessage(input.discordChannelId, { + ...workingMessageFields(hopContent, input.t3ThreadId), + }); + const moved = nextStateAfterMovingWorkingTip({ + priorDiscordMessageIds: [tipId], + priorStaleStreamMessageIds: state.staleStreamMessageIds, + newTipIds: [...state.discordMessageIds.filter((id) => id !== tipId), created.id], + }); + yield* deleteMessages(moved.oldIdsToDelete).pipe( + Effect.catchCause(Effect.logWarning), + Effect.asVoid, + ); + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [...moved.discordMessageIds], + staleStreamMessageIds: [...moved.staleStreamMessageIds], + streamBreakPrefix: moved.streamBreakPrefix, + })); + const afterHop = yield* Ref.get(stateRef); + yield* persistStreamMessageIds(allStreamIds(afterHop)); + yield* Effect.logInfo("Hopped Working tip below echoed command", { + t3ThreadId: input.t3ThreadId, + reason, + deletedDiscordMessageId: tipId, + messageId: created.id, + toolCallCount, + }); + }); + + const workingTipIsAboveEchoedCommand = (streamTipId: string | null) => + Effect.gen(function* () { + if (streamTipId === null || streamTipId.trim() === "") return false; + const recent = yield* rest + .listMessages(input.discordChannelId, { limit: 15 }) + .pipe(Effect.orElseSucceed(() => [] as ReadonlyArray)); + return isStreamTipDisplacedByEchoedCommand({ + recentMessagesNewestFirst: recent, + streamTipId, + }); + }); + + const updateWorkingHeartbeat = Effect.fn("ResponseBridge.updateWorkingHeartbeat")(function* ( + workingDots: WorkingDotCount, + ) { + yield* streamWriteLock.withPermit( + Effect.gen(function* () { + const state = yield* Ref.get(stateRef); + let tipId = state.discordMessageIds.at(-1) ?? null; + const latest = yield* Ref.get(latestThreadRef); + const turnRunning = latest !== null && isTurnInProgress(latest); + const toolCallCount = currentTurnToolCallCount(latest); + + const hb = decideHeartbeat({ + state: state.delivery, + turnInProgress: turnRunning, + hasOpenTip: tipId !== null, + }); + if (hb._tag === "noop") return; + + // No tip yet but epoch still awaiting/streaming: recreate Working dots only. + if (tipId === null) { + if ( + !shouldRecreateTip({ + state: state.delivery, + updateFailed: true, + turnInProgress: turnRunning, + }) + ) { + return; + } + const content = formatInProgressChunk( + "", + true, + DISCORD_LIMIT, + workingDots, + toolCallCount, + ); + const created = yield* rest.createMessage(input.discordChannelId, { + ...workingMessageFields(content, input.t3ThreadId), + }); + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [created.id], + seededWorkingAckPending: current.delivery.phase === "awaiting", + })); + yield* persistStreamMessageIds([created.id]); + yield* Effect.logInfo("Heartbeat recreated missing Working tip for running turn", { + t3ThreadId: input.t3ThreadId, + messageId: created.id, + epoch: state.delivery.epoch, + phase: state.delivery.phase, + toolCallCount, + }); + return; + } + + // Echoed desktop/web/mobile/GitHub command below Working: hop the live tip + // under that command. Casual thread chat must not hop. + if ( + shouldHopWorkingTipOnDisplacement("echoed-command") && + (yield* workingTipIsAboveEchoedCommand(tipId)) + ) { + yield* hopWorkingTipToChannelEnd("heartbeat-echoed-command"); + return; + } + + // Epoch FSM: awaiting → dots only; streaming → current epoch streamText only. + // Same GFM→bullets rewrite as the primary stream path. + const tipDisplay = rewriteMarkdownTablesForDiscord( + activeStreamTipText(streamDisplayText(hb.tipBody), state.streamBreakPrefix), + ); + + const chunks = + tipDisplay.trim() === "" + ? ([""] as string[]) + : chunkDiscordContent(tipDisplay, STREAM_CHUNK_LIMIT); + const tipChunk = chunks.at(-1) ?? ""; + const content = formatInProgressChunk( + tipChunk, + true, + DISCORD_LIMIT, + workingDots, + toolCallCount, + ); + const fields = workingMessageFields(content, input.t3ThreadId); + const updated = yield* rest + .updateMessage(input.discordChannelId, tipId, { ...fields }) + .pipe(Effect.result); + if ( + shouldRecreateTip({ + state: state.delivery, + updateFailed: Result.isFailure(updated), + turnInProgress: turnRunning, + }) + ) { + const created = yield* rest.createMessage(input.discordChannelId, { ...fields }); + tipId = created.id; + yield* Ref.update(stateRef, (current) => ({ + ...current, + discordMessageIds: [created.id], + staleStreamMessageIds: uniqueDiscordMessageIds([ + ...current.staleStreamMessageIds, + ...current.discordMessageIds, + ]), + })); + const after = yield* Ref.get(stateRef); + yield* persistStreamMessageIds(allStreamIds(after)); + yield* Effect.logWarning("Heartbeat recreated dead Working tip", { + t3ThreadId: input.t3ThreadId, + messageId: created.id, + cause: formatAlertCause(Result.isFailure(updated) ? updated.failure : "unknown", 200), + }); + } + }), + ); + }); + + const alertStreamFailure = (phase: string) => (cause: unknown) => + Effect.gen(function* () { + const pretty = formatAlertCause(cause); + yield* Effect.logError("Discord stream post/edit failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + phase, + cause: pretty, + }); + yield* postBridgeAlert( + `stream:${input.discordChannelId}:${phase}`, + "Discord stream post/edit failed", + [ + `channel=\`${input.discordChannelId}\``, + `thread=\`${input.t3ThreadId}\``, + `phase=\`${phase}\``, + pretty, + ].join("\n"), + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + }).pipe(Effect.asVoid); + + /** + * Keep the pinned thread-info Model line in sync when the T3 thread model changes + * (Discord `--model` flag, web UI, etc.). Includes "since …, started with …" history. + */ + const syncThreadInfoModelPin = (thread: OrchestrationThread) => + Effect.gen(function* () { + const modelSelection = thread.modelSelection; + if (modelSelection === undefined || modelSelection === null) return; + + const modelLine = formatModelSelectionLine(modelSelection); + const link = yield* links.getByDiscordThreadId(input.discordChannelId); + if (link === null) return; + if (link.currentModelLine === modelLine) return; + + const botConfig = yield* DiscordBotConfig; + yield* upsertThreadInfoPin({ + discordThreadId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + botConfig, + modelSelection, + worktreePath: thread.worktreePath, + local: thread.worktreePath === null, + }); + yield* Effect.logInfo("Thread info pin model updated", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + previousModel: link.currentModelLine ?? null, + nextModel: modelLine, + }); + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to sync thread info model pin", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + error: String(error), + }), + ), + ); + + /** + * Apply one thread snapshot to Discord (stream tip / finalize / tasks / title). + * Must not run concurrently for the same bridge — callers serialize via deliveryLock. + * + * Order matters: assistant stream/finalize runs **before** title/pin/side work. + * Mid-turn thread renames used to run first (with optional GH PR lookups) and hold + * this queue so intermediate tip edits coalesced away — Discord stayed on + * `_Working.._` until the final, while the channel name still updated. Finals + * still landed; live progress did not. + */ + const processThreadSnapshot = (thread: OrchestrationThread) => + Effect.gen(function* () { + yield* ensureVcsStatusSubscription(thread); + + // Cheap bookkeeping only — no Discord REST — so we do not delay the tip path. + const threadUserMessageIds = uniqueMessageIds( + thread.messages.filter((message) => message.role === "user").map((message) => message.id), + ); + const priorState = yield* Ref.get(stateRef); + const unseenExternalUserMessages = externalUserMessagesToEcho({ + messages: thread.messages, + observedInitialUserSnapshot: priorState.observedInitialUserSnapshot, + seenUserMessageIds: priorState.seenUserMessageIds, + sentDiscordUserMessageIds: priorState.sentDiscordUserMessageIds, + }); + const unresolvedSentDiscordUserMessageIds = priorState.sentDiscordUserMessageIds.filter( + (messageId) => !threadUserMessageIds.includes(messageId), + ); + yield* Ref.update(stateRef, (current) => ({ + ...current, + seenUserMessageIds: uniqueMessageIds([ + ...current.seenUserMessageIds, + ...threadUserMessageIds, + ]), + observedInitialUserSnapshot: true, + sentDiscordUserMessageIds: unresolvedSentDiscordUserMessageIds, + })); + if ( + unresolvedSentDiscordUserMessageIds.length !== priorState.sentDiscordUserMessageIds.length + ) { + yield* persistSentDiscordUserMessageIds(unresolvedSentDiscordUserMessageIds); + } + + const activeTurnId = thread.latestTurn?.turnId ?? null; + const turnInProgressNow = isTurnInProgress(thread); + + // Interrupted session (Wake Required): convert open Working tips to a Continue notice + // before catch-up finalize would treat partial stream as a finished answer. + { + const preWake = yield* Ref.get(stateRef); + if ( + shouldConvertWorkingTipsToWakeUp({ + sessionStatus: thread.session?.status ?? null, + activeTurnId: thread.session?.activeTurnId ?? null, + latestTurnState: thread.latestTurn?.state ?? null, + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + turnInProgress: turnInProgressNow, + openStreamTipCount: allStreamIds(preWake).length, + wakeUpNoticePosted: preWake.wakeUpNoticePosted, + }) + ) { + yield* convertWorkingTipsToWakeUp("session-interrupted").pipe( + Effect.catchCause(alertStreamFailure("wake-up-convert")), + Effect.asVoid, + ); + } + } + + const assistant = thread.messages.findLast((message) => message.role === "assistant"); + + // --- Primary: stream tip / finalize (user-visible progress) --- + // Skip stream/finalize when we just converted (or previously posted) a wake-up notice + // for a real mid-turn interrupt — partial content is not a completed final. + const afterWakeState = yield* Ref.get(stateRef); + if (isSessionWakeRequired(thread) && afterWakeState.wakeUpNoticePosted) { + // Secondary path still runs for title (❗) / pin / tasks. + } else if (assistant !== undefined) { + const prior = yield* Ref.get(stateRef); + + // Structural delivery: assistants allowed for Discord this snapshot (epoch FSM). + // lastFinalizedAssistantId excludes prior-turn bodies even while the new turn + // is already in progress (snapshot race before the new user message lands). + // Re-read durable cursor each snapshot so reconnect/catch-up cannot ignore a + // finalize written by a prior epoch or after a delivery-state reset. + const durableLinkNow = yield* links + .getByDiscordThreadId(input.discordChannelId) + .pipe(Effect.catchCause(() => Effect.succeed(null))); + const lastFinalizedForDelivery = + prior.delivery.lastFinalizedAssistantId ?? + durableLinkNow?.lastFinalizedAssistantId ?? + persistedLink?.lastFinalizedAssistantId ?? + warmCacheEntry?.lastFinalizedAssistantId ?? + null; + const lastFinalizedTextForDelivery = prior.delivery.lastFinalizedText ?? null; + const threadMessagesForDelivery = thread.messages.map((message) => ({ + id: message.id, + role: message.role, + turnId: message.turnId, + text: message.text, + })); + const deliveryAssistants = assistantMessagesForDelivery({ + messages: threadMessagesForDelivery, + turnId: activeTurnId, + turnInProgress: turnInProgressNow, + hasLatestTurn: thread.latestTurn !== null && thread.latestTurn !== undefined, + lastFinalizedAssistantId: lastFinalizedForDelivery, + lastFinalizedText: lastFinalizedTextForDelivery, + }); + // Queue drain auto-starts the parked follow-up (correct). Discord must + // still post the prior T3 answer as its own final first — even if the + // next turn already has assistants or the premature-status finalize + // already deleted the Working tip. + const priorCatchUp = unfinalizedPriorAssistantForCatchUp({ + messages: threadMessagesForDelivery, + currentTurnId: activeTurnId, + lastFinalizedAssistantId: lastFinalizedForDelivery, + lastFinalizedText: lastFinalizedTextForDelivery, + }); + if (priorCatchUp !== null) { + yield* Effect.logInfo( + "Catch-up finalizing prior turn before queued follow-up delivery", + { + t3ThreadId: input.t3ThreadId, + priorTurnId: priorCatchUp.turnId, + priorAssistantId: priorCatchUp.id, + nextTurnId: activeTurnId, + textLen: priorCatchUp.text.length, + }, + ); + yield* postOrEditAssistant({ + turnId: priorCatchUp.turnId, + t3MessageId: priorCatchUp.id, + text: priorCatchUp.text, + streaming: false, + images: [], + worktreePath: thread.worktreePath, + }).pipe( + Effect.catchCause((cause) => + Effect.logError("Failed to catch-up finalize prior turn", { + t3ThreadId: input.t3ThreadId, + priorTurnId: priorCatchUp.turnId, + priorAssistantId: priorCatchUp.id, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + } + const afterCatchUp = yield* Ref.get(stateRef); + const lastFinalizedAfterCatchUp = + afterCatchUp.delivery.lastFinalizedAssistantId ?? lastFinalizedForDelivery; + const lastFinalizedTextAfterCatchUp = + afterCatchUp.delivery.lastFinalizedText ?? lastFinalizedTextForDelivery; + const deliveryAssistantIds = new Set(deliveryAssistants.map((entry) => entry.id)); + const turnAssistants = thread.messages.filter( + (message) => message.role === "assistant" && deliveryAssistantIds.has(message.id), + ); + const images = turnAssistants.flatMap((message) => + imageAttachmentsOf(message.attachments), + ); + const streaming = + turnInProgressNow || + turnAssistants.some( + (message) => isAssistantStreaming(thread, message.id) || message.streaming === true, + ); + + const decision = decideAssistantDelivery({ + state: { + ...afterCatchUp.delivery, + // Keep durable finalize memory from the link store in sync. + lastFinalizedAssistantId: lastFinalizedAfterCatchUp, + lastFinalizedText: lastFinalizedTextAfterCatchUp, + }, + turnId: activeTurnId, + turnInProgress: turnInProgressNow, + assistants: deliveryAssistants.map((entry) => ({ + id: entry.id, + text: entry.text, + })), + messages: threadMessagesForDelivery, + streaming, + presentationFull: (input.presentationMode ?? "full") === "full", + // Idle catch-up (rehydrate *or* interactive recovery after a comment) often + // gets a single settled snapshot — do not stream the previous final under + // `_Working.._` + Stop waiting for a second settle tick that never arrives. + // Substantial answers also finalize immediately inside decideAssistantDelivery. + skipSettleGrace: !turnInProgressNow, + }); + + yield* Effect.logInfo("Discord delivery decision", { + t3ThreadId: input.t3ThreadId, + turnId: activeTurnId, + intent: decision.intent._tag, + reason: + decision.intent._tag === "noop" || decision.intent._tag === "hold" + ? decision.intent.reason + : null, + phase: decision.state.phase, + epoch: decision.state.epoch, + settleReady: decision.state.settleReady, + deliveryAssistants: deliveryAssistants.length, + streaming, + turnInProgress: turnInProgressNow, + }); + + // Apply non-terminal state before I/O; finalize commits only after successful post + // so a failed finalize can retry without being stuck in phase=finalized. + if (decision.intent._tag !== "finalize") { + // Late multi-bubble reopen: epoch left finalized → streaming/awaiting with a + // new assistant after lastFinalized. Clear bridge finalizedTurnId so stream / + // re-finalize is not treated as a no-op duplicate of the short status final. + const reopenedAfterPrematureFinal = + prior.delivery.phase === "finalized" && + (decision.state.phase === "streaming" || decision.state.phase === "awaiting"); + yield* Ref.update(stateRef, (current) => ({ + ...current, + delivery: decision.state, + adoptedInitialSnapshot: true, + seededWorkingAckPending: decision.state.phase === "awaiting", + lastAssistantText: retainUnfinalizedStreamText({ + phase: decision.state.phase, + streamText: decision.state.streamText, + priorLastAssistantText: current.lastAssistantText, + }), + finalizedTurnId: + decision.state.phase === "awaiting" || reopenedAfterPrematureFinal + ? null + : current.finalizedTurnId, + currentTurnId: decision.state.turnId ?? current.currentTurnId, + t3AssistantMessageId: decision.state.assistantId ?? current.t3AssistantMessageId, + })); + } else { + yield* Ref.update(stateRef, (current) => ({ + ...current, + adoptedInitialSnapshot: true, + })); + } + + if (decision.intent._tag === "stream") { + yield* postOrEditAssistant({ + turnId: decision.intent.turnId, + t3MessageId: decision.intent.assistantId, + text: decision.intent.text, + streaming: true, + images, + worktreePath: thread.worktreePath, + }).pipe(Effect.catchCause(alertStreamFailure("live-stream")), Effect.asVoid); + } else if (decision.intent._tag === "finalize") { + yield* postOrEditAssistant({ + turnId: decision.intent.turnId, + t3MessageId: decision.intent.assistantId, + text: decision.intent.text, + streaming: false, + images, + worktreePath: thread.worktreePath, + }).pipe(Effect.catchCause(alertStreamFailure("finalize")), Effect.asVoid); + // Commit terminal epoch only after finalize attempt (success path updates tips). + yield* Ref.update(stateRef, (current) => ({ + ...current, + delivery: decision.state, + seededWorkingAckPending: false, + lastAssistantText: "", + finalizedTurnId: decision.state.turnId ?? activeTurnId, + currentTurnId: decision.state.turnId ?? current.currentTurnId, + t3AssistantMessageId: decision.state.assistantId, + })); + } else if ( + decision.intent._tag === "noop" && + decision.intent.reason === "settled-without-content" && + !prior.seededWorkingAckPending && + prior.delivery.phase !== "finalized" + ) { + // Prefer posting whatever we already streamed over wiping Working with silence. + const fallbackText = prior.lastAssistantText.trim(); + if (fallbackText !== "" && prior.t3AssistantMessageId !== null) { + yield* Effect.logInfo( + "Finalizing from last streamed body (settled without new content)", + { + t3ThreadId: input.t3ThreadId, + turnId: activeTurnId, + textLen: fallbackText.length, + }, + ); + yield* postOrEditAssistant({ + turnId: activeTurnId, + t3MessageId: prior.t3AssistantMessageId, + text: fallbackText, + streaming: false, + images: [], + worktreePath: thread.worktreePath, + }).pipe( + Effect.catchCause(alertStreamFailure("finalize-stream-fallback")), + Effect.asVoid, + ); + yield* Ref.update(stateRef, (current) => ({ + ...current, + delivery: { + ...current.delivery, + phase: "finalized" as const, + streamText: "", + settleReady: false, + finalizedAssistantId: prior.t3AssistantMessageId, + lastFinalizedAssistantId: prior.t3AssistantMessageId, + lastFinalizedText: fallbackText, + }, + seededWorkingAckPending: false, + lastAssistantText: "", + finalizedTurnId: activeTurnId, + })); + } else { + yield* clearInProgressMessages("settled-without-final-content").pipe( + Effect.catchCause(Effect.logError), + Effect.asVoid, + ); + } + } + } else { + const stateBefore = yield* Ref.get(stateRef); + const turnRunningNoAssistant = isTurnInProgress(thread); + yield* Ref.update(stateRef, (current) => + current.adoptedInitialSnapshot ? current : { ...current, adoptedInitialSnapshot: true }, + ); + const state = yield* Ref.get(stateRef); + yield* Effect.logInfo("Bridge thread update (no assistant message yet)", { + t3ThreadId: input.t3ThreadId, + messageCount: thread.messages.length, + sessionStatus: thread.session?.status ?? null, + turnState: thread.latestTurn?.state ?? null, + seededWorkingAckPending: state.seededWorkingAckPending, + state: summarizeBridgeStateForLog(state), + }); + if ( + turnRunningNoAssistant && + !state.seededWorkingAckPending && + shouldPublishAssistantUpdate({ + presentationMode: input.presentationMode ?? "full", + streaming: true, + }) + ) { + // Rehydrate / live: turn is spinning (tools only) with no assistant bubble yet. + // Keep or recreate a Working tip so Discord shows the turn is alive. + const needsWorkingTip = + mode === "rehydrate" || + !stateBefore.adoptedInitialSnapshot || + allStreamIds(state).length === 0; + if (needsWorkingTip) { + yield* Effect.logInfo("Ensuring Working tip for in-progress turn without assistant", { + t3ThreadId: input.t3ThreadId, + turnId: activeTurnId, + mode, + openTips: allStreamIds(state).length, + }); + yield* postOrEditAssistant({ + turnId: activeTurnId, + t3MessageId: REHYDRATE_WORKING_PLACEHOLDER_ID, + text: "", + streaming: true, + images: [], + worktreePath: thread.worktreePath, + }).pipe( + Effect.catchCause(alertStreamFailure("rehydrate-working-no-assistant")), + Effect.asVoid, + ); + } + } else if (!turnRunningNoAssistant && !state.seededWorkingAckPending) { + // A stopped/interrupted turn with no assistant content still needs to clear the + // initial Working.. ack from Discord. + yield* clearInProgressMessages("settled-without-assistant-message").pipe( + Effect.catchCause(Effect.logError), + Effect.asVoid, + ); + } + } + + // --- Secondary: title / pin / side posts (must not starve tip edits) --- + // Title first, with its own budget: turn settle must clear ⏳ even when GH + // lookup / tasks would burn the shared secondary timeout. Pending renames + // also retry on the Working heartbeat so idle threads do not stay stale. + yield* syncDiscordThreadTitle().pipe( + Effect.timeout("12 seconds"), + Effect.catchCause((cause) => + Effect.logWarning("Discord thread title sync failed or timed out", { + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + + // Best-effort + hard time budget for remaining secondary work. + yield* Effect.gen(function* () { + yield* syncThreadInfoModelPin(thread); + + // Tasks first: first-class Discord progress UI from turn.plan (not External User Input). + // Keep updating mid-turn / rehydrate; owned via taskDiscordMessageId so it never freezes Working. + const tasks = presentTasks(thread.activities, thread.latestTurn?.turnId ?? null); + if (tasks !== null && input.presentationMode !== "final-only") { + const content = formatTasksForDiscord(tasks); + const key = `${tasks.explanation ?? ""}:${tasks.tasks.map((task) => `${task.status}:${task.step}`).join("|")}`; + yield* postOrEditTasks(content, key).pipe( + Effect.catchCause(Effect.logError), + Effect.asVoid, + ); + } + + // Cross-surface user text only (github / t3-client whitelist) — after Tasks. + if (unseenExternalUserMessages.length > 0) { + yield* postExternalUserMessages(unseenExternalUserMessages).pipe( + Effect.catchCause(Effect.logError), + Effect.asVoid, + ); + if (shouldHopWorkingTipOnDisplacement("echoed-command")) { + yield* streamWriteLock + .withPermit(hopWorkingTipToChannelEnd("external-user-echo")) + .pipe(Effect.catchCause(Effect.logWarning), Effect.asVoid); + } + } + + const pending = derivePendingInteractions(thread.activities); + const approvals = pending.filter( + (entry): entry is PendingApproval => entry.kind === "approval", + ); + yield* postApprovals(approvals).pipe(Effect.catchCause(Effect.logError), Effect.asVoid); + + if (thread.session?.status === "error" && thread.session.lastError) { + yield* rest + .createMessage(input.discordChannelId, { + content: `**T3 error:** ${thread.session.lastError}`, + }) + .pipe(Effect.catchCause(Effect.logError), Effect.asVoid); + } + }).pipe( + Effect.timeout(BRIDGE_SECONDARY_DISCORD_TIMEOUT), + Effect.catchCause((cause) => + Effect.logWarning("Bridge secondary Discord work failed or timed out", { + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + }).pipe(Effect.asVoid); + + /** + * Coalescing delivery queue. + * + * Previously every WS event awaited full Discord I/O inside Stream.runForEach. + * A slow/hung createMessage blocked the subscription fiber, so later assistant + * bubbles never reached Discord while the T3 client still advanced. + * + * Now: WS only publishes the latest snapshot + bumps a generation. A single + * worker holds deliveryLock, always applies the newest snapshot, and loops if + * more arrivals happened during Discord work. + */ + const deliveryGenerationRef = yield* Ref.make(0); + const deliveryProcessedRef = yield* Ref.make(0); + const deliveryFailureCountRef = yield* Ref.make(0); + const deliveryLock = yield* Semaphore.make(1); + // Dual cursor: orchestration sequence observed from T3 (WS/HTTP), vs sequence + // successfully applied to Discord after processThreadSnapshot. + const latestObservedSequenceRef = yield* Ref.make( + persistedLink?.lastThreadSnapshotSequence ?? null, + ); + const persistDeliverySequence = (sequence: number) => + links + .updateBridgeHints(input.discordChannelId, { + lastDeliveredSequence: sequence, + }) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to persist delivery sequence cursor", { + discordChannelId: input.discordChannelId, + sequence, + cause: formatAlertCause(cause, 300), + }), + ), + Effect.asVoid, + ); + + /** + * After processThreadSnapshot TimeoutError / failure: refresh from HTTP and keep + * the delivery generation open so we retry instead of going silent until a new WS + * event or the 12s reconcile tick. + */ + const recoverAfterDeliveryFailure = (failureCount: number) => + Effect.gen(function* () { + const backoffSec = deliveryFailureBackoffSeconds(failureCount); + yield* Effect.logWarning("Bridge delivery auto-recover: backoff then HTTP reseed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + failureCount, + backoffSec, + }); + yield* Effect.sleep(`${backoffSec} seconds`); + const snapshot = yield* t3.fetchThreadDetail(input.t3ThreadId as ThreadId).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Bridge delivery auto-recover fetch failed", { + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 300), + }).pipe(Effect.as(null)), + ), + ); + if (snapshot === null) return; + yield* Ref.set(latestObservedSequenceRef, snapshot.snapshotSequence); + yield* links + .updateBridgeHints(input.discordChannelId, { + lastThreadSnapshotSequence: snapshot.snapshotSequence, + }) + .pipe(Effect.catchCause(Effect.logWarning), Effect.asVoid); + yield* Ref.set(latestThreadRef, snapshot.thread); + // Bump generation so even if we marked the failed gen processed, a fresh + // attempt is queued. Worker loop also continues when we leave processed behind. + yield* Ref.update(deliveryGenerationRef, (n) => n + 1); + yield* Effect.logInfo("Bridge delivery auto-recover reseeded snapshot", { + t3ThreadId: input.t3ThreadId, + sequence: snapshot.snapshotSequence, + turnState: snapshot.thread.latestTurn?.state ?? null, + messageCount: snapshot.thread.messages.length, + }); + }).pipe(Effect.asVoid); + + const runDeliveryWorker = Effect.gen(function* () { + while (true) { + const pending = yield* Ref.get(deliveryGenerationRef); + const processed = yield* Ref.get(deliveryProcessedRef); + if (pending <= processed) return; + const latest = yield* Ref.get(latestThreadRef); + if (latest === null) { + yield* Ref.set(deliveryProcessedRef, pending); + return; + } + const processResult = yield* processThreadSnapshot(latest).pipe( + // Outer safety net: stream timeouts above usually suffice; secondary work is + // separately capped so title/tasks cannot burn this whole budget. + Effect.timeout(BRIDGE_PROCESS_SNAPSHOT_TIMEOUT), + Effect.result, + ); + if (Result.isFailure(processResult)) { + const pretty = formatAlertCause(processResult.failure); + const failureCount = yield* Ref.updateAndGet(deliveryFailureCountRef, (n) => n + 1); + yield* Effect.logError("Thread bridge processThreadSnapshot failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + failureCount, + cause: pretty, + }); + // Alert on first failure and every 5th thereafter so recover loops are not spam. + if (failureCount === 1 || failureCount % 5 === 0) { + yield* postBridgeAlert( + `onThread:${input.discordChannelId}`, + "Thread bridge processThreadSnapshot failed (auto-recovering)", + [ + `channel=\`${input.discordChannelId}\``, + `thread=\`${input.t3ThreadId}\``, + `mode=\`${mode}\``, + `failureCount=${failureCount}`, + pretty, + ].join("\n"), + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + } + // Do not advance lastDeliveredSequence — delivery lag keeps HTTP reconcile on. + // Close this generation, reseed from HTTP (backoff), bump a new generation, retry. + yield* Ref.set(deliveryProcessedRef, pending); + if ( + shouldRetryDeliveryFailure({ + failureCount, + maxRetries: BRIDGE_DELIVERY_FAILURE_MAX_RETRIES, + }) + ) { + yield* recoverAfterDeliveryFailure(failureCount); + continue; + } + // Exhausted in-worker retries — one last reseed, reset counter, defer further + // attempts to the 12s HTTP reconcile fiber (open tips / delivery lag). + yield* Effect.logError( + "Bridge delivery auto-recover exhausted in-worker retries; deferring to HTTP reconcile", + { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + failureCount, + }, + ); + yield* recoverAfterDeliveryFailure(failureCount); + yield* Ref.set(deliveryFailureCountRef, 0); + continue; + } + + yield* Ref.set(deliveryFailureCountRef, 0); + // Snapshot applied to Discord (stream/finalize/noop). Advance delivery cursor + // to the latest orchestration sequence we have observed for this thread. + const observed = yield* Ref.get(latestObservedSequenceRef); + if (observed !== null && Number.isFinite(observed)) { + yield* persistDeliverySequence(observed); + // Durable warm base (trimmed) for restart resume without full HTTP tip. + yield* persistWarmThreadCache(latest, observed); + } + // Mark the generation we *started* with as done; if newer arrived mid-run, + // the loop continues and re-applies the latest snapshot. + yield* Ref.set(deliveryProcessedRef, pending); + } + }); + + const scheduleThreadDelivery = (thread: OrchestrationThread) => + Effect.gen(function* () { + // Unblock BridgeHub.ensure as soon as any snapshot arrives (do not wait for Discord). + yield* signalReady; + const bridgeState = yield* Ref.get(stateRef); + if (bridgeState.delivery.lastFinalizedAssistantId !== null) { + deliveredMemoryTrim.lastFinalizedAssistantId = + bridgeState.delivery.lastFinalizedAssistantId; + } + yield* Ref.set(latestThreadRef, projectThreadForDiscordMemory(thread)); + yield* Ref.update(deliveryGenerationRef, (n) => n + 1); + yield* deliveryLock.withPermit(runDeliveryWorker).pipe(Effect.forkDetach); + }); + + /** + * Retry pending / desynced Discord titles without waiting for another T3 snapshot. + * Rate-limits and secondary timeouts used to leave ⏳ after settle forever. + * Only wakes full sync when needed — never cold-starts GH every tick. + */ + const flushDiscordThreadTitleIfNeeded = Effect.gen(function* () { + const pendingTitle = yield* Ref.get(pendingDesiredThreadTitleRef); + const stateNow = yield* Ref.get(stateRef); + const threadNow = yield* Ref.get(latestThreadRef); + const mirroredActivity = parseDiscordThreadTitleBadges(stateNow.mirroredThreadTitle).activity; + const desiredActivity = + threadNow === null + ? null + : resolveDiscordThreadActivityBadgeState({ + sessionStatus: threadNow.session?.status ?? null, + activeTurnId: threadNow.session?.activeTurnId ?? null, + latestTurnState: threadNow.latestTurn?.state ?? null, + latestTurnCompletedAt: threadNow.latestTurn?.completedAt ?? null, + }); + const titleNeedsSync = + (pendingTitle !== null && pendingTitle !== stateNow.mirroredThreadTitle) || + desiredActivity !== mirroredActivity; + if (!titleNeedsSync) return; + yield* syncDiscordThreadTitle(); + }); + + const titleRetryFiber = yield* Effect.gen(function* () { + while (true) { + yield* Effect.sleep("15 seconds"); + yield* flushDiscordThreadTitleIfNeeded.pipe( + Effect.catchCause((cause) => + Effect.logWarning("Periodic Discord title retry failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 200), + }), + ), + Effect.asVoid, + ); + } + }).pipe(Effect.forkChild); + + const heartbeatFiber = + input.presentationMode === "final-only" + ? null + : yield* Effect.gen(function* () { + let workingDots: WorkingDotCount = 2; + while (true) { + yield* Effect.sleep("10 seconds"); + workingDots = nextWorkingDotCount(workingDots); + yield* updateWorkingHeartbeat(workingDots).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + const pretty = formatAlertCause(cause); + yield* Effect.logWarning("Failed to update Discord Working heartbeat", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: pretty, + }); + yield* postBridgeAlert( + `heartbeat:${input.discordChannelId}`, + "Working heartbeat failed", + [ + `channel=\`${input.discordChannelId}\``, + `thread=\`${input.t3ThreadId}\``, + pretty, + ].join("\n"), + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + }).pipe(Effect.asVoid), + ), + ); + } + }).pipe(Effect.forkChild); + + /** + * HTTP reconcile: when Working tips stay open or a turn is running, re-fetch the + * thread over HTTP even if the WS stream has gone quiet. This is the recovery path + * for "T3 client has the answer, Discord still says Working..". + */ + const reconcileFiber = yield* Effect.gen(function* () { + while (true) { + yield* Effect.sleep(BRIDGE_HTTP_RECONCILE_INTERVAL); + const state = yield* Ref.get(stateRef); + const latest = yield* Ref.get(latestThreadRef); + const openStreamTipCount = allStreamIds(state).length; + const turnInProgress = latest !== null && isTurnInProgress(latest); + // We started work from Discord (user message and/or Working ack) but never + // recorded a finalize for the current turn — keep reconciling until we do. + const awaitingDiscordFinal = + state.finalizedTurnId === null && + (state.seededWorkingAckPending || + state.sentDiscordUserMessageIds.length > 0 || + openStreamTipCount > 0); + const linkCursors = yield* links + .getByDiscordThreadId(input.discordChannelId) + .pipe(Effect.catchCause(() => Effect.succeed(null))); + const deliveryLagging = isDeliveryBehindOrchestration({ + lastDeliveredSequence: + linkCursors?.lastDeliveredSequence ?? persistedLink?.lastDeliveredSequence ?? null, + lastThreadSnapshotSequence: + (yield* Ref.get(latestObservedSequenceRef)) ?? + linkCursors?.lastThreadSnapshotSequence ?? + persistedLink?.lastThreadSnapshotSequence ?? + null, + }); + if ( + !bridgeNeedsHttpReconcile({ + openStreamTipCount, + seededWorkingAckPending: state.seededWorkingAckPending, + turnInProgress, + awaitingDiscordFinal, + deliveryLagging, + }) + ) { + continue; + } + + const snapshot = yield* t3.fetchThreadDetail(input.t3ThreadId as ThreadId).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Bridge HTTP reconcile fetch failed", { + t3ThreadId: input.t3ThreadId, + cause: formatAlertCause(cause, 300), + }).pipe(Effect.as(null)), + ), + ); + if (snapshot === null) continue; + + yield* Effect.logInfo("Bridge HTTP reconcile applying snapshot", { + t3ThreadId: input.t3ThreadId, + sequence: snapshot.snapshotSequence, + openStreamTipCount, + turnState: snapshot.thread.latestTurn?.state ?? null, + sessionStatus: snapshot.thread.session?.status ?? null, + messageCount: snapshot.thread.messages.length, + awaitingDiscordFinal, + deliveryLagging, + }); + // Orchestration cursor only — delivery cursor advances after process succeeds. + yield* Ref.set(latestObservedSequenceRef, snapshot.snapshotSequence); + yield* links + .updateBridgeHints(input.discordChannelId, { + lastThreadSnapshotSequence: snapshot.snapshotSequence, + }) + .pipe(Effect.catchCause(Effect.logWarning), Effect.asVoid); + yield* scheduleThreadDelivery(snapshot.thread); + } + }).pipe(Effect.forkChild); + + // botUserId is used for finalize accept-without-ack adoption scans. + + const storedSequence = persistedLink?.lastThreadSnapshotSequence ?? null; + const storedDeliveredSequence = persistedLink?.lastDeliveredSequence ?? null; + const initialAfterSequence = resolveSubscribeAfterSequence({ + lastDeliveredSequence: storedDeliveredSequence, + lastThreadSnapshotSequence: storedSequence, + }); + const subscribeSeed = resolveThreadSubscribeSeed({ + warm: + warmCacheEntry !== null + ? { + snapshotSequence: warmCacheEntry.snapshotSequence, + thread: warmCacheEntry.thread, + } + : null, + afterSequence: initialAfterSequence, + }); + yield* Effect.logInfo("Bridge subscribing to T3 thread stream", { + t3ThreadId: input.t3ThreadId, + storedSequence, + storedDeliveredSequence, + afterSequence: initialAfterSequence, + seedKind: subscribeSeed.kind, + warmSequence: warmCacheEntry?.snapshotSequence ?? null, + warmMessageCount: warmCacheEntry?.thread.messages.length ?? null, + deliveryLagging: isDeliveryBehindOrchestration({ + lastDeliveredSequence: storedDeliveredSequence, + lastThreadSnapshotSequence: storedSequence, + }), + }); + // WS callback only enqueues; Discord I/O runs on the delivery worker. + const onThreadGuarded = (thread: OrchestrationThread) => + scheduleThreadDelivery(thread).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + const pretty = formatAlertCause(cause); + yield* Effect.logError("Thread bridge scheduleThreadDelivery failed", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: pretty, + }); + yield* postBridgeAlert( + `onThread:${input.discordChannelId}`, + "Thread bridge scheduleThreadDelivery failed", + [ + `channel=\`${input.discordChannelId}\``, + `thread=\`${input.t3ThreadId}\``, + `mode=\`${mode}\``, + pretty, + ].join("\n"), + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + }).pipe(Effect.asVoid), + ), + ); + + // Orchestration cursor: advances as soon as T3 state is observed (performant WS + // resume). Delivery cursor is separate and only moves after Discord I/O succeeds. + // Both are O(1) scalars — never an event/history log. + const persistSequenceMarker = (sequence: number) => + Effect.gen(function* () { + yield* Ref.set(latestObservedSequenceRef, sequence); + yield* links.updateBridgeHints(input.discordChannelId, { + lastThreadSnapshotSequence: sequence, + }); + }).pipe(Effect.asVoid); + + // Client-aligned follow (DiscordThreadFollower) + durable warm tip: + // prefer warm base + afterSequence (web/desktop EnvironmentCacheStore pattern); + // HTTP full tip only when warm is missing. Dual-cursor afterSequence prefers + // delivery high-water. Follower owns reload-required + durable resubscribe. + // ResponseBridge only projects OrchestrationThread → Discord (coalesce queue). + const warmForSubscribe = yield* warmCache + .load(input.t3ThreadId) + .pipe(Effect.catchCause(() => Effect.succeed(null))); + const seed = resolveThreadSubscribeSeed({ + warm: + warmForSubscribe !== null + ? { + snapshotSequence: warmForSubscribe.snapshotSequence, + thread: warmForSubscribe.thread, + } + : null, + afterSequence: initialAfterSequence, + }); + yield* t3 + .subscribeThread(input.t3ThreadId as ThreadId, onThreadGuarded, { + ...(seed.kind === "warm" + ? { + afterSequence: seed.afterSequence, + warmSeed: { + snapshotSequence: seed.afterSequence, + thread: seed.thread, + }, + } + : seed.kind === "http" + ? { afterSequence: seed.afterSequence } + : initialAfterSequence !== null && initialAfterSequence >= 0 + ? { afterSequence: initialAfterSequence } + : {}), + onSequence: persistSequenceMarker, + projectThread: projectThreadForDiscordMemory, + }) + .pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + // Follower retries internally; this is only if the outer effect is interrupted + // or fails without recovery. Bot restart / fiber cancel is interrupt-only — + // expected, high volume; do not page #omegent-alerts. + if (Cause.hasInterruptsOnly(cause)) { + yield* Effect.logInfo("Bridge subscribeThread interrupted (no alert)", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + }); + return; + } + const pretty = formatAlertCause(cause); + yield* Effect.logError("Bridge subscribeThread exited", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + cause: pretty, + }); + yield* postFatalAlert( + `subscribe:${input.t3ThreadId}`, + "T3 thread subscription exited", + `channel=\`${input.discordChannelId}\` thread=\`${input.t3ThreadId}\`\n${pretty}`, + { threadId: input.t3ThreadId, channelId: input.discordChannelId }, + ); + }).pipe(Effect.asVoid), + ), + Effect.ensuring( + Effect.gen(function* () { + if (heartbeatFiber !== null) { + yield* Fiber.interrupt(heartbeatFiber).pipe(Effect.ignore); + } + yield* Fiber.interrupt(titleRetryFiber).pipe(Effect.ignore); + yield* Fiber.interrupt(reconcileFiber).pipe(Effect.ignore); + yield* stopVcsStatusSubscription; + // Do NOT delete open stream tips on stop when the turn is still running. + // Restart/reconnect must leave Working.. visible so rehydrate can resume it. + // Interactive re-ensure already orphan-cleans via seedStreamMessageIds when a + // fresh Working ack is posted for a new user turn. + const state = yield* Ref.get(stateRef); + const latest = yield* Ref.get(latestThreadRef); + const openTips = allStreamIds(state); + const turnRunning = latest !== null && isTurnInProgress(latest); + if ( + shouldPreserveStreamTipsOnBridgeStop({ + turnInProgress: turnRunning, + openStreamTipCount: openTips.length, + }) + ) { + yield* Effect.logInfo( + "Discord↔T3 bridge stopped; preserving in-progress stream tips for rehydrate", + { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + tipIds: openTips, + turnState: latest?.latestTurn?.state ?? null, + }, + ); + } else if (openTips.length > 0) { + // Idle bridge replacement: drop leftover tips so they do not linger. + yield* streamWriteLock.withPermit(deleteMessages(openTips)); + yield* persistStreamMessageIds([]); + yield* Effect.logInfo("Discord↔T3 bridge stopped; cleared idle stream tips", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + tipIds: openTips, + }); + } else { + yield* Effect.logInfo("Discord↔T3 bridge stopped", { + discordChannelId: input.discordChannelId, + t3ThreadId: input.t3ThreadId, + }); + } + }), + ), + ); + }); diff --git a/apps/discord-bot/src/features/TeamsModule.ts b/apps/discord-bot/src/features/TeamsModule.ts new file mode 100644 index 000000000000..5a0218a6c39b --- /dev/null +++ b/apps/discord-bot/src/features/TeamsModule.ts @@ -0,0 +1,634 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectContext:off globalFetch:off globalTimers:off missingEffectError:off globalDateInEffect:off globalDate:off globalErrorInEffectCatch:off globalErrorInEffectFailure:off globalFetchInEffect:off preferSchemaOverJson:off +import { DiscordConfig, DiscordREST } from "dfx"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Redacted from "effect/Redacted"; + +import type { DiscordBotConfig } from "../config.ts"; +import { createMessageWithAttachments, DiscordUploadError } from "../presentation/discordFiles.ts"; +import { TeamsSeenStore } from "../store/TeamsSeenStore.ts"; +import { ThreadLinkStore } from "../store/ThreadLinkStore.ts"; +import { truncateTitle } from "../presentation/messages.ts"; +import { startOrContinueLinkedTurn, startOrContinueT3Turn } from "./LinkedTurnRouter.ts"; +import type { DiscordUploadFile } from "../presentation/discordFiles.ts"; +import { downloadTeamsMessageImages } from "../teams/attachments.ts"; +import { loadTeamsChannelConfigsFromFileSync, type TeamsChannelConfig } from "../teams/config.ts"; +import { + buildTeamsIncidentTitle, + buildTeamsPrompt, + buildTeamsSeedMessage, + hasAllowlistedReaction, + hasInternalTagTrigger, + isHumanTeamsMessage, + looksLikeGermanProblemReport, + mentionsTeamsBot, + rootTeamsMessageId, + teamsMessageTimestamp, + type TeamsMessage, +} from "../teams/presentation.ts"; + +interface GraphListResponse { + readonly value?: ReadonlyArray | undefined; + readonly "@odata.nextLink"?: string | undefined; +} + +interface GraphHostedContentResponse { + readonly value?: + | ReadonlyArray<{ + readonly id?: string | undefined; + readonly contentType?: string | undefined; + }> + | undefined; +} + +function channelKey(channel: TeamsChannelConfig): string { + return `${channel.teamId}/${channel.channelId}`; +} + +function sourceThreadKey(channel: TeamsChannelConfig, rootMessageId: string): string { + return `${channel.teamId}/${channel.channelId}/${rootMessageId}`; +} + +function oauthRequestBody(config: DiscordBotConfig): URLSearchParams { + const body = new URLSearchParams(); + body.set("grant_type", "client_credentials"); + body.set("client_id", config.teamsClientId ?? ""); + body.set("client_secret", config.teamsClientSecret ?? ""); + body.set("scope", "https://graph.microsoft.com/.default"); + return body; +} + +async function fetchJson(input: RequestInfo | URL, init?: RequestInit): Promise { + const response = await globalThis.fetch(input, init); + if (!response.ok) { + throw new Error(`${response.status} ${response.statusText}`); + } + return (await response.json()) as unknown; +} + +function nowLookbackStart(): Date { + const now = new Date(); + const dayOfWeek = now.getUTCDay(); + if (dayOfWeek === 6 || dayOfWeek === 0 || dayOfWeek === 1) { + const daysSinceFriday = dayOfWeek === 6 ? 1 : dayOfWeek === 0 ? 2 : 3; + const friday = new Date(now); + friday.setUTCDate(now.getUTCDate() - daysSinceFriday); + friday.setUTCHours(0, 0, 0, 0); + return friday; + } + + return new Date(now.getTime() - 24 * 60 * 60 * 1000); +} + +export const runTeamsModule = Effect.fn("runTeamsModule")(function* (config: DiscordBotConfig) { + if (!config.teamsEnabled) { + yield* Effect.logInfo("Teams module disabled"); + return; + } + if ( + !config.teamsTenantId || + !config.teamsClientId || + !config.teamsClientSecret || + !config.teamsChannelsPath + ) { + yield* Effect.logWarning("Teams module enabled but auth/config is incomplete; skipping"); + return; + } + + const channels = loadTeamsChannelConfigsFromFileSync(config.teamsChannelsPath); + if (channels.length === 0) { + yield* Effect.logWarning("Teams module enabled but channel config is empty; skipping"); + return; + } + + const rest = yield* DiscordREST; + const discordConfig = yield* DiscordConfig.DiscordConfig; + const seenStore = yield* TeamsSeenStore; + const links = yield* ThreadLinkStore; + + let cachedAccessToken: { readonly token: string; readonly expiresAt: number } | null = null; + + const getAccessToken = Effect.fn("runTeamsModule.getAccessToken")(function* () { + const now = Date.now(); + if (cachedAccessToken !== null && cachedAccessToken.expiresAt > now + 60_000) { + return cachedAccessToken.token; + } + + const tokenResponse = (yield* Effect.tryPromise({ + try: () => + fetchJson(`https://login.microsoftonline.com/${config.teamsTenantId}/oauth2/v2.0/token`, { + method: "POST", + headers: { + "content-type": "application/x-www-form-urlencoded", + }, + body: oauthRequestBody(config), + }), + catch: (cause) => new Error(String(cause)), + })) as { + readonly access_token?: string; + readonly expires_in?: number; + }; + + const token = tokenResponse.access_token ?? ""; + const expiresIn = tokenResponse.expires_in ?? 3600; + if (token.length === 0) { + return yield* Effect.fail( + new Error("Microsoft Graph token response did not include access_token."), + ); + } + cachedAccessToken = { + token, + expiresAt: now + expiresIn * 1000, + }; + return token; + }); + + const graphGet = Effect.fn("runTeamsModule.graphGet")(function* (pathOrUrl: string) { + const accessToken = yield* getAccessToken(); + return (yield* Effect.tryPromise({ + try: () => + fetchJson( + pathOrUrl.startsWith("https://") + ? pathOrUrl + : `https://graph.microsoft.com/v1.0${pathOrUrl}`, + { + headers: { + authorization: `Bearer ${accessToken}`, + }, + }, + ), + catch: (cause) => new Error(String(cause)), + })) as GraphListResponse; + }); + + const graphGetUnknown = Effect.fn("runTeamsModule.graphGetUnknown")(function* (path: string) { + const accessToken = yield* getAccessToken(); + return yield* Effect.tryPromise({ + try: () => + fetchJson(`https://graph.microsoft.com/v1.0${path}`, { + headers: { + authorization: `Bearer ${accessToken}`, + }, + }), + catch: (cause) => new Error(String(cause)), + }); + }); + + const messageIsWithinLookback = (message: TeamsMessage, lookbackStartMs: number): boolean => { + const createdAt = Date.parse(message.createdDateTime ?? ""); + return !Number.isFinite(createdAt) || createdAt >= lookbackStartMs; + }; + + const listPagedMessages = Effect.fn("runTeamsModule.listPagedMessages")(function* ( + initialPath: string, + lookbackStartMs: number, + ) { + const collected: TeamsMessage[] = []; + let cursor: string | null = initialPath; + + while (cursor !== null) { + const page: GraphListResponse = yield* graphGet(cursor); + const pageMessages: TeamsMessage[] = [...(page.value ?? [])]; + collected.push(...pageMessages); + + const shouldContinue: boolean = pageMessages.some((message: TeamsMessage) => + messageIsWithinLookback(message, lookbackStartMs), + ); + cursor = shouldContinue ? (page["@odata.nextLink"] ?? null) : null; + } + + return collected.filter((message) => messageIsWithinLookback(message, lookbackStartMs)); + }); + + const postTeamsWebhookAck = Effect.fn("runTeamsModule.postTeamsWebhookAck")(function* ( + channel: TeamsChannelConfig, + message: TeamsMessage, + ) { + if (!channel.respondToMentions || !channel.teamsIncomingWebhookUrl) return; + yield* Effect.tryPromise({ + try: () => + globalThis.fetch(channel.teamsIncomingWebhookUrl!, { + method: "POST", + headers: { + "content-type": "application/json", + }, + body: JSON.stringify({ + text: `Triage started for ${channel.company}/${channel.environment}: ${truncateTitle( + buildTeamsIncidentTitle({ + company: channel.company, + environment: channel.environment, + message, + }), + 140, + )}`, + }), + }), + catch: (cause) => new Error(String(cause)), + }).pipe(Effect.ignore); + }); + + const openDiscordThread = Effect.fn("runTeamsModule.openDiscordThread")(function* ( + channel: TeamsChannelConfig, + message: TeamsMessage, + reason: "mention" | "german-problem" | "allowlisted-reaction" | "internal-tag", + imageFiles: ReadonlyArray, + ) { + const discordChannelId = channel.discordChannelId; + if (discordChannelId === undefined) { + return yield* Effect.fail( + new Error( + `Teams channel ${channel.teamId}/${channel.channelId} uses Discord delivery without discordChannelId.`, + ), + ); + } + const seedContent = buildTeamsSeedMessage({ + company: channel.company, + environment: channel.environment, + channelName: channel.channelName, + message, + reason, + }); + const seed = + imageFiles.length === 0 + ? yield* rest.createMessage(discordChannelId, { + content: seedContent, + }) + : yield* Effect.tryPromise({ + try: () => + createMessageWithAttachments({ + baseUrl: discordConfig.rest.baseUrl, + botToken: Redacted.value(discordConfig.token), + channelId: discordChannelId, + content: seedContent, + files: imageFiles, + }), + catch: (cause) => + cause instanceof DiscordUploadError + ? cause + : new DiscordUploadError(cause instanceof Error ? cause.message : String(cause)), + }); + const discordThread = yield* rest.createThreadFromMessage(discordChannelId, seed.id, { + name: truncateTitle( + buildTeamsIncidentTitle({ + company: channel.company, + environment: channel.environment, + message, + }), + ), + auto_archive_duration: 1440, + }); + return discordThread.id; + }); + + const hostedContentsPath = (channel: TeamsChannelConfig, message: TeamsMessage): string => + message.replyToId + ? `/teams/${encodeURIComponent(channel.teamId)}/channels/${encodeURIComponent(channel.channelId)}/messages/${encodeURIComponent(message.replyToId)}/replies/${encodeURIComponent(message.id)}/hostedContents` + : `/teams/${encodeURIComponent(channel.teamId)}/channels/${encodeURIComponent(channel.channelId)}/messages/${encodeURIComponent(message.id)}/hostedContents`; + + const buildHostedContentValueUrl = ( + channel: TeamsChannelConfig, + message: TeamsMessage, + hostedContentId: string, + ): string => + `https://graph.microsoft.com/v1.0${ + message.replyToId + ? `/teams/${encodeURIComponent(channel.teamId)}/channels/${encodeURIComponent(channel.channelId)}/messages/${encodeURIComponent(message.replyToId)}/replies/${encodeURIComponent(message.id)}/hostedContents/${encodeURIComponent(hostedContentId)}/$value` + : `/teams/${encodeURIComponent(channel.teamId)}/channels/${encodeURIComponent(channel.channelId)}/messages/${encodeURIComponent(message.id)}/hostedContents/${encodeURIComponent(hostedContentId)}/$value` + }`; + + const listHostedContentsForMessage = Effect.fn("runTeamsModule.listHostedContentsForMessage")( + function* (channel: TeamsChannelConfig, message: TeamsMessage) { + const response = (yield* graphGetUnknown(hostedContentsPath(channel, message)).pipe( + Effect.orElseSucceed(() => ({ value: [] }) satisfies GraphHostedContentResponse), + )) as GraphHostedContentResponse; + return (response.value ?? []) + .filter( + (entry): entry is { readonly id: string; readonly contentType?: string | undefined } => + typeof entry.id === "string" && entry.id.length > 0, + ) + .map((entry) => ({ + id: entry.id, + contentType: entry.contentType, + valueUrl: buildHostedContentValueUrl(channel, message, entry.id), + })); + }, + ); + + const recentHistoryForMessage = ( + channel: TeamsChannelConfig, + messages: ReadonlyArray, + targetMessage: TeamsMessage, + processedRootKeys: ReadonlySet, + ): ReadonlyArray => { + const targetIndex = messages.findIndex((message) => message.id === targetMessage.id); + if (targetIndex <= 0) return []; + + const targetTime = Date.parse(targetMessage.createdDateTime ?? ""); + const history: TeamsMessage[] = []; + for (let index = targetIndex - 1; index >= 0; index -= 1) { + const candidate = messages[index]!; + if (!isHumanTeamsMessage(candidate)) continue; + if (processedRootKeys.has(sourceThreadKey(channel, rootTeamsMessageId(candidate)))) break; + const candidateTime = Date.parse(candidate.createdDateTime ?? ""); + if ( + Number.isFinite(targetTime) && + Number.isFinite(candidateTime) && + targetTime - candidateTime > 2 * 60 * 60 * 1000 + ) { + break; + } + history.push(candidate); + } + + return history.toReversed(); + }; + + const processedRootKeysForChannel = Effect.fn("runTeamsModule.processedRootKeysForChannel")( + function* (channel: TeamsChannelConfig) { + const prefix = `${channel.teamId}/${channel.channelId}/`; + const allLinks = yield* links.list(); + return new Set( + allLinks + .filter((link) => (link.sourceKind ?? "discord") === "teams") + .map((link) => link.sourceThreadId) + .filter( + (value): value is string => typeof value === "string" && value.startsWith(prefix), + ), + ); + }, + ); + + const findMessageById = ( + messages: ReadonlyArray, + messageId: string | null | undefined, + ): TeamsMessage | null => + typeof messageId === "string" + ? (messages.find((message) => message.id === messageId) ?? null) + : null; + + const resolveTagTargetMessage = ( + message: TeamsMessage, + messages: ReadonlyArray, + ): TeamsMessage => findMessageById(messages, message.replyToId) ?? message; + + type TriggerReason = "mention" | "german-problem" | "allowlisted-reaction" | "internal-tag"; + + const classifyTrigger = (input: { + readonly channel: TeamsChannelConfig; + readonly message: TeamsMessage; + readonly messages: ReadonlyArray; + readonly alreadySeen: boolean; + }): { + readonly reason: TriggerReason; + readonly targetMessage: TeamsMessage; + readonly triggerMessage?: TeamsMessage | undefined; + } | null => { + const mentionTrigger = + !input.alreadySeen && mentionsTeamsBot(input.message, config.teamsBotDisplayName); + if (mentionTrigger) { + return { + reason: "mention", + targetMessage: input.message, + }; + } + + const reactionTrigger = hasAllowlistedReaction({ + message: input.message, + allowlistedUserIds: input.channel.internalUserIds, + reactionTriggerTypes: input.channel.reactionTriggerTypes, + }); + if (reactionTrigger) { + return { + reason: "allowlisted-reaction", + targetMessage: input.message, + }; + } + + const tagTrigger = + !input.alreadySeen && + hasInternalTagTrigger({ + message: input.message, + allowlistedUserIds: input.channel.internalUserIds, + messageTagTriggers: input.channel.messageTagTriggers, + }); + if (tagTrigger) { + return { + reason: "internal-tag", + targetMessage: resolveTagTargetMessage(input.message, input.messages), + triggerMessage: input.message, + }; + } + + const automaticAssessmentEnabled = input.channel.automaticAssessmentEnabled ?? true; + const germanProblemTrigger = + automaticAssessmentEnabled && + !input.alreadySeen && + looksLikeGermanProblemReport({ + message: input.message, + companyKeywords: input.channel.companyKeywords, + environmentKeywords: input.channel.environmentKeywords, + problemKeywords: input.channel.problemKeywords, + }); + if (germanProblemTrigger) { + return { + reason: "german-problem", + targetMessage: input.message, + }; + } + + return null; + }; + + const processMessage = Effect.fn("runTeamsModule.processMessage")(function* ( + channel: TeamsChannelConfig, + message: TeamsMessage, + messages: ReadonlyArray, + seenIds: Set, + processedRootKeys: Set, + ) { + if (!isHumanTeamsMessage(message)) return; + + const alreadySeen = seenIds.has(message.id); + const trigger = classifyTrigger({ + channel, + message, + messages, + alreadySeen, + }); + + if (!alreadySeen) { + yield* seenStore.markSeen(channelKey(channel), message.id); + seenIds.add(message.id); + } + + if (trigger === null) return; + + const rootMessageId = rootTeamsMessageId(trigger.targetMessage); + const rootKey = sourceThreadKey(channel, rootMessageId); + if (processedRootKeys.has(rootKey)) return; + + const accessToken = yield* getAccessToken(); + const hostedContents = yield* listHostedContentsForMessage(channel, trigger.targetMessage); + const imageDownloads = yield* Effect.tryPromise({ + try: () => + downloadTeamsMessageImages({ + message: trigger.targetMessage, + accessToken, + hostedContentEntries: hostedContents, + }), + catch: (cause) => new Error(String(cause)), + }).pipe( + Effect.catch((error) => + Effect.logError("Failed to download Teams image attachments", { + error: String(error), + }).pipe( + Effect.as({ + discordFiles: [] as ReadonlyArray, + t3Uploads: [], + skipped: [], + }), + ), + ), + ); + if (imageDownloads.skipped.length > 0) { + yield* Effect.logWarning("Skipped some Teams image attachments", { + skipped: imageDownloads.skipped, + }); + } + + const history = recentHistoryForMessage( + channel, + messages, + trigger.targetMessage, + processedRootKeys, + ); + + const prompt = buildTeamsPrompt({ + channelName: channel.channelName, + company: channel.company, + environment: channel.environment, + projectShortName: channel.projectShortName, + reason: trigger.reason, + message: trigger.targetMessage, + triggerMessage: trigger.triggerMessage, + history, + }); + if (channel.deliveryMode === "discord") { + const discordChannelId = channel.discordChannelId; + if (discordChannelId === undefined) { + return yield* Effect.fail( + new Error( + `Teams channel ${channel.teamId}/${channel.channelId} uses Discord delivery without discordChannelId.`, + ), + ); + } + const existing = yield* links.getBySourceThread("teams", rootKey); + const discordThreadId = + existing?.discordThreadId ?? + (yield* openDiscordThread( + channel, + trigger.targetMessage, + trigger.reason, + imageDownloads.discordFiles, + )); + yield* startOrContinueLinkedTurn(config, { + source: { + sourceKind: "teams", + sourceThreadId: rootKey, + }, + discordThreadId, + discordParentChannelId: discordChannelId, + discordGuildId: "", + projectShortName: channel.projectShortName, + prompt, + flags: {}, + ...(imageDownloads.t3Uploads.length > 0 ? { attachments: imageDownloads.t3Uploads } : {}), + announceLines: [ + `Linked **${channel.projectShortName}**`, + `Source: Teams / ${channel.channelName}`, + `Company: **${channel.company}**`, + `Environment: **${channel.environment}**`, + ], + promptContext: { + kind: "raw", + value: prompt, + }, + }); + } else { + yield* startOrContinueT3Turn(config, { + source: { + sourceKind: "teams", + sourceThreadId: rootKey, + }, + externalConversationId: rootKey, + externalParentId: `${channel.teamId}/${channel.channelId}`, + externalTenantId: config.teamsTenantId ?? "", + projectShortName: channel.projectShortName, + prompt, + flags: {}, + ...(imageDownloads.t3Uploads.length > 0 ? { attachments: imageDownloads.t3Uploads } : {}), + promptContext: { + kind: "raw", + value: prompt, + }, + }); + } + processedRootKeys.add(rootKey); + + if (trigger.reason === "mention" || channel.deliveryMode !== "discord") { + yield* postTeamsWebhookAck(channel, trigger.targetMessage); + } + }); + + const listMessagesForChannel = Effect.fn("runTeamsModule.listMessagesForChannel")(function* ( + channel: TeamsChannelConfig, + ) { + const lookbackStartMs = nowLookbackStart().getTime(); + const roots = yield* listPagedMessages( + `/teams/${encodeURIComponent(channel.teamId)}/channels/${encodeURIComponent(channel.channelId)}/messages?$top=50`, + lookbackStartMs, + ); + + const collected: TeamsMessage[] = []; + for (const root of roots) { + collected.push(root); + const replies = yield* listPagedMessages( + `/teams/${encodeURIComponent(channel.teamId)}/channels/${encodeURIComponent(channel.channelId)}/messages/${encodeURIComponent(root.id)}/replies?$top=50`, + lookbackStartMs, + ).pipe(Effect.orElseSucceed(() => [] as TeamsMessage[])); + collected.push(...replies); + } + + return collected.toSorted((left, right) => + teamsMessageTimestamp(left).localeCompare(teamsMessageTimestamp(right)), + ); + }); + + yield* Effect.logInfo("Teams module enabled", { + channels: channels.length, + pollIntervalSeconds: config.teamsPollIntervalSeconds, + }); + + while (true) { + for (const channel of channels) { + yield* Effect.gen(function* () { + const messages = yield* listMessagesForChannel(channel); + const seenIds = new Set(yield* seenStore.listSeenIds(channelKey(channel))); + const processedRootKeys = yield* processedRootKeysForChannel(channel); + for (const message of messages) { + yield* processMessage(channel, message, messages, seenIds, processedRootKeys); + } + }).pipe( + Effect.catch((error) => + Effect.logError("Teams channel poll failed", { + teamId: channel.teamId, + channelId: channel.channelId, + error: String(error), + }), + ), + ); + } + + yield* Effect.sleep(Duration.seconds(config.teamsPollIntervalSeconds)); + } +}); diff --git a/apps/discord-bot/src/features/TeamsNativeApp.test.ts b/apps/discord-bot/src/features/TeamsNativeApp.test.ts new file mode 100644 index 000000000000..8e9bea12f144 --- /dev/null +++ b/apps/discord-bot/src/features/TeamsNativeApp.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { sourceConversationKey, splitTeamsMessage } from "./TeamsNativeApp.ts"; + +describe("sourceConversationKey", () => { + it("keeps native Teams conversations distinct by tenant and location", () => { + expect( + sourceConversationKey({ + tenantId: "tenant", + teamId: "team", + channelId: "channel", + conversationId: "conversation;messageid=root", + }), + ).toBe("native/tenant/team/channel/conversation;messageid=root"); + }); + + it("supports personal chats", () => { + expect( + sourceConversationKey({ + tenantId: "tenant", + teamId: undefined, + channelId: undefined, + conversationId: "personal-chat", + }), + ).toBe("native/tenant/chat/chat/personal-chat"); + }); +}); + +describe("splitTeamsMessage", () => { + it("keeps short answers intact", () => { + expect(splitTeamsMessage("done")).toEqual(["done"]); + }); + + it("splits large answers below the Teams delivery ceiling without losing text", () => { + const input = `${"a".repeat(15_000)}\n\n${"b".repeat(15_000)}`; + const chunks = splitTeamsMessage(input); + expect(chunks).toHaveLength(2); + expect(chunks.every((chunk) => chunk.length <= 25_000)).toBe(true); + expect(chunks.join("\n\n")).toBe(input); + }); +}); diff --git a/apps/discord-bot/src/features/TeamsNativeApp.ts b/apps/discord-bot/src/features/TeamsNativeApp.ts new file mode 100644 index 000000000000..e2bb1fc23bd5 --- /dev/null +++ b/apps/discord-bot/src/features/TeamsNativeApp.ts @@ -0,0 +1,440 @@ +// @effect-diagnostics anyUnknownInErrorContext:off globalErrorInEffectCatch:off globalErrorInEffectFailure:off globalPromise:off missingEffectContext:off tryCatchInEffectGen:off preferSchemaOverJson:off +import { App } from "@microsoft/teams.apps"; +import { ProviderUserInputAnswers, type ThreadId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; + +import type { DiscordBotConfig } from "../config.ts"; +import { derivePendingInteractions } from "../presentation/pendingInteractions.ts"; +import { ProjectAliasStore } from "../projectAliases.ts"; +import { ThreadLinkStore } from "../store/ThreadLinkStore.ts"; +import { T3Session } from "../t3/T3Session.ts"; +import { loadTeamsChannelConfigsFromFileSync, type TeamsChannelConfig } from "../teams/config.ts"; +import { teamsMessageText } from "../teams/presentation.ts"; +import { startOrContinueT3Turn } from "./LinkedTurnRouter.ts"; +import { finalAnswerText } from "./ResponseBridge.ts"; + +interface TeamsConversationCoordinates { + readonly tenantId: string; + readonly teamId: string | undefined; + readonly channelId: string | undefined; + readonly conversationId: string; +} + +function coordinates(activity: { + readonly conversation: { readonly id: string; readonly tenantId?: string | undefined }; + readonly channelData?: { + readonly tenant?: { readonly id?: string | undefined } | undefined; + readonly team?: { readonly id?: string | undefined } | undefined; + readonly channel?: { readonly id?: string | undefined } | undefined; + }; +}): TeamsConversationCoordinates { + return { + tenantId: activity.channelData?.tenant?.id ?? activity.conversation.tenantId ?? "", + teamId: activity.channelData?.team?.id, + channelId: activity.channelData?.channel?.id, + conversationId: activity.conversation.id, + }; +} + +function channelForCoordinates( + channels: ReadonlyArray, + input: TeamsConversationCoordinates, +): TeamsChannelConfig | undefined { + return channels.find( + (channel) => channel.teamId === input.teamId && channel.channelId === input.channelId, + ); +} + +export function sourceConversationKey(input: TeamsConversationCoordinates): string { + return `native/${input.tenantId}/${input.teamId ?? "chat"}/${input.channelId ?? "chat"}/${input.conversationId}`; +} + +function settled(status: string | null | undefined): boolean { + return status !== "starting" && status !== "running"; +} + +export function splitTeamsMessage(text: string): ReadonlyArray { + const normalized = text.trim(); + if (normalized.length <= 25_000) return [normalized]; + const chunks: string[] = []; + let remaining = normalized; + while (remaining.length > 25_000) { + const candidate = remaining.slice(0, 25_000); + const splitAt = Math.max(candidate.lastIndexOf("\n\n"), candidate.lastIndexOf("\n")); + const end = splitAt >= 10_000 ? splitAt : 25_000; + chunks.push(remaining.slice(0, end).trimEnd()); + remaining = remaining.slice(end).trimStart(); + } + if (remaining.length > 0) chunks.push(remaining); + return chunks; +} + +const waitForFinalAnswer = Effect.fn("waitForFinalAnswer")(function* (input: { + readonly t3ThreadId: ThreadId; + readonly baseline: string; + readonly baselineTurnId: string | null; + readonly send: (text: string) => Promise; +}) { + const t3 = yield* T3Session; + const announcedRequests = new Set(); + while (true) { + yield* Effect.sleep("1 second"); + const snapshot = yield* t3.fetchThreadDetail(input.t3ThreadId).pipe( + Effect.catch((error) => + Effect.logWarning("Teams final-answer poll failed", { + threadId: input.t3ThreadId, + error: String(error), + }).pipe(Effect.as(null)), + ), + ); + if (snapshot === null) continue; + for (const interaction of derivePendingInteractions(snapshot.thread.activities)) { + if (announcedRequests.has(interaction.requestId)) continue; + announcedRequests.add(interaction.requestId); + if (interaction.kind === "approval") { + yield* Effect.tryPromise({ + try: () => + input.send( + [ + `T3 needs **${interaction.requestKind}** approval.`, + interaction.detail, + `Reply \`approve ${interaction.requestId}\` or \`deny ${interaction.requestId}\`.`, + ] + .filter((line): line is string => line !== null) + .join("\n\n"), + ), + catch: (cause) => new Error(String(cause)), + }); + } else { + const questions = interaction.questions + .map( + (question) => + `- \`${question.id}\`: ${question.question}${ + question.options.length === 0 + ? "" + : ` (${question.options.map((option) => option.label).join(", ")})` + }`, + ) + .join("\n"); + yield* Effect.tryPromise({ + try: () => + input.send( + [ + "T3 needs more information:", + questions, + `Reply \`answer ${interaction.requestId} {"question-id":"answer"}\`.`, + ].join("\n\n"), + ), + catch: (cause) => new Error(String(cause)), + }); + } + } + const answer = finalAnswerText(snapshot.thread); + const latestTurnId = snapshot.thread.latestTurn?.turnId ?? null; + if ( + answer.length === 0 || + (answer === input.baseline && latestTurnId === input.baselineTurnId) || + !settled(snapshot.thread.session?.status) + ) { + continue; + } + for (const chunk of splitTeamsMessage(answer)) { + yield* Effect.tryPromise({ + try: () => input.send(chunk), + catch: (cause) => new Error(String(cause)), + }); + } + return; + } +}); + +function messageActionCard(defaultProject: string | undefined) { + return { + contentType: "application/vnd.microsoft.card.adaptive", + content: { + type: "AdaptiveCard", + version: "1.5", + body: [ + { + type: "TextBlock", + text: "Start a T3 investigation from this Teams message", + weight: "Bolder", + wrap: true, + }, + { + type: "Input.Text", + id: "projectShortName", + label: "Project alias", + value: defaultProject ?? "", + isRequired: true, + errorMessage: "Enter a project alias configured in T3_PROJECT_ALIASES_PATH.", + }, + { + type: "Input.Text", + id: "instructions", + label: "Additional instructions", + isMultiline: true, + placeholder: "Optional context or desired outcome", + }, + { + type: "ActionSet", + actions: [ + { + type: "Action.Submit", + title: "Start investigation", + data: { action: "startT3Investigation" }, + }, + ], + }, + ], + $schema: "https://adaptivecards.io/schemas/adaptive-card.json", + }, + } as const; +} + +/** + * Native Teams SDK endpoint. This is independent from Discord gateway/services and can be + * deployed with only Teams + T3 credentials. + */ +export const runTeamsNativeApp = Effect.fn("runTeamsNativeApp")(function* ( + config: DiscordBotConfig, +) { + if (!config.teamsNativeEnabled) { + yield* Effect.logInfo("Native Teams app disabled"); + return; + } + if ( + config.teamsClientId === undefined || + config.teamsClientSecret === undefined || + config.teamsTenantId === undefined + ) { + return yield* Effect.fail( + new Error( + "TEAMS_NATIVE_ENABLED requires TEAMS_CLIENT_ID, TEAMS_CLIENT_SECRET, and TEAMS_TENANT_ID.", + ), + ); + } + + const channels = + config.teamsChannelsPath === undefined + ? [] + : loadTeamsChannelConfigsFromFileSync(config.teamsChannelsPath); + const t3 = yield* T3Session; + const links = yield* ThreadLinkStore; + const services = yield* Effect.context(); + const run = Effect.runPromiseWith(services); + + const app = new App({ + clientId: config.teamsClientId, + clientSecret: config.teamsClientSecret, + tenantId: config.teamsTenantId, + messagingEndpoint: config.teamsMessagingEndpoint, + activity: { mentions: { stripText: true } }, + }); + + app.on("message", async ({ activity, send, reply }) => { + await run( + Effect.gen(function* () { + const location = coordinates(activity); + const sourceKey = sourceConversationKey(location); + const channel = channelForCoordinates(channels, location); + const projectShortName = channel?.projectShortName ?? config.teamsDefaultProjectShortName; + const prompt = (activity.text ?? "").trim(); + const existing = yield* links.getBySourceThread("teams", sourceKey); + + const stop = /^(?:\/?stop|cancel)$/iu.test(prompt); + if (stop) { + if (existing === null) { + yield* Effect.promise(() => reply("There is no linked T3 thread to stop.")); + return; + } + yield* t3.interrupt(existing.t3ThreadId); + yield* Effect.promise(() => reply("Stopped the active T3 turn.")); + return; + } + + const approval = /^(?:\/?)(approve|deny)\s+(\S+)$/iu.exec(prompt); + if (approval !== null) { + if (existing === null) { + yield* Effect.promise(() => reply("There is no linked T3 thread for that approval.")); + return; + } + yield* t3.respondToApproval( + existing.t3ThreadId, + approval[2]!, + approval[1]!.toLowerCase() === "approve" ? "accept" : "decline", + ); + yield* Effect.promise(() => reply(`Approval ${approval[1]!.toLowerCase()}ed.`)); + return; + } + + const userInput = /^(?:\/?)answer\s+(\S+)\s+(.+)$/isu.exec(prompt); + if (userInput !== null) { + if (existing === null) { + yield* Effect.promise(() => + reply("There is no linked T3 thread for that input request."), + ); + return; + } + const parsed = yield* Effect.try({ + try: () => JSON.parse(userInput[2]!) as unknown, + catch: () => new Error("Answers must be a JSON object."), + }).pipe(Effect.flatMap(Schema.decodeUnknownEffect(ProviderUserInputAnswers))); + yield* t3.respondToUserInput(existing.t3ThreadId, userInput[1]!, parsed); + yield* Effect.promise(() => reply("Submitted the requested input to T3.")); + return; + } + + if (prompt.length === 0) return; + if (projectShortName === undefined) { + yield* Effect.promise(() => + reply( + "No T3 project is mapped to this Teams location. Configure TEAMS_CHANNELS_PATH or TEAMS_DEFAULT_PROJECT_SHORT_NAME.", + ), + ); + return; + } + + const baselineSnapshot = + existing === null + ? null + : yield* t3 + .fetchThreadDetail(existing.t3ThreadId) + .pipe(Effect.orElseSucceed(() => null)); + const baseline = baselineSnapshot === null ? "" : finalAnswerText(baselineSnapshot.thread); + const baselineTurnId = baselineSnapshot?.thread.latestTurn?.turnId ?? null; + const turn = yield* startOrContinueT3Turn(config, { + source: { sourceKind: "teams", sourceThreadId: sourceKey }, + externalConversationId: location.conversationId, + externalParentId: `${location.teamId ?? "chat"}/${location.channelId ?? "chat"}`, + externalTenantId: location.tenantId, + projectShortName, + prompt, + flags: {}, + stickyModelOnContinue: true, + promptContext: { kind: "raw", value: prompt }, + }); + + const webLink = + config.webUiBaseUrl === undefined + ? null + : `${config.webUiBaseUrl.replace(/\/$/u, "")}/?thread=${turn.threadId}`; + yield* Effect.promise(() => + reply( + [ + turn.isNew + ? `Started T3 for **${projectShortName}**.` + : "Continued the linked T3 thread.", + webLink === null ? null : `[Open in T3 Code](${webLink})`, + ] + .filter((line): line is string => line !== null) + .join("\n"), + ), + ); + yield* Effect.forkDetach( + waitForFinalAnswer({ + t3ThreadId: turn.threadId, + baseline, + baselineTurnId, + send: (text) => send(text), + }).pipe( + Effect.catchCause((cause) => + Effect.logError("Native Teams answer delivery failed", { + threadId: turn.threadId, + cause, + }), + ), + ), + ); + }).pipe( + Effect.catch((error) => + Effect.logError("Native Teams message failed", { error: String(error) }).pipe( + Effect.andThen( + Effect.promise(() => + reply( + "T3 could not process this message. Check the bridge logs and configuration.", + ), + ), + ), + ), + ), + ), + ); + }); + + app.on("message.ext.open", async ({ activity }) => { + const location = coordinates(activity); + const channel = channelForCoordinates(channels, location); + return { + task: { + type: "continue", + value: { + title: "Start T3 investigation", + height: "medium", + width: "medium", + card: messageActionCard(channel?.projectShortName ?? config.teamsDefaultProjectShortName), + }, + }, + }; + }); + + app.on("message.ext.submit", async ({ activity }) => { + const data = activity.value.data as + | { readonly projectShortName?: unknown; readonly instructions?: unknown } + | undefined; + const projectShortName = + typeof data?.projectShortName === "string" ? data.projectShortName.trim() : ""; + if (projectShortName.length === 0) { + return { task: { type: "message", value: "A project alias is required." } }; + } + const sourceMessage = teamsMessageText({ + id: activity.value.messagePayload?.id ?? activity.id, + body: activity.value.messagePayload?.body, + from: activity.value.messagePayload?.from, + }); + const instructions = typeof data?.instructions === "string" ? data.instructions.trim() : ""; + const prompt = [ + "Investigate the following Microsoft Teams message.", + sourceMessage, + instructions.length === 0 ? null : `Additional instructions: ${instructions}`, + ] + .filter((line): line is string => line !== null && line.length > 0) + .join("\n\n"); + const location = coordinates(activity); + const messageId = activity.value.messagePayload?.id ?? activity.id; + const sourceKey = `message-action/${location.tenantId}/${messageId}`; + + Effect.runForkWith(services)( + startOrContinueT3Turn(config, { + source: { sourceKind: "teams", sourceThreadId: sourceKey }, + externalConversationId: sourceKey, + externalParentId: `${location.teamId ?? "chat"}/${location.channelId ?? "chat"}`, + externalTenantId: location.tenantId, + projectShortName, + prompt, + flags: {}, + promptContext: { kind: "raw", value: prompt }, + }).pipe( + Effect.catchCause((cause) => + Effect.logError("Teams message action failed", { sourceKey, cause }), + ), + ), + ); + return { + task: { + type: "message", + value: "T3 investigation started. Open T3 Code to follow progress.", + }, + }; + }); + + yield* Effect.tryPromise({ + try: () => app.start(config.teamsPort), + catch: (cause) => new Error(`Could not start native Teams app: ${String(cause)}`), + }); + yield* Effect.logInfo("Native Teams app listening", { + port: config.teamsPort, + endpoint: config.teamsMessagingEndpoint, + }); +}); diff --git a/apps/discord-bot/src/features/ThreadInfoPin.ts b/apps/discord-bot/src/features/ThreadInfoPin.ts new file mode 100644 index 000000000000..2d082cb89f1d --- /dev/null +++ b/apps/discord-bot/src/features/ThreadInfoPin.ts @@ -0,0 +1,829 @@ +// @effect-diagnostics globalFetch:off globalFetchInEffect:off unknownInEffectCatch:off anyUnknownInErrorContext:off outdatedApi:off +import type { ProjectId, ThreadId } from "@t3tools/contracts"; +import { DiscordConfig, DiscordREST } from "dfx"; +import * as Effect from "effect/Effect"; +import * as Redacted from "effect/Redacted"; + +import type { DiscordBotConfig } from "../config.ts"; +import { resolveGitHubUrlForWorkspace } from "../presentation/githubLinks.ts"; +import { + extractJiraIssueKeysFromDiscordMessage, + jiraIssueKeysAfterExcludingSentryFalsePositives, + jiraIssueKeysMaskedBySentryContext, +} from "../presentation/jiraLinks.ts"; +import { + extractSentryIssueUrlsFromDiscordMessage, + mergeSentryIssueUrls, +} from "../presentation/sentryLinks.ts"; +import { + buildDiscordThreadJumpUrl, + buildT3WebThreadUrl, + ensureDiscordPrAttributionFooters, + formatDiscordPrAttributionFooter, + starterDisplayName, + starterUserId, + type DiscordThreadStarterLike, +} from "../presentation/discordPrAttribution.ts"; +import { + extractPullRequestUrlsFromDiscordMessage, + mergePullRequestUrls, + normalizeGithubRepoSlug, +} from "../presentation/prLinks.ts"; +import { SUPPRESS_EMBEDS_FLAG } from "../presentation/suppressEmbeds.ts"; +import { + applyModelHistoryUpdate, + formatModelSelectionLine, + formatThreadInfoModelLine, + isThreadInfoPinContent, + renderThreadInfoPin, + type ThreadInfoPinRenderInput, + type ThreadModelHistory, +} from "../presentation/threadInfoPin.ts"; +import { ThreadLinkStore, type ThreadLink } from "../store/ThreadLinkStore.ts"; +import { T3Session } from "../t3/T3Session.ts"; + +interface DiscordMessageSummary { + readonly id: string; + readonly content?: string | null; + readonly embeds?: ReadonlyArray<{ + readonly url?: string | null; + readonly title?: string | null; + readonly description?: string | null; + readonly author?: { readonly name?: string | null } | null; + readonly footer?: { readonly text?: string | null } | null; + }> | null; + readonly author?: { + readonly id?: string; + readonly bot?: boolean; + readonly username?: string; + readonly global_name?: string | null; + } | null; + readonly timestamp?: string | null; +} + +interface DiscordChannelSummary { + readonly id: string; + readonly name?: string | null; + readonly parent_id?: string | null; + readonly owner_id?: string | null; +} + +export interface ThreadInfoPinMessageRef { + readonly channelId: string; + readonly messageId: string; + readonly jiraIssueKeys: ReadonlyArray; + readonly sentryIssueUrls: ReadonlyArray; + readonly prUrls: ReadonlyArray; +} + +async function discordApiJson(input: { + readonly baseUrl: string; + readonly botToken: string; + readonly path: string; + readonly method?: string; + readonly body?: unknown; +}): Promise { + const response = await globalThis.fetch(`${input.baseUrl.replace(/\/+$/u, "")}${input.path}`, { + method: input.method ?? "GET", + headers: { + Authorization: `Bot ${input.botToken}`, + "Content-Type": "application/json", + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + ...(input.body === undefined ? {} : { body: JSON.stringify(input.body) }), + }); + if (!response.ok) { + const body = await response.text().catch(() => ""); + throw new Error( + `Discord API ${input.method ?? "GET"} ${input.path} failed (${response.status}): ${body}`, + ); + } + if (response.status === 204) { + return undefined as T; + } + return (await response.json()) as T; +} + +async function discordApiVoid(input: { + readonly baseUrl: string; + readonly botToken: string; + readonly path: string; + readonly method: string; +}): Promise { + const response = await globalThis.fetch(`${input.baseUrl.replace(/\/+$/u, "")}${input.path}`, { + method: input.method, + headers: { + Authorization: `Bot ${input.botToken}`, + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + }); + if (!response.ok && response.status !== 204) { + const body = await response.text().catch(() => ""); + throw new Error( + `Discord API ${input.method} ${input.path} failed (${response.status}): ${body}`, + ); + } +} + +function t3WebThreadUrl(webUiBaseUrl: string | undefined, threadId: string): string | null { + if (webUiBaseUrl === undefined) return null; + return `${webUiBaseUrl.replace(/\/$/u, "")}/?thread=${threadId}`; +} + +export function modelHistoryFromLink( + link: + | Pick + | null + | undefined, +): ThreadModelHistory { + return { + initialModelLine: link?.initialModelLine ?? null, + currentModelLine: link?.currentModelLine ?? null, + modelSinceAt: link?.modelSinceAt ?? null, + }; +} + +export function buildThreadInfoRenderInput(input: { + readonly modelSelection?: + | { readonly instanceId: string; readonly model: string } + | null + | undefined; + /** When set, preferred over a bare modelSelection line (includes since/started-with). */ + readonly modelHistory?: ThreadModelHistory | null | undefined; + readonly worktreePath?: string | null | undefined; + readonly baseBranchLabel?: string | null | undefined; + readonly local?: boolean | undefined; + readonly webLink?: string | null | undefined; + readonly extraLines?: ReadonlyArray | undefined; + readonly sentryIssueUrls?: ReadonlyArray | undefined; + readonly jiraIssueKeys?: ReadonlyArray | undefined; + readonly jiraBrowseBaseUrl?: string | undefined; + readonly prUrls?: ReadonlyArray | undefined; + readonly channelGithubRepoSlug?: string | null | undefined; + readonly titleLine?: string | null | undefined; +}): ThreadInfoPinRenderInput { + const modelLineFromHistory = + input.modelHistory === null || input.modelHistory === undefined + ? null + : formatThreadInfoModelLine(input.modelHistory); + const modelLine = + modelLineFromHistory ?? + (input.modelSelection === null || input.modelSelection === undefined + ? null + : formatModelSelectionLine(input.modelSelection)); + + let worktreeLine: string | null = null; + if (input.local === true) { + worktreeLine = "Mode: local (no worktree)"; + } else if (input.worktreePath !== null && input.worktreePath !== undefined) { + worktreeLine = `Worktree: \`${input.worktreePath}\``; + } else if (input.baseBranchLabel !== null && input.baseBranchLabel !== undefined) { + worktreeLine = `Worktree off \`${input.baseBranchLabel}\``; + } + + return { + modelLine, + worktreeLine, + webLink: input.webLink ?? null, + extraLines: [...(input.titleLine ? [input.titleLine] : []), ...(input.extraLines ?? [])], + sentryIssueUrls: input.sentryIssueUrls ?? [], + jiraIssueKeys: input.jiraIssueKeys ?? [], + jiraBrowseBaseUrl: input.jiraBrowseBaseUrl, + prUrls: input.prUrls ?? [], + channelGithubRepoSlug: input.channelGithubRepoSlug ?? null, + }; +} + +/** + * Resolve the channel/project GitHub `owner/repo` for PR label disambiguation. + * Prefers the thread worktree, then the linked project workspace root. + */ +const resolveChannelGithubRepoSlug = (input: { + readonly worktreePath?: string | null | undefined; + readonly projectId?: ProjectId | string | null | undefined; +}) => + Effect.gen(function* () { + const t3 = yield* T3Session; + let cwd = + input.worktreePath !== null && + input.worktreePath !== undefined && + input.worktreePath.trim() !== "" + ? input.worktreePath + : null; + + if (cwd === null && input.projectId !== null && input.projectId !== undefined) { + const project = yield* t3.getProjectShell(input.projectId as ProjectId); + const root = project?.workspaceRoot?.trim() ?? ""; + cwd = root.length > 0 ? root : null; + } + + if (cwd === null) return null; + + const githubUrl = yield* Effect.tryPromise({ + try: () => resolveGitHubUrlForWorkspace(cwd), + catch: () => null as string | null, + }).pipe(Effect.orElseSucceed(() => null as string | null)); + + return normalizeGithubRepoSlug(githubUrl); + }); + +/** + * Load Discord thread starter (public-thread parent message or oldest thread message) + * and the current thread title for hardcoded PR attribution footers. + */ +const loadDiscordThreadAttributionContext = (input: { + readonly discordThreadId: string; + readonly parentChannelId: string | null; + readonly guildId: string; + readonly baseUrl: string; + readonly botToken: string; +}) => + Effect.gen(function* () { + const channel = yield* Effect.tryPromise({ + try: () => + discordApiJson({ + baseUrl: input.baseUrl, + botToken: input.botToken, + path: `/channels/${input.discordThreadId}`, + }), + catch: (cause) => cause, + }).pipe(Effect.orElseSucceed((): DiscordChannelSummary | null => null)); + + const parentChannelId = + input.parentChannelId ?? + (channel?.parent_id !== null && channel?.parent_id !== undefined && channel.parent_id !== "" + ? channel.parent_id + : null); + + let starter: DiscordThreadStarterLike | null = null; + if (parentChannelId !== null) { + // Public threads created from a message use the starter message id as the thread id. + starter = yield* Effect.tryPromise({ + try: () => + discordApiJson({ + baseUrl: input.baseUrl, + botToken: input.botToken, + path: `/channels/${parentChannelId}/messages/${input.discordThreadId}`, + }), + catch: (cause) => cause, + }).pipe( + Effect.map((message): DiscordThreadStarterLike => ({ + id: message.id, + author: { + id: message.author?.id, + username: message.author?.username, + displayName: message.author?.global_name ?? message.author?.username, + }, + })), + Effect.orElseSucceed((): DiscordThreadStarterLike | null => null), + ); + } + + if (starter === null) { + const listed = yield* Effect.tryPromise({ + try: () => + discordApiJson>({ + baseUrl: input.baseUrl, + botToken: input.botToken, + path: `/channels/${input.discordThreadId}/messages?limit=5&after=0`, + }), + catch: (cause) => cause, + }).pipe(Effect.orElseSucceed((): ReadonlyArray => [])); + + const oldest = listed.at(-1) ?? listed[0]; + if (oldest !== undefined) { + starter = { + id: oldest.id, + author: { + id: oldest.author?.id, + username: oldest.author?.username, + displayName: oldest.author?.global_name ?? oldest.author?.username, + }, + }; + } + } + + const threadTitle = + channel?.name !== null && channel?.name !== undefined && channel.name.trim() !== "" + ? channel.name.trim() + : "Discord thread"; + + const userId = starterUserId(starter); + if (userId === null) return null; + + return { + footer: formatDiscordPrAttributionFooter({ + starterDisplayName: starterDisplayName(starter), + starterUserId: userId, + threadTitle, + threadJumpUrl: buildDiscordThreadJumpUrl({ + guildId: input.guildId, + discordThreadId: input.discordThreadId, + messageId: starter?.id ?? null, + }), + }), + threadTitle, + starterUserId: userId, + } as const; + }); + +/** + * When GitHub PR URLs are observed on a Discord-linked thread, hard-append the + * Discord attribution footer using the **thread starter** + thread title. + * Idempotent (skips bodies that already have the footer). Best-effort only. + */ +const ensureAttributionFootersForIncomingPrs = (input: { + readonly discordThreadId: string; + readonly link: ThreadLink | null; + readonly incomingPrUrls: ReadonlyArray; + readonly webUiBaseUrl?: string | undefined; +}) => + Effect.gen(function* () { + const prUrls = mergePullRequestUrls([], input.incomingPrUrls); + if (prUrls.length === 0) return; + + const links = yield* ThreadLinkStore; + const link = input.link ?? (yield* links.getByDiscordThreadId(input.discordThreadId)); + if (link === null) { + yield* Effect.logWarning("Skipping Discord PR attribution footer: no thread link", { + discordThreadId: input.discordThreadId, + prCount: prUrls.length, + }); + return; + } + + const discordConfig = yield* DiscordConfig.DiscordConfig; + const botToken = Redacted.value(discordConfig.token); + const baseUrl = discordConfig.rest.baseUrl; + + const attribution = yield* loadDiscordThreadAttributionContext({ + discordThreadId: input.discordThreadId, + parentChannelId: link.channelId, + guildId: link.guildId, + baseUrl, + botToken, + }); + if (attribution === null) { + yield* Effect.logWarning("Skipping Discord PR attribution footer: no thread starter", { + discordThreadId: input.discordThreadId, + prCount: prUrls.length, + }); + return; + } + + const t3FullThreadUrl = buildT3WebThreadUrl(input.webUiBaseUrl, link.t3ThreadId); + + const results = yield* Effect.tryPromise({ + try: () => + ensureDiscordPrAttributionFooters({ + prUrls, + footer: attribution.footer, + t3FullThreadUrl, + }), + catch: (cause) => cause, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Discord PR attribution footer ensure failed", { + discordThreadId: input.discordThreadId, + error: String(error), + }).pipe(Effect.as([] as const)), + ), + ); + + for (const result of results) { + if (result.status === "updated") { + yield* Effect.logInfo("Appended Discord PR attribution footer", { + discordThreadId: input.discordThreadId, + prUrl: result.url, + threadTitle: attribution.threadTitle, + starterUserId: attribution.starterUserId, + }); + } else if (result.status === "error") { + yield* Effect.logWarning("Failed to append Discord PR attribution footer", { + discordThreadId: input.discordThreadId, + prUrl: result.url, + detail: result.detail ?? null, + }); + } + } + }); + +/** + * Create or update the pinned thread-info message and ensure it stays pinned. + */ +export const ensureThreadInfoPin = (input: { + readonly channelId: string; + readonly content: string; + readonly existingMessageId?: string | null; +}) => + Effect.gen(function* () { + const discordConfig = yield* DiscordConfig.DiscordConfig; + const botToken = Redacted.value(discordConfig.token); + const baseUrl = discordConfig.rest.baseUrl; + + const pinned = yield* Effect.tryPromise({ + try: () => + discordApiJson>({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins`, + }), + catch: (cause) => cause, + }).pipe(Effect.orElseSucceed((): ReadonlyArray => [])); + + const infoPins = pinned.filter((message) => isThreadInfoPinContent(message.content)); + const existingFromPins = infoPins[0] ?? null; + const stale = infoPins.slice(1); + + let messageId = + input.existingMessageId && input.existingMessageId.trim() !== "" + ? input.existingMessageId + : (existingFromPins?.id ?? null); + + // Prefer the stored id when still present among pins or when it still exists. + if (messageId !== null) { + const patchOk = yield* Effect.tryPromise({ + try: () => + discordApiJson({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/messages/${messageId}`, + method: "PATCH", + body: { content: input.content, flags: SUPPRESS_EMBEDS_FLAG }, + }), + catch: (cause) => cause, + }).pipe( + Effect.as(true as const), + Effect.orElseSucceed(() => false as const), + ); + + if (!patchOk) { + messageId = existingFromPins?.id ?? null; + if (messageId !== null) { + yield* Effect.tryPromise({ + try: () => + discordApiJson({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/messages/${messageId}`, + method: "PATCH", + body: { content: input.content, flags: SUPPRESS_EMBEDS_FLAG }, + }), + catch: (cause) => cause, + }); + } + } + } + + if (messageId === null) { + const created = yield* Effect.tryPromise({ + try: () => + discordApiJson<{ readonly id: string }>({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/messages`, + method: "POST", + body: { content: input.content, flags: SUPPRESS_EMBEDS_FLAG }, + }), + catch: (cause) => cause, + }); + messageId = created.id; + } + + // Ensure pin (idempotent PUT). + yield* Effect.tryPromise({ + try: () => + discordApiVoid({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins/${messageId}`, + method: "PUT", + }), + catch: (cause) => cause, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to pin thread info message", { + channelId: input.channelId, + messageId, + error: String(error), + }), + ), + ); + + for (const message of stale) { + if (message.id === messageId) continue; + yield* Effect.tryPromise({ + try: () => + discordApiVoid({ + baseUrl, + botToken, + path: `/channels/${input.channelId}/pins/${message.id}`, + method: "DELETE", + }), + catch: (cause) => cause, + }).pipe(Effect.catch(() => Effect.void)); + } + + return { + channelId: input.channelId, + messageId, + } as const; + }); + +/** + * Persist any newly observed Jira keys / Sentry / PR URLs, then create/update + pin the thread-info message. + */ +export const upsertThreadInfoPin = (input: { + readonly discordThreadId: string; + readonly t3ThreadId: string; + readonly botConfig: DiscordBotConfig; + readonly incomingJiraKeys?: ReadonlyArray; + /** Sentry short ids that were previously stored as Jira keys and should be dropped. */ + readonly dropJiraIssueKeys?: ReadonlyArray; + readonly incomingSentryIssueUrls?: ReadonlyArray; + readonly incomingPrUrls?: ReadonlyArray; + readonly modelSelection?: { readonly instanceId: string; readonly model: string } | null; + readonly worktreePath?: string | null; + readonly baseBranchLabel?: string | null; + readonly local?: boolean; + /** Skip GitHub repo slug enrichment on latency-sensitive bootstrap paths. */ + readonly skipChannelRepoLookup?: boolean; + readonly extraLines?: ReadonlyArray; + readonly titleLine?: string | null; +}) => + Effect.gen(function* () { + const links = yield* ThreadLinkStore; + const existing = yield* links.getByDiscordThreadId(input.discordThreadId); + + let jiraIssueKeys = jiraIssueKeysAfterExcludingSentryFalsePositives( + existing?.jiraIssueKeys, + input.incomingJiraKeys ?? [], + input.dropJiraIssueKeys ?? [], + ); + const existingJira = existing?.jiraIssueKeys ?? []; + const jiraUnchanged = + jiraIssueKeys.length === existingJira.length && + jiraIssueKeys.every((key, index) => key === existingJira[index]); + if (!jiraUnchanged) { + const updated = yield* links.setJiraIssueKeys(input.discordThreadId, jiraIssueKeys); + if (updated !== null) { + jiraIssueKeys = updated.jiraIssueKeys ?? jiraIssueKeys; + } + } + + let sentryIssueUrls = mergeSentryIssueUrls( + existing?.sentryIssueUrls, + input.incomingSentryIssueUrls ?? [], + ); + if ((input.incomingSentryIssueUrls?.length ?? 0) > 0) { + const updated = yield* links.appendSentryIssueUrls( + input.discordThreadId, + input.incomingSentryIssueUrls ?? [], + ); + if (updated !== null) { + sentryIssueUrls = updated.sentryIssueUrls ?? sentryIssueUrls; + } + } + + let prUrls = mergePullRequestUrls(existing?.prUrls, input.incomingPrUrls ?? []); + if ((input.incomingPrUrls?.length ?? 0) > 0) { + const updated = yield* links.appendPrUrls(input.discordThreadId, input.incomingPrUrls ?? []); + if (updated !== null) { + prUrls = updated.prUrls ?? prUrls; + } + } + + // Hardcode Discord PR attribution (thread starter + title) — no agent prompt. + // Only runs for *incoming* PR URLs this call (pin refresh with empty incoming is a no-op). + // ensureDiscordPrAttributionFooters is idempotent if the footer is already present. + // Also appends T3 thread link: full host for private GH repos, short t3vm host for public. + yield* ensureAttributionFootersForIncomingPrs({ + discordThreadId: input.discordThreadId, + link: existing, + incomingPrUrls: input.incomingPrUrls ?? [], + webUiBaseUrl: input.botConfig.webUiBaseUrl, + }).pipe( + Effect.catch((error) => + Effect.logWarning("Discord PR attribution side-effect failed", { + discordThreadId: input.discordThreadId, + error: String(error), + }), + ), + ); + + const nextModelLine = + input.modelSelection === null || input.modelSelection === undefined + ? null + : formatModelSelectionLine(input.modelSelection); + const modelHistory = applyModelHistoryUpdate(modelHistoryFromLink(existing), nextModelLine); + if ( + modelHistory.initialModelLine !== (existing?.initialModelLine ?? null) || + modelHistory.currentModelLine !== (existing?.currentModelLine ?? null) || + modelHistory.modelSinceAt !== (existing?.modelSinceAt ?? null) + ) { + yield* links.setModelHistory(input.discordThreadId, modelHistory); + } + + const channelGithubRepoSlug = + input.skipChannelRepoLookup === true + ? null + : yield* resolveChannelGithubRepoSlug({ + worktreePath: input.worktreePath, + projectId: existing?.projectId, + }); + + const content = renderThreadInfoPin( + buildThreadInfoRenderInput({ + modelSelection: input.modelSelection, + modelHistory, + worktreePath: input.worktreePath, + baseBranchLabel: input.baseBranchLabel, + local: input.local, + webLink: t3WebThreadUrl(input.botConfig.webUiBaseUrl, input.t3ThreadId), + extraLines: input.extraLines, + titleLine: input.titleLine, + sentryIssueUrls, + jiraIssueKeys, + jiraBrowseBaseUrl: input.botConfig.jiraBrowseBaseUrl, + prUrls, + channelGithubRepoSlug, + }), + ); + + // After setModelHistory the stored info message id is still on `existing`. + const latest = yield* links.getByDiscordThreadId(input.discordThreadId); + const pin = yield* ensureThreadInfoPin({ + channelId: input.discordThreadId, + content, + existingMessageId: latest?.infoDiscordMessageId ?? existing?.infoDiscordMessageId ?? null, + }); + + if ((latest?.infoDiscordMessageId ?? existing?.infoDiscordMessageId) !== pin.messageId) { + yield* links.setInfoDiscordMessageId(input.discordThreadId, pin.messageId); + } + + return { + channelId: pin.channelId, + messageId: pin.messageId, + jiraIssueKeys, + sentryIssueUrls, + prUrls, + } satisfies ThreadInfoPinMessageRef; + }); + +const BACKFILL_MESSAGE_PAGES = 5; +const BACKFILL_PAGE_SIZE = 100; +const BACKFILL_CONCURRENCY = 2; + +/** + * On bot start: scan linked Discord threads for Jira keys and PR URLs + * (chronological first-seen), rewrite the thread-info message, and ensure it is pinned. + */ +export const backfillThreadInfoPins = (botConfig: DiscordBotConfig) => + Effect.gen(function* () { + const links = yield* ThreadLinkStore; + + const all = yield* links.list(); + const active = all + .filter((link) => link.status === "active") + .toSorted((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt)); + + yield* Effect.logInfo("Thread info pin backfill starting", { + activeLinks: active.length, + jiraBrowseBaseUrl: botConfig.jiraBrowseBaseUrl ?? "(unset)", + }); + + let updated = 0; + let failed = 0; + let skipped = 0; + + yield* Effect.forEach( + active, + (link) => + Effect.gen(function* () { + const result = yield* backfillOneThreadInfoPin(link, botConfig).pipe(Effect.result); + + if (result._tag === "Failure") { + failed += 1; + yield* Effect.logWarning("Thread info pin backfill failed", { + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + error: String(result.failure), + }); + return; + } + if (result.success === "skipped") { + skipped += 1; + return; + } + updated += 1; + }), + { concurrency: BACKFILL_CONCURRENCY }, + ); + + yield* Effect.logInfo("Thread info pin backfill finished", { + considered: active.length, + updated, + skipped, + failed, + }); + }); + +const backfillOneThreadInfoPin = (link: ThreadLink, botConfig: DiscordBotConfig) => + Effect.gen(function* () { + const rest = yield* DiscordREST; + const t3 = yield* T3Session; + const links = yield* ThreadLinkStore; + + const channelOk = yield* rest.getChannel(link.discordThreadId).pipe( + Effect.as(true as const), + Effect.orElseSucceed(() => false as const), + ); + if (!channelOk) return "skipped" as const; + + const history = yield* fetchChannelMessagesOldestFirst(link.discordThreadId); + + const keysFromHistory: string[] = []; + const sentryMaskedFromHistory: string[] = []; + const sentryUrlsFromHistory: string[] = []; + const prUrlsFromHistory: string[] = []; + let discoveredInfoMessageId: string | null = link.infoDiscordMessageId ?? null; + + for (const message of history) { + if (isThreadInfoPinContent(message.content)) { + if (discoveredInfoMessageId === null) discoveredInfoMessageId = message.id; + // Do not re-parse our own pin — it can echo previously misclassified Jira keys. + continue; + } + const keys = extractJiraIssueKeysFromDiscordMessage(message); + for (const key of keys) keysFromHistory.push(key); + for (const key of jiraIssueKeysMaskedBySentryContext(message)) { + sentryMaskedFromHistory.push(key); + } + for (const url of extractSentryIssueUrlsFromDiscordMessage(message)) { + sentryUrlsFromHistory.push(url); + } + const prUrls = extractPullRequestUrlsFromDiscordMessage(message); + for (const url of prUrls) prUrlsFromHistory.push(url); + } + + const mergedKeys = jiraIssueKeysAfterExcludingSentryFalsePositives( + link.jiraIssueKeys, + keysFromHistory, + sentryMaskedFromHistory, + ); + yield* links.setJiraIssueKeys(link.discordThreadId, mergedKeys); + const mergedSentryUrls = mergeSentryIssueUrls(link.sentryIssueUrls, sentryUrlsFromHistory); + yield* links.setSentryIssueUrls(link.discordThreadId, mergedSentryUrls); + const mergedPrUrls = mergePullRequestUrls(link.prUrls, prUrlsFromHistory); + yield* links.setPrUrls(link.discordThreadId, mergedPrUrls); + if (discoveredInfoMessageId !== null && discoveredInfoMessageId !== link.infoDiscordMessageId) { + yield* links.setInfoDiscordMessageId(link.discordThreadId, discoveredInfoMessageId); + } + + const shell = yield* t3.getThreadShell(link.t3ThreadId as ThreadId); + const modelSelection = shell?.modelSelection ?? null; + const worktreePath = shell?.worktreePath ?? null; + + yield* upsertThreadInfoPin({ + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + botConfig, + incomingJiraKeys: [], + dropJiraIssueKeys: sentryMaskedFromHistory, + incomingSentryIssueUrls: [], + incomingPrUrls: [], + modelSelection, + worktreePath, + local: worktreePath === null, + // Keys/URLs already persisted via setJiraIssueKeys/setPrUrls; upsert merges from store. + }); + + return "updated" as const; + }); + +const fetchChannelMessagesOldestFirst = (channelId: string) => + Effect.gen(function* () { + const rest = yield* DiscordREST; + const newestFirst: DiscordMessageSummary[] = []; + let before: string | undefined; + + for (let page = 0; page < BACKFILL_MESSAGE_PAGES; page += 1) { + const batch = (yield* rest + .listMessages(channelId, { + limit: BACKFILL_PAGE_SIZE, + ...(before === undefined ? {} : { before }), + }) + .pipe( + Effect.orElseSucceed((): ReadonlyArray => []), + )) as ReadonlyArray; + + if (batch.length === 0) break; + newestFirst.push(...batch); + before = batch[batch.length - 1]?.id; + if (batch.length < BACKFILL_PAGE_SIZE) break; + } + + // Discord returns newest-first; reverse for chronological first-seen key order. + return newestFirst.toReversed(); + }); diff --git a/apps/discord-bot/src/features/ThreadRestore.test.ts b/apps/discord-bot/src/features/ThreadRestore.test.ts new file mode 100644 index 000000000000..33955ff0cbd1 --- /dev/null +++ b/apps/discord-bot/src/features/ThreadRestore.test.ts @@ -0,0 +1,280 @@ +// @effect-diagnostics globalDate:off +import type { ProjectId, ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import type { ThreadLink } from "../store/ThreadLinkStore.ts"; +import { MAX_ACTIVE_BRIDGES, pickEvictionVictim, type ActiveBridge } from "./BridgeHub.ts"; +import { + rankAndCapRestoreCandidates, + shellRestoreDecision, + type ShellRestoreDecision, +} from "./ThreadRestore.ts"; + +function link(partial: Partial & Pick): ThreadLink { + return { + discordThreadId: partial.discordThreadId, + t3ThreadId: (partial.t3ThreadId ?? `t3-${partial.discordThreadId}`) as ThreadId, + projectId: (partial.projectId ?? "proj") as ProjectId, + channelId: partial.channelId ?? "chan", + guildId: partial.guildId ?? "guild", + createdAt: partial.createdAt ?? "2026-01-01T00:00:00.000Z", + updatedAt: partial.updatedAt ?? partial.createdAt ?? "2026-01-01T00:00:00.000Z", + lastActivityAt: partial.lastActivityAt ?? "2026-01-01T00:00:00.000Z", + status: partial.status ?? "active", + lastSeenTurnId: partial.lastSeenTurnId ?? null, + lastFinalizedAssistantId: partial.lastFinalizedAssistantId ?? null, + lastThreadSnapshotSequence: partial.lastThreadSnapshotSequence ?? null, + lastDeliveredSequence: partial.lastDeliveredSequence ?? null, + streamDiscordMessageIds: partial.streamDiscordMessageIds, + }; +} + +function shell(overrides: { + latestTurnState?: "running" | "completed" | "interrupted" | null; + sessionStatus?: "running" | "starting" | "idle" | "error" | "interrupted" | null; + hasPendingApprovals?: boolean; + hasPendingUserInput?: boolean; +}): Parameters[0] { + return { + id: "t1" as ThreadId, + projectId: "p1" as ProjectId, + title: "x", + modelSelection: { instanceId: "codex" as never, model: "gpt" }, + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: null, + latestTurn: + overrides.latestTurnState === null || overrides.latestTurnState === undefined + ? null + : ({ + turnId: "turn-1", + state: overrides.latestTurnState, + requestedAt: "2026-01-01T00:00:00.000Z", + startedAt: "2026-01-01T00:00:00.000Z", + completedAt: null, + assistantMessageId: null, + } as never), + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + archivedAt: null, + session: + overrides.sessionStatus === null || overrides.sessionStatus === undefined + ? null + : ({ + threadId: "t1", + status: overrides.sessionStatus, + providerName: null, + runtimeMode: "full-access", + activeTurnId: null, + lastError: null, + updatedAt: "2026-01-01T00:00:00.000Z", + } as never), + latestUserMessageAt: null, + hasPendingApprovals: overrides.hasPendingApprovals ?? false, + hasPendingUserInput: overrides.hasPendingUserInput ?? false, + hasActionableProposedPlan: false, + } as unknown as Parameters[0]; +} + +describe("shellRestoreDecision", () => { + it("marks missing shell as missing", () => { + expect(shellRestoreDecision(null)).toEqual({ kind: "missing" } satisfies ShellRestoreDecision); + }); + + it("restores running turns", () => { + const decision = shellRestoreDecision(shell({ latestTurnState: "running" })); + expect(decision.kind).toBe("restore"); + if (decision.kind === "restore") { + expect(decision.reasons).toContain("running"); + } + }); + + it("restores session starting/running", () => { + expect(shellRestoreDecision(shell({ sessionStatus: "starting" })).kind).toBe("restore"); + expect(shellRestoreDecision(shell({ sessionStatus: "running" })).kind).toBe("restore"); + }); + + it("restores interrupted sessions only when a turn still looks unfinished", () => { + const decision = shellRestoreDecision( + shell({ sessionStatus: "interrupted", latestTurnState: "running" }), + ); + expect(decision.kind).toBe("restore"); + if (decision.kind === "restore") { + expect(decision.reasons).toContain("session-wake-required"); + } + }); + + it("does not restore zombie interrupted sessions with a completed turn", () => { + expect( + shellRestoreDecision(shell({ sessionStatus: "interrupted", latestTurnState: "completed" })) + .kind, + ).toBe("idle"); + }); + + it("restores pending approvals / user input", () => { + expect(shellRestoreDecision(shell({ hasPendingApprovals: true })).kind).toBe("restore"); + expect(shellRestoreDecision(shell({ hasPendingUserInput: true })).kind).toBe("restore"); + }); + + it("restores when open stream ids need catch-up finalize", () => { + const decision = shellRestoreDecision(shell({ latestTurnState: "completed" }), { + hasOpenStreamIds: true, + }); + expect(decision.kind).toBe("restore"); + if (decision.kind === "restore") { + expect(decision.reasons).toContain("open-stream-ids"); + } + }); + + it("restores when dual-cursor delivery lags orchestration", () => { + const decision = shellRestoreDecision(shell({ latestTurnState: "completed" }), { + deliveryBehind: true, + }); + expect(decision.kind).toBe("restore"); + if (decision.kind === "restore") { + expect(decision.reasons).toContain("delivery-behind"); + } + }); + + it("skips idle completed threads without open stream ids", () => { + expect( + shellRestoreDecision(shell({ latestTurnState: "completed" }), { hasOpenStreamIds: false }) + .kind, + ).toBe("idle"); + }); +}); + +describe("rankAndCapRestoreCandidates", () => { + it("keeps urgent candidates ahead of newer idle links", () => { + const candidates = [ + { + link: link({ discordThreadId: "idle-new", lastActivityAt: "2026-06-01T00:00:00.000Z" }), + urgent: false, + }, + { + link: link({ discordThreadId: "urgent-old", lastActivityAt: "2026-01-01T00:00:00.000Z" }), + urgent: true, + }, + { + link: link({ discordThreadId: "urgent-new", lastActivityAt: "2026-03-01T00:00:00.000Z" }), + urgent: true, + }, + { + link: link({ + discordThreadId: "tomb", + lastActivityAt: "2026-07-01T00:00:00.000Z", + status: "tombstone", + }), + urgent: true, + }, + ]; + const { selected, dropped } = rankAndCapRestoreCandidates(candidates, 2); + expect(selected.map((entry) => entry.link.discordThreadId)).toEqual([ + "urgent-new", + "urgent-old", + ]); + expect(dropped).toBe(1); + }); + + it("defaults cap to MAX_ACTIVE_BRIDGES", () => { + expect(MAX_ACTIVE_BRIDGES).toBe(50); + const many = Array.from({ length: 60 }, (_, index) => ({ + link: link({ + discordThreadId: `d-${index}`, + lastActivityAt: new Date(Date.UTC(2026, 0, 1 + index)).toISOString(), + }), + urgent: index < 5, + })); + const { selected, dropped } = rankAndCapRestoreCandidates(many); + expect(selected).toHaveLength(50); + expect(selected.slice(0, 5).every((entry) => entry.urgent)).toBe(true); + expect(dropped).toBe(10); + }); + + it("orders idle candidates by lastActivityAt once urgent slots are satisfied", () => { + const candidates = [ + { + link: link({ discordThreadId: "idle-old", lastActivityAt: "2026-01-01T00:00:00.000Z" }), + urgent: false, + }, + { + link: link({ discordThreadId: "idle-new", lastActivityAt: "2026-06-01T00:00:00.000Z" }), + urgent: false, + }, + { + link: link({ discordThreadId: "urgent", lastActivityAt: "2026-02-01T00:00:00.000Z" }), + urgent: true, + }, + ]; + const { selected } = rankAndCapRestoreCandidates(candidates, 3); + expect(selected.map((entry) => entry.link.discordThreadId)).toEqual([ + "urgent", + "idle-new", + "idle-old", + ]); + }); +}); + +describe("pickEvictionVictim", () => { + const entry = ( + partial: Partial & Pick, + ): ActiveBridge => ({ + discordChannelId: partial.discordChannelId, + t3ThreadId: partial.t3ThreadId ?? "t3", + lastActivityAt: partial.lastActivityAt ?? "2026-01-01T00:00:00.000Z", + preferred: partial.preferred ?? false, + mode: partial.mode ?? "rehydrate", + }); + + it("prefers oldest non-preferred bridge", () => { + const victim = pickEvictionVictim( + [ + entry({ + discordChannelId: "pref-old", + preferred: true, + lastActivityAt: "2026-01-01T00:00:00.000Z", + }), + entry({ + discordChannelId: "idle-new", + preferred: false, + lastActivityAt: "2026-06-01T00:00:00.000Z", + }), + entry({ + discordChannelId: "idle-old", + preferred: false, + lastActivityAt: "2026-02-01T00:00:00.000Z", + }), + ], + "incoming", + ); + expect(victim?.discordChannelId).toBe("idle-old"); + }); + + it("falls back to oldest preferred when all are preferred", () => { + const victim = pickEvictionVictim( + [ + entry({ + discordChannelId: "a", + preferred: true, + lastActivityAt: "2026-03-01T00:00:00.000Z", + }), + entry({ + discordChannelId: "b", + preferred: true, + lastActivityAt: "2026-01-01T00:00:00.000Z", + }), + ], + "incoming", + ); + expect(victim?.discordChannelId).toBe("b"); + }); + + it("never picks the except channel", () => { + const victim = pickEvictionVictim( + [entry({ discordChannelId: "only", preferred: false })], + "only", + ); + expect(victim).toBeNull(); + }); +}); diff --git a/apps/discord-bot/src/features/ThreadRestore.ts b/apps/discord-bot/src/features/ThreadRestore.ts new file mode 100644 index 000000000000..477bfa589e4d --- /dev/null +++ b/apps/discord-bot/src/features/ThreadRestore.ts @@ -0,0 +1,275 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectContext:off missingEffectError:off +/** + * Boot / T3-reconnect rehydrate of Discord↔T3 bridges. + * + * Restore set (design decision 1 + catch-up): + * - shell thread running / starting / pending approval / pending user-input + * - OR session interrupted (Wake Required — convert Working tips + ❗ title) + * - OR durable `streamDiscordMessageIds` non-empty (need finalize/cleanup after offline completion) + * - OR dual-cursor lag (`lastDeliveredSequence` behind `lastThreadSnapshotSequence`) + * + * Cap 50 by lastActivityAt desc. Concurrent ensure 4. + */ +import type { OrchestrationThreadShell, ThreadId } from "@t3tools/contracts"; +import { sessionNeedsWakeUp } from "@t3tools/shared/sessionWake"; +import { DiscordREST } from "dfx"; +import * as Effect from "effect/Effect"; + +import { ThreadLinkStore, type ThreadLink } from "../store/ThreadLinkStore.ts"; +import { T3Session } from "../t3/T3Session.ts"; +import { formatAlertCause, postFatalAlert } from "./Alerts.ts"; +import { BridgeHub, MAX_ACTIVE_BRIDGES } from "./BridgeHub.ts"; +import { isDeliveryBehindOrchestration } from "./ResponseBridge.ts"; + +export type RestoreCandidateReason = + | "running" + | "session-active" + | "session-wake-required" + | "pending-approval" + | "pending-user-input" + | "open-stream-ids" + | "delivery-behind" + | "idle-linked"; + +export type ShellRestoreDecision = + | { readonly kind: "missing" } + | { readonly kind: "idle" } + | { readonly kind: "restore"; readonly reasons: ReadonlyArray }; + +/** + * Pure shell-based restore decision (no Discord I/O). + * `hasOpenStreamIds` covers offline-completed turns that still need Discord finalize. + * `deliveryBehind` covers dual-cursor lag (orchestration advanced, Discord never applied). + */ +export function shellRestoreDecision( + shell: OrchestrationThreadShell | null | undefined, + options?: { + readonly hasOpenStreamIds?: boolean; + readonly deliveryBehind?: boolean; + }, +): ShellRestoreDecision { + if (shell === null || shell === undefined) { + // Thread gone from shell — cannot resume or finalize cleanly. + return { kind: "missing" }; + } + + const reasons: RestoreCandidateReason[] = []; + if (shell.latestTurn?.state === "running") reasons.push("running"); + if (shell.session?.status === "running" || shell.session?.status === "starting") { + reasons.push("session-active"); + } + // Only real mid-turn interrupts (not zombie interrupted + completed turn). + if ( + sessionNeedsWakeUp({ + sessionStatus: shell.session?.status ?? null, + activeTurnId: shell.session?.activeTurnId ?? null, + latestTurnState: shell.latestTurn?.state ?? null, + latestTurnCompletedAt: shell.latestTurn?.completedAt ?? null, + }) + ) { + reasons.push("session-wake-required"); + } + if (shell.hasPendingApprovals) reasons.push("pending-approval"); + if (shell.hasPendingUserInput) reasons.push("pending-user-input"); + if (options?.hasOpenStreamIds === true) reasons.push("open-stream-ids"); + if (options?.deliveryBehind === true) reasons.push("delivery-behind"); + + if (reasons.length === 0) return { kind: "idle" }; + return { kind: "restore", reasons }; +} + +/** Sort active links by freshest activity, cap at max. */ +export function rankAndCapRestoreCandidates( + candidates: ReadonlyArray<{ + readonly link: ThreadLink; + readonly urgent: boolean; + }>, + max: number = MAX_ACTIVE_BRIDGES, +): { + readonly selected: ReadonlyArray<{ + readonly link: ThreadLink; + readonly urgent: boolean; + }>; + readonly dropped: number; +} { + const active = candidates.filter((candidate) => candidate.link.status === "active"); + const sorted = [...active].sort((a, b) => { + if (a.urgent !== b.urgent) { + return a.urgent ? -1 : 1; + } + return b.link.lastActivityAt.localeCompare(a.link.lastActivityAt); + }); + const selected = sorted.slice(0, Math.max(0, max)); + return { selected, dropped: Math.max(0, sorted.length - selected.length) }; +} + +export type RehydrateStats = { + readonly considered: number; + readonly selected: number; + readonly restored: number; + readonly failed: number; + readonly tombstoned: number; + readonly idleLinked: number; + readonly cappedOut: number; +}; + +/** + * Select restore candidates from durable links + live T3 shell + Discord channel existence. + */ +export const selectRestoreCandidates = Effect.gen(function* () { + const links = yield* ThreadLinkStore; + const t3 = yield* T3Session; + const rest = yield* DiscordREST; + + const all = yield* links.list(); + const activeLinks = all.filter((link) => link.status === "active"); + + const candidates: Array<{ readonly link: ThreadLink; readonly urgent: boolean }> = []; + let tombstoned = 0; + let idleLinked = 0; + + for (const link of activeLinks) { + const shell = yield* t3.getThreadShell(link.t3ThreadId as ThreadId); + const hasOpenStreamIds = (link.streamDiscordMessageIds?.length ?? 0) > 0; + const deliveryBehind = isDeliveryBehindOrchestration({ + lastDeliveredSequence: link.lastDeliveredSequence, + lastThreadSnapshotSequence: link.lastThreadSnapshotSequence, + }); + const decision = shellRestoreDecision(shell, { hasOpenStreamIds, deliveryBehind }); + + if (decision.kind === "missing") { + yield* links.tombstone(link.discordThreadId); + tombstoned += 1; + yield* Effect.logWarning("Rehydrate tombstoned link (T3 thread missing)", { + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + }); + continue; + } + + // Discord channel must still exist. + const channelOk = yield* rest.getChannel(link.discordThreadId).pipe( + Effect.as(true as const), + Effect.catch((error) => { + const message = String(error); + // dfx / Discord 404 → gone + const missing = + message.includes("10003") || + message.includes("Unknown Channel") || + message.includes("404"); + return Effect.succeed(missing ? (false as const) : (true as const)); + }), + ); + if (!channelOk) { + yield* links.tombstone(link.discordThreadId); + tombstoned += 1; + yield* Effect.logWarning("Rehydrate tombstoned link (Discord channel missing)", { + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + }); + continue; + } + + if (decision.kind === "idle") { + idleLinked += 1; + candidates.push({ link, urgent: false }); + continue; + } + + candidates.push({ link, urgent: true }); + } + + const { selected, dropped } = rankAndCapRestoreCandidates(candidates, MAX_ACTIVE_BRIDGES); + if (dropped > 0) { + yield* Effect.logWarning("Rehydrate capped candidates by urgency and lastActivityAt", { + candidates: candidates.length, + selected: selected.length, + cappedOut: dropped, + cap: MAX_ACTIVE_BRIDGES, + }); + } + + return { + selected: selected.map((candidate) => candidate.link), + stats: { + considered: activeLinks.length, + selected: selected.length, + restored: 0, + failed: 0, + tombstoned, + idleLinked, + cappedOut: dropped, + } satisfies RehydrateStats, + }; +}); + +/** + * Re-establish bridges for active links after boot or T3 reconnect. + * Running / pending / lagging links outrank idle links under the cap. + * Catch-up finalize runs inside each bridge's first snapshot when the turn finished offline. + */ +export const rehydrateBridges = (source: "boot" | "reconnect") => + Effect.gen(function* () { + const hub = yield* BridgeHub; + + yield* Effect.logInfo("Discord bridge rehydrate starting", { source }); + + if (source === "reconnect") { + // subscribeThread fibers die with the old session; clear hub registry explicitly. + yield* hub.dropAll(); + } + + const { selected, stats } = yield* selectRestoreCandidates; + let restored = 0; + let failed = 0; + + yield* Effect.forEach( + selected, + (link) => + Effect.gen(function* () { + yield* hub.ensure({ + discordChannelId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + mode: "rehydrate", + lastActivityAt: link.lastActivityAt, + preferred: true, + }); + restored += 1; + yield* Effect.logInfo("Rehydrate bridge ensured", { + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + openStreamIds: link.streamDiscordMessageIds?.length ?? 0, + }); + }).pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + failed += 1; + const pretty = formatAlertCause(cause); + yield* Effect.logError("Rehydrate bridge ensure failed", { + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + cause: pretty, + }); + yield* postFatalAlert( + `rehydrate:${link.discordThreadId}`, + "Bridge rehydrate failed", + `source=\`${source}\` channel=\`${link.discordThreadId}\` thread=\`${link.t3ThreadId}\`\n${pretty}`, + { threadId: link.t3ThreadId, channelId: link.discordThreadId }, + ); + }).pipe(Effect.asVoid), + ), + ), + { concurrency: 4 }, + ); + + const finalStats: RehydrateStats = { + ...stats, + restored, + failed, + }; + yield* Effect.logInfo("Discord bridge rehydrate finished", { + source, + ...finalStats, + }); + return finalStats; + }); diff --git a/apps/discord-bot/src/features/ThreadTalkPolicy.test.ts b/apps/discord-bot/src/features/ThreadTalkPolicy.test.ts new file mode 100644 index 000000000000..8a04ad4cdc13 --- /dev/null +++ b/apps/discord-bot/src/features/ThreadTalkPolicy.test.ts @@ -0,0 +1,64 @@ +import { ProjectId, ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import type { ThreadLink } from "../store/ThreadLinkStore.ts"; +import { + formatUnmentionedDiscordPrompt, + parseThreadTalkCommand, + threadTalkEnabled, +} from "./ThreadTalkPolicy.ts"; + +const link = (threadTalkMode?: "all-messages"): ThreadLink => ({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadId.make("thread-1"), + projectId: ProjectId.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + updatedAt: "2026-07-18T00:00:00.000Z", + lastActivityAt: "2026-07-18T00:00:00.000Z", + status: "active", + lastSeenTurnId: null, + lastFinalizedAssistantId: null, + lastThreadSnapshotSequence: null, + lastDeliveredSequence: null, + ...(threadTalkMode === undefined ? {} : { threadTalkMode }), +}); + +describe("parseThreadTalkCommand", () => { + it("parses exact on, off, and status commands", () => { + expect(parseThreadTalkCommand("thread-talk on")).toEqual({ kind: "set", enabled: true }); + expect(parseThreadTalkCommand(" THREAD-TALK OFF ")).toEqual({ + kind: "set", + enabled: false, + }); + expect(parseThreadTalkCommand("thread-talk status")).toEqual({ kind: "status" }); + }); + + it("does not consume ordinary prompts containing the command words", () => { + expect(parseThreadTalkCommand("please turn thread-talk on")).toBeNull(); + expect(parseThreadTalkCommand("thread-talk on and check this")).toBeNull(); + }); +}); + +describe("threadTalkEnabled", () => { + it("is disabled for absent and legacy links", () => { + expect(threadTalkEnabled(null)).toBe(false); + expect(threadTalkEnabled(link())).toBe(false); + }); + + it("is enabled only for all-messages links", () => { + expect(threadTalkEnabled(link("all-messages"))).toBe(true); + }); +}); + +it("labels unmentioned prompts with Discord author and message context", () => { + expect( + formatUnmentionedDiscordPrompt({ + content: "check the failing build", + authorId: "user-1", + authorName: "Pat", + messageId: "message-1", + }), + ).toBe("Discord message from Pat (user user-1, message message-1):\n\ncheck the failing build"); +}); diff --git a/apps/discord-bot/src/features/ThreadTalkPolicy.ts b/apps/discord-bot/src/features/ThreadTalkPolicy.ts new file mode 100644 index 000000000000..571b828c51b2 --- /dev/null +++ b/apps/discord-bot/src/features/ThreadTalkPolicy.ts @@ -0,0 +1,30 @@ +import type { ThreadLink } from "../store/ThreadLinkStore.ts"; + +export type ThreadTalkCommand = + | { readonly kind: "set"; readonly enabled: boolean } + | { readonly kind: "status" }; + +export function parseThreadTalkCommand(raw: string): ThreadTalkCommand | null { + const normalized = raw.trim().replace(/\s+/gu, " ").toLocaleLowerCase(); + if (normalized === "thread-talk on") return { kind: "set", enabled: true }; + if (normalized === "thread-talk off") return { kind: "set", enabled: false }; + if (normalized === "thread-talk status") return { kind: "status" }; + return null; +} + +export function threadTalkEnabled(link: ThreadLink | null): boolean { + return link?.threadTalkMode === "all-messages"; +} + +export function formatUnmentionedDiscordPrompt(input: { + readonly content: string; + readonly authorId: string; + readonly authorName: string; + readonly messageId: string; +}): string { + return [ + `Discord message from ${input.authorName} (user ${input.authorId}, message ${input.messageId}):`, + "", + input.content, + ].join("\n"); +} diff --git a/apps/discord-bot/src/identityMap.test.ts b/apps/discord-bot/src/identityMap.test.ts new file mode 100644 index 000000000000..71f02b2ae561 --- /dev/null +++ b/apps/discord-bot/src/identityMap.test.ts @@ -0,0 +1,271 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { describe, expect, it } from "vite-plus/test"; + +import { + loadIdentityMapFromFileSync, + makeRefreshingIdentityMapStore, + parseIdentityMapDocument, + parseSimpleIdentityYaml, + classifyDiscordAgentAccess, + resolveParticipantIdentity, +} from "./identityMap.ts"; + +describe("parseIdentityMapDocument", () => { + it("parses people array with nested identities", () => { + const people = parseIdentityMapDocument({ + people: [ + { + name: "Patrick Roza", + discord: { id: "95218063095377920", username: "patroza" }, + github: { login: "patroza", id: "12345" }, + jira: { accountId: "712020:abc", email: "patrick@example.com" }, + }, + ], + }); + expect(people).toEqual([ + { + name: "Patrick Roza", + discord: { id: "95218063095377920", username: "patroza" }, + github: { login: "patroza", id: "12345" }, + jira: { accountId: "712020:abc", email: "patrick@example.com" }, + }, + ]); + }); + + it("parses people map keyed by discord id with flat fields", () => { + const people = parseIdentityMapDocument({ + people: { + "95218063095377920": { + name: "Patrick Roza", + githubLogin: "patroza", + githubId: "12345", + }, + }, + }); + expect(people[0]?.discord?.id).toBe("95218063095377920"); + expect(people[0]?.github?.login).toBe("patroza"); + expect(people[0]?.github?.id).toBe("12345"); + }); + + it("parses top-level map keyed by discord id", () => { + const people = parseIdentityMapDocument({ + "111": { name: "Davide", githubLogin: "davide", githubId: "9" }, + }); + expect(people).toHaveLength(1); + expect(people[0]?.name).toBe("Davide"); + expect(people[0]?.discord?.id).toBe("111"); + }); + + it("rejects entries without name", () => { + expect(() => + parseIdentityMapDocument({ + people: [{ discord: { id: "1" }, github: { login: "x" } }], + }), + ).toThrow(/name/i); + }); +}); + +describe("parseSimpleIdentityYaml", () => { + it("parses people block with nested fields", () => { + const doc = parseSimpleIdentityYaml(` +# comment +people: + "95218063095377920": + name: Patrick Roza + githubLogin: patroza + githubId: "12345" + jiraAccountId: 712020:abc +`); + const people = parseIdentityMapDocument(doc); + expect(people).toHaveLength(1); + expect(people[0]?.name).toBe("Patrick Roza"); + expect(people[0]?.discord?.id).toBe("95218063095377920"); + expect(people[0]?.github?.login).toBe("patroza"); + expect(people[0]?.github?.id).toBe("12345"); + expect(people[0]?.jira?.accountId).toBe("712020:abc"); + }); +}); + +describe("resolveParticipantIdentity", () => { + const people = parseIdentityMapDocument({ + people: [ + { + name: "Patrick Roza", + discord: { id: "95218063095377920", username: "patroza" }, + github: { login: "patroza", id: "12345" }, + }, + { + name: "Davide", + discord: { id: "222", username: "davide" }, + github: { login: "davide", id: "99" }, + }, + ], + }); + + it("resolves by discord id", () => { + const resolved = resolveParticipantIdentity({ + role: "requester", + discordId: "95218063095377920", + discordUsername: "patroza", + discordDisplayName: "Patrick Roza", + people, + }); + expect(resolved.person?.name).toBe("Patrick Roza"); + }); + + it("marks unmapped users", () => { + const resolved = resolveParticipantIdentity({ + role: "requester", + discordId: "999", + people, + }); + expect(resolved.person).toBeNull(); + expect(resolved.unmappedReason).toContain("not present"); + }); + + it("fail-closes Discord agent access when the map is empty", () => { + const denied = classifyDiscordAgentAccess({ + people: [], + discordId: "95218063095377920", + }); + expect(denied.allowed).toBe(false); + if (!denied.allowed) { + expect(denied.reason).toBe("identity_map_empty"); + expect(denied.userMessage.toLowerCase()).toContain("not authorized"); + } + }); + + it("allows mapped Discord requesters and denies unmapped ones", () => { + const allowed = classifyDiscordAgentAccess({ + people, + discordId: "95218063095377920", + discordUsername: "patroza", + }); + expect(allowed.allowed).toBe(true); + if (allowed.allowed) expect(allowed.person.name).toBe("Patrick Roza"); + + const denied = classifyDiscordAgentAccess({ + people, + discordId: "999", + discordUsername: "stranger", + }); + expect(denied.allowed).toBe(false); + if (!denied.allowed) expect(denied.reason).toBe("unmapped_discord_actor"); + }); +}); + +describe("loadIdentityMapFromFileSync", () => { + it("loads JSON files", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-identity-")); + const path = NodePath.join(dir, "identity-map.json"); + await NodeFSP.writeFile( + path, + JSON.stringify({ + people: [ + { + name: "A", + discord: { id: "1" }, + github: { login: "a", id: "2" }, + }, + ], + }), + "utf8", + ); + const people = loadIdentityMapFromFileSync(path); + expect(people).toHaveLength(1); + expect(people[0]?.github?.login).toBe("a"); + }); + + it("loads YAML files", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-identity-")); + const path = NodePath.join(dir, "identity-map.yaml"); + await NodeFSP.writeFile( + path, + `people: + "1": + name: A + githubLogin: a + githubId: "2" +`, + "utf8", + ); + const people = loadIdentityMapFromFileSync(path); + expect(people[0]?.discord?.id).toBe("1"); + expect(people[0]?.github?.id).toBe("2"); + }); +}); + +describe("makeRefreshingIdentityMapStore", () => { + it("reloads after the TTL expires and keeps the prior map on load failure", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-identity-ttl-")); + const path = NodePath.join(dir, "identity-map.json"); + await NodeFSP.writeFile( + path, + JSON.stringify({ + people: [ + { + name: "A", + discord: { id: "1" }, + github: { login: "a", id: "11" }, + }, + ], + }), + "utf8", + ); + + let now = 1_000_000; + let loads = 0; + const store = makeRefreshingIdentityMapStore({ + filePath: path, + ttlMs: 60_000, + now: () => now, + load: (p) => { + loads += 1; + return loadIdentityMapFromFileSync(p); + }, + }); + + expect(store.list()).toHaveLength(1); + expect(store.resolveByDiscordId("1")?.name).toBe("A"); + expect(loads).toBe(1); + + // Within TTL — no reload + now += 30_000; + expect(store.list()).toHaveLength(1); + expect(loads).toBe(1); + + // After TTL — pick up new file contents + await NodeFSP.writeFile( + path, + JSON.stringify({ + people: [ + { + name: "A", + discord: { id: "1" }, + github: { login: "a", id: "11" }, + }, + { + name: "Davide Di Pumpo", + discord: { id: "150802733316702208" }, + github: { login: "MakhBeth", id: "2373426" }, + }, + ], + }), + "utf8", + ); + now += 60_000; + expect(store.list()).toHaveLength(2); + expect(store.resolveByDiscordId("150802733316702208")?.github?.login).toBe("MakhBeth"); + expect(loads).toBe(2); + + // Corrupt file after TTL — keep last good snapshot + await NodeFSP.writeFile(path, "{ not valid json", "utf8"); + now += 60_000; + expect(store.list()).toHaveLength(2); + expect(store.resolveByDiscordId("150802733316702208")?.name).toBe("Davide Di Pumpo"); + expect(loads).toBe(3); + }); +}); diff --git a/apps/discord-bot/src/identityMap.ts b/apps/discord-bot/src/identityMap.ts new file mode 100644 index 000000000000..7264cdac75b8 --- /dev/null +++ b/apps/discord-bot/src/identityMap.ts @@ -0,0 +1,613 @@ +// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off tryCatchInEffectGen:off +/** + * Operator-maintained canonical map across Discord, Jira, and GitHub identities. + * + * Loaded once at bot startup from T3_IDENTITY_MAP_PATH (same delivery path as + * project-aliases: staged secrets share). Absent path → empty map (feature off). + */ +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; + +export interface DiscordIdentityRef { + readonly id: string; + readonly username?: string | undefined; +} + +export interface GitHubIdentityRef { + /** GitHub login (without @). */ + readonly login: string; + /** Numeric GitHub user id as a decimal string. */ + readonly id?: string | undefined; + /** Explicit GitHub email retained in the shared identity document. */ + readonly email?: string | undefined; + /** Optional GitHub display name. */ + readonly name?: string | undefined; +} + +export interface JiraIdentityRef { + readonly accountId?: string | undefined; + readonly email?: string | undefined; + readonly displayName?: string | undefined; +} + +export interface PersonIdentity { + /** Human display name. */ + readonly name: string; + readonly discord?: DiscordIdentityRef | undefined; + readonly github?: GitHubIdentityRef | undefined; + readonly jira?: JiraIdentityRef | undefined; +} + +export class IdentityMapLoadError extends Schema.TaggedError()( + "IdentityMapLoadError", + { + path: Schema.String, + message: Schema.String, + }, +) {} + +const isIdentityMapLoadError = Schema.is(IdentityMapLoadError); + +function expandHomePath(value: string): string { + if (!value) return value; + if (value === "~") return NodeOS.homedir(); + if (value.startsWith("~/") || value.startsWith("~\\")) { + return NodePath.join(NodeOS.homedir(), value.slice(2)); + } + return value; +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function asNonEmptyString(value: unknown): string | undefined { + if (typeof value !== "string") return undefined; + const trimmed = value.trim(); + return trimmed.length > 0 ? trimmed : undefined; +} + +function asDiscordSnowflake(value: unknown): string | undefined { + const raw = asNonEmptyString(value); + if (raw === undefined) return undefined; + // Discord snowflakes are decimal digit strings (typically 17–19 digits). + // Accept any pure digit id so fixtures and short local maps still load. + if (!/^\d{1,32}$/u.test(raw)) return undefined; + return raw; +} + +function normalizeLogin(value: unknown): string | undefined { + const raw = asNonEmptyString(value); + if (raw === undefined) return undefined; + const login = raw.replace(/^@/u, "").trim(); + if (login.length === 0) return undefined; + // GitHub login: alphanumeric / hyphen, max 39. + if (!/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/u.test(login)) return undefined; + return login; +} + +function parsePerson(raw: unknown, indexLabel: string): PersonIdentity { + if (!isRecord(raw)) { + throw new Error(`Identity map entry ${indexLabel} must be an object.`); + } + + const name = asNonEmptyString(raw.name); + if (name === undefined) { + throw new Error(`Identity map entry ${indexLabel} is missing a non-empty "name".`); + } + + // Nested form: { discord: { id }, github: { login, id, email }, jira: {...} } + // Flat form: { discordId, discordUsername, githubLogin, githubId, githubEmail, jiraAccountId, jiraEmail } + const discordNested = isRecord(raw.discord) ? raw.discord : undefined; + const githubNested = isRecord(raw.github) ? raw.github : undefined; + const jiraNested = isRecord(raw.jira) ? raw.jira : undefined; + + const discordId = + asDiscordSnowflake(discordNested?.id) ?? + asDiscordSnowflake(raw.discordId) ?? + asDiscordSnowflake(raw.discord_id); + const discordUsername = + asNonEmptyString(discordNested?.username) ?? + asNonEmptyString(raw.discordUsername) ?? + asNonEmptyString(raw.discord_username); + + const githubLogin = + normalizeLogin(githubNested?.login) ?? + normalizeLogin(raw.githubLogin) ?? + normalizeLogin(raw.github_login) ?? + normalizeLogin(raw.github); + const githubId = + asNonEmptyString(githubNested?.id)?.replace(/\D/gu, "") || + asNonEmptyString(raw.githubId)?.replace(/\D/gu, "") || + asNonEmptyString(raw.github_id)?.replace(/\D/gu, "") || + undefined; + const githubEmail = + asNonEmptyString(githubNested?.email) ?? + asNonEmptyString(raw.githubEmail) ?? + asNonEmptyString(raw.github_email); + const githubName = + asNonEmptyString(githubNested?.name) ?? + asNonEmptyString(raw.githubName) ?? + asNonEmptyString(raw.github_name); + + const jiraAccountId = + asNonEmptyString(jiraNested?.accountId) ?? + asNonEmptyString(raw.jiraAccountId) ?? + asNonEmptyString(raw.jira_account_id); + const jiraEmail = + asNonEmptyString(jiraNested?.email) ?? + asNonEmptyString(raw.jiraEmail) ?? + asNonEmptyString(raw.jira_email); + const jiraDisplayName = + asNonEmptyString(jiraNested?.displayName) ?? + asNonEmptyString(raw.jiraDisplayName) ?? + asNonEmptyString(raw.jira_display_name); + + if (discordId === undefined && githubLogin === undefined && jiraAccountId === undefined) { + throw new Error( + `Identity map entry ${indexLabel} ("${name}") needs at least one of discord.id, github.login, or jira.accountId.`, + ); + } + + return { + name, + ...(discordId !== undefined + ? { + discord: { + id: discordId, + ...(discordUsername !== undefined ? { username: discordUsername } : {}), + }, + } + : {}), + ...(githubLogin !== undefined + ? { + github: { + login: githubLogin, + ...(githubId !== undefined && githubId.length > 0 ? { id: githubId } : {}), + ...(githubEmail !== undefined ? { email: githubEmail } : {}), + ...(githubName !== undefined ? { name: githubName } : {}), + }, + } + : {}), + ...(jiraAccountId !== undefined || jiraEmail !== undefined + ? { + jira: { + ...(jiraAccountId !== undefined ? { accountId: jiraAccountId } : {}), + ...(jiraEmail !== undefined ? { email: jiraEmail } : {}), + ...(jiraDisplayName !== undefined ? { displayName: jiraDisplayName } : {}), + }, + } + : {}), + }; +} + +/** + * Parse identity map document (JSON object). + * + * Accepted shapes: + * - `{ "people": [ { name, discord, github, jira }, ... ] }` + * - `{ "people": { "": { name, githubLogin, ... }, ... } }` + * - `{ "": { name, githubLogin, ... }, ... }` (top-level map, no people key) + */ +export function parseIdentityMapDocument(document: unknown): ReadonlyArray { + if (document === null || document === undefined) return []; + if (!isRecord(document)) { + throw new Error("Identity map root must be an object."); + } + + const peopleNode = document.people; + if (Array.isArray(peopleNode)) { + return peopleNode.map((entry, index) => parsePerson(entry, `[${index}]`)); + } + + if (isRecord(peopleNode)) { + return Object.entries(peopleNode).map(([key, value]) => { + if (!isRecord(value)) { + throw new Error(`Identity map people["${key}"] must be an object.`); + } + // If the key is a snowflake and the object omitted discordId, inject it. + const withDiscord = + asDiscordSnowflake(key) !== undefined && asDiscordSnowflake(value.discordId) === undefined + ? { ...value, discordId: key } + : value; + return parsePerson(withDiscord, `people["${key}"]`); + }); + } + + // Top-level map keyed by discord id (when no people key). + const reserved = new Set(["version", "schema", "$schema"]); + const entries = Object.entries(document).filter(([key]) => !reserved.has(key)); + if (entries.length === 0) return []; + + return entries.map(([key, value]) => { + if (!isRecord(value)) { + throw new Error(`Identity map["${key}"] must be an object.`); + } + const withDiscord = + asDiscordSnowflake(key) !== undefined && asDiscordSnowflake(value.discordId) === undefined + ? { ...value, discordId: key } + : value; + return parsePerson(withDiscord, `["${key}"]`); + }); +} + +/** + * Minimal YAML → JSON-ish object for the identity map shapes we document. + * Prefer JSON for complex nesting; this covers the flat keyed form used in ops. + * + * Supports: + * ```yaml + * people: + * "123": + * name: Alice + * githubLogin: alice + * githubId: "99" + * ``` + * and top-level keyed people without a `people:` wrapper. + */ +export function parseSimpleIdentityYaml(raw: string): unknown { + const lines = raw.split(/\r?\n/); + const root: Record> = {}; + let inPeople = false; + let currentKey: string | null = null; + + for (const line of lines) { + const trimmed = line.trim(); + if (trimmed.length === 0 || trimmed.startsWith("#")) continue; + + if (/^people:\s*$/u.test(trimmed)) { + inPeople = true; + continue; + } + + // Nested field under a person key (2+ spaces). + const fieldMatch = /^(\s{2,})([A-Za-z][A-Za-z0-9_]*)\s*:\s*(.*)$/u.exec(line); + if (fieldMatch && currentKey !== null) { + const field = fieldMatch[2]!; + const value = stripYamlScalar(fieldMatch[3] ?? ""); + root[currentKey] = { ...root[currentKey], [field]: value }; + continue; + } + + // Person key at indent 0 or under people: (2 spaces): `"id":` or `id:` + const keyMatch = /^(\s{0,2})(?:"(\d+)"|'(\d+)'|(\d+)|([A-Za-z0-9_-]+))\s*:\s*$/u.exec(line); + if (keyMatch) { + const indent = keyMatch[1] ?? ""; + if (inPeople && indent.length === 0) { + // top-level key after people block ended — treat as new top-level person + } + const key = keyMatch[2] ?? keyMatch[3] ?? keyMatch[4] ?? keyMatch[5] ?? null; + if (key === null || key === "people") continue; + currentKey = key; + root[currentKey] = { ...root[currentKey] }; + continue; + } + + // Inline single-line `key: value` at root (unusual for this schema) + const inlineMatch = /^([A-Za-z0-9_-]+|"\d+"|'\d+'|\d+)\s*:\s+(.+)$/u.exec(trimmed); + if (inlineMatch && currentKey === null) { + continue; + } + } + + if (Object.keys(root).length === 0) { + return { people: [] }; + } + return { people: root }; +} + +function stripYamlScalar(value: string): string { + const trimmed = value.trim(); + if ( + (trimmed.startsWith('"') && trimmed.endsWith('"')) || + (trimmed.startsWith("'") && trimmed.endsWith("'")) + ) { + return trimmed.slice(1, -1); + } + // Strip inline comments for simple scalars. + const hash = trimmed.search(/\s+#/u); + return hash >= 0 ? trimmed.slice(0, hash).trim() : trimmed; +} + +export function loadIdentityMapFromFileSync(filePath: string): ReadonlyArray { + const resolvedPath = NodePath.resolve(expandHomePath(filePath.trim())); + if (!NodeFS.existsSync(resolvedPath)) { + throw new IdentityMapLoadError({ + path: resolvedPath, + message: `Identity map file not found: ${resolvedPath}`, + }); + } + + const raw = NodeFS.readFileSync(resolvedPath, "utf8"); + const trimmed = raw.trim(); + if (trimmed.length === 0) return []; + + let document: unknown; + try { + if (resolvedPath.endsWith(".json")) { + document = JSON.parse(trimmed) as unknown; + } else { + // YAML: try JSON-compatible first (JSON is valid YAML subset for our shapes). + try { + document = JSON.parse(trimmed) as unknown; + } catch { + document = parseSimpleIdentityYaml(trimmed); + } + } + } catch (cause) { + throw new IdentityMapLoadError({ + path: resolvedPath, + message: cause instanceof Error ? cause.message : String(cause), + }); + } + + try { + return parseIdentityMapDocument(document); + } catch (cause) { + throw new IdentityMapLoadError({ + path: resolvedPath, + message: cause instanceof Error ? cause.message : String(cause), + }); + } +} + +export type ResolvedParticipantIdentity = { + readonly role: "requester" | "thread_starter" | "other"; + readonly discordId: string | null; + readonly discordUsername: string | null; + readonly discordDisplayName: string | null; + readonly person: PersonIdentity | null; + readonly unmappedReason: string | null; +}; + +export function resolveParticipantIdentity(input: { + readonly role: ResolvedParticipantIdentity["role"]; + readonly discordId?: string | null | undefined; + readonly discordUsername?: string | null | undefined; + readonly discordDisplayName?: string | null | undefined; + readonly people: ReadonlyArray; +}): ResolvedParticipantIdentity { + const discordId = input.discordId?.trim() || null; + const discordUsername = input.discordUsername?.trim() || null; + const discordDisplayName = input.discordDisplayName?.trim() || null; + + let person: PersonIdentity | null = null; + if (discordId !== null) { + person = input.people.find((p) => p.discord?.id === discordId) ?? null; + } + if (person === null && discordUsername !== null) { + const lowered = discordUsername.toLowerCase(); + person = input.people.find((p) => p.discord?.username?.toLowerCase() === lowered) ?? null; + } + + if (person === null) { + return { + role: input.role, + discordId, + discordUsername, + discordDisplayName, + person: null, + unmappedReason: + discordId === null && discordUsername === null + ? "no discord identity on message" + : "not present in identity map", + }; + } + + return { + role: input.role, + discordId, + discordUsername, + discordDisplayName, + person, + unmappedReason: null, + }; +} + +export type DiscordAgentAccessDecision = + | { readonly allowed: true; readonly person: PersonIdentity } + | { + readonly allowed: false; + readonly reason: "identity_map_empty" | "unmapped_discord_actor" | "missing_discord_actor"; + /** Short user-facing Discord reply (no map jargon). */ + readonly userMessage: string; + }; + +/** + * Fail-closed agent gate for Discord requesters. + * + * - Empty / unloaded map → deny everyone (same as unmapped) + * - Requester Discord id/username not in map → deny + * - Mapped → allow + */ +export function classifyDiscordAgentAccess(input: { + readonly people: ReadonlyArray; + readonly discordId?: string | null | undefined; + readonly discordUsername?: string | null | undefined; + readonly discordDisplayName?: string | null | undefined; +}): DiscordAgentAccessDecision { + if (input.people.length === 0) { + return { + allowed: false, + reason: "identity_map_empty", + userMessage: + "You're not authorized to run agent work from Discord. An operator needs to configure the identity map before anyone can use the agent.", + }; + } + const resolved = resolveParticipantIdentity({ + role: "requester", + discordId: input.discordId, + discordUsername: input.discordUsername, + discordDisplayName: input.discordDisplayName, + people: input.people, + }); + if (resolved.person === null) { + const missingActor = + (input.discordId?.trim() ?? "") === "" && (input.discordUsername?.trim() ?? "") === ""; + return { + allowed: false, + reason: missingActor ? "missing_discord_actor" : "unmapped_discord_actor", + userMessage: + "You're not authorized to run agent work from Discord. Ask an operator to add your Discord account to the allowlist.", + }; + } + return { allowed: true, person: resolved.person }; +} + +export interface IdentityMapStoreService { + readonly list: () => ReadonlyArray; + readonly resolveByDiscordId: (discordId: string) => PersonIdentity | null; + readonly resolveByDiscordUsername: (username: string) => PersonIdentity | null; + readonly resolveParticipant: (input: { + readonly role: ResolvedParticipantIdentity["role"]; + readonly discordId?: string | null | undefined; + readonly discordUsername?: string | null | undefined; + readonly discordDisplayName?: string | null | undefined; + }) => ResolvedParticipantIdentity; +} + +export class IdentityMapStore extends Context.Service()( + "@t3tools/discord-bot/identityMap/IdentityMapStore", +) {} + +/** How long a loaded identity map stays hot before re-reading the file (no bot restart). */ +export const IDENTITY_MAP_CACHE_TTL_MS = 60_000; + +function indexesFromPeople(people: ReadonlyArray): { + readonly people: ReadonlyArray; + readonly byId: ReadonlyMap; + readonly byUsername: ReadonlyMap; +} { + const byId = new Map(); + const byUsername = new Map(); + for (const person of people) { + if (person.discord?.id !== undefined) { + byId.set(person.discord.id, person); + } + if (person.discord?.username !== undefined) { + byUsername.set(person.discord.username.toLowerCase(), person); + } + } + return { people, byId, byUsername }; +} + +export const makeIdentityMapStore = ( + people: ReadonlyArray, +): IdentityMapStoreService => { + const index = indexesFromPeople(people); + + return IdentityMapStore.of({ + list: () => index.people, + resolveByDiscordId: (discordId) => index.byId.get(discordId.trim()) ?? null, + resolveByDiscordUsername: (username) => + index.byUsername.get(username.trim().toLowerCase()) ?? null, + resolveParticipant: (input) => + resolveParticipantIdentity({ + role: input.role, + discordId: input.discordId, + discordUsername: input.discordUsername, + discordDisplayName: input.discordDisplayName, + people: index.people, + }), + }); +}; + +/** + * File-backed identity map with a short TTL cache so operators can edit + * identity-map.yaml without restarting the Discord bot. + * + * - Eager-loads once at construction (throws on first failure). + * - Re-reads the file at most every `ttlMs` (default 60s) on access. + * - On later load failures, keeps the last good snapshot and waits another TTL. + */ +export function makeRefreshingIdentityMapStore(input: { + readonly filePath: string; + readonly ttlMs?: number; + readonly now?: () => number; + readonly load?: (path: string) => ReadonlyArray; + /** Optional hook when a reload succeeds (for tests / diagnostics). */ + readonly onReload?: (people: ReadonlyArray) => void; +}): IdentityMapStoreService { + const ttlMs = input.ttlMs ?? IDENTITY_MAP_CACHE_TTL_MS; + // @effect-diagnostics-next-line globalDate:off + const now = input.now ?? (() => Date.now()); + const load = input.load ?? loadIdentityMapFromFileSync; + const path = input.filePath.trim(); + + let index = indexesFromPeople(load(path)); + let loadedAt = now(); + input.onReload?.(index.people); + + const refreshIfStale = () => { + const t = now(); + if (t - loadedAt < ttlMs) return; + try { + const nextPeople = load(path); + index = indexesFromPeople(nextPeople); + loadedAt = t; + input.onReload?.(index.people); + } catch { + // Keep serving the last good map; delay the next retry by a full TTL. + loadedAt = t; + } + }; + + return IdentityMapStore.of({ + list: () => { + refreshIfStale(); + return index.people; + }, + resolveByDiscordId: (discordId) => { + refreshIfStale(); + return index.byId.get(discordId.trim()) ?? null; + }, + resolveByDiscordUsername: (username) => { + refreshIfStale(); + return index.byUsername.get(username.trim().toLowerCase()) ?? null; + }, + resolveParticipant: (participant) => { + refreshIfStale(); + return resolveParticipantIdentity({ + role: participant.role, + discordId: participant.discordId, + discordUsername: participant.discordUsername, + discordDisplayName: participant.discordDisplayName, + people: index.people, + }); + }, + }); +} + +export const layerFromOptionalPath = (filePath: string | undefined) => + Layer.effect( + IdentityMapStore, + Effect.gen(function* () { + if (filePath === undefined || filePath.trim().length === 0) { + yield* Effect.logInfo( + "T3_IDENTITY_MAP_PATH is unset; Discord identity authorization is unavailable until configured.", + ); + return makeIdentityMapStore([]); + } + const resolvedPath = filePath.trim(); + const store = yield* Effect.try({ + try: () => makeRefreshingIdentityMapStore({ filePath: resolvedPath }), + catch: (cause) => { + if (isIdentityMapLoadError(cause)) return cause; + return new IdentityMapLoadError({ + path: resolvedPath, + message: cause instanceof Error ? cause.message : String(cause), + }); + }, + }); + const count = store.list().length; + yield* Effect.logInfo( + `Loaded ${count} identity map entr${count === 1 ? "y" : "ies"} from ${resolvedPath} (reload TTL ${IDENTITY_MAP_CACHE_TTL_MS / 1000}s)`, + ); + return store; + }), + ); diff --git a/apps/discord-bot/src/main.ts b/apps/discord-bot/src/main.ts new file mode 100644 index 000000000000..ae1e4824c6e2 --- /dev/null +++ b/apps/discord-bot/src/main.ts @@ -0,0 +1,195 @@ +// @effect-diagnostics globalDate:off globalFetch:off globalTimers:off globalErrorInEffectCatch:off globalErrorInEffectFailure:off anyUnknownInErrorContext:off missingEffectContext:off missingEffectError:off preferSchemaOverJson:off tryCatchInEffectGen:off missingReturnYieldStar:off layerMergeAllWithDependencies:off unsafeEffectTypeAssertion:off +import { NodeRuntime } from "@effect/platform-node"; +import * as Config from "effect/Config"; +import * as ConfigProvider from "effect/ConfigProvider"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Logger from "effect/Logger"; +import * as Option from "effect/Option"; +import { FetchHttpClient } from "effect/unstable/http"; +import { OtlpSerialization, OtlpTracer } from "effect/unstable/observability"; + +import { DiscordBotConfig } from "./config.ts"; +import { makeDiscordLayer } from "./discord/DiscordLive.ts"; +import { runAlertWatchdog } from "./features/Alerts.ts"; +import { layer as bridgeHubLayer } from "./features/BridgeHub.ts"; +import { DiscordBotRunning, MentionRouterLive } from "./features/MentionRouter.ts"; +import { runBridge } from "./features/ResponseBridge.ts"; +import { runTeamsModule } from "./features/TeamsModule.ts"; +import { runTeamsNativeApp } from "./features/TeamsNativeApp.ts"; +import { backfillThreadInfoPins } from "./features/ThreadInfoPin.ts"; +import { rehydrateBridges } from "./features/ThreadRestore.ts"; +import { layerFromOptionalPath as identityMapStoreLayer, IdentityMapStore } from "./identityMap.ts"; +import { + layerFromOptionalPath as projectAliasStoreLayer, + ProjectAliasStore, +} from "./projectAliases.ts"; +import { layer as teamsSeenStoreLayer } from "./store/TeamsSeenStore.ts"; +import { layer as threadLinkStoreLayer } from "./store/ThreadLinkStore.ts"; +import { layer as threadWarmCacheStoreLayer } from "./store/ThreadWarmCacheStore.ts"; +import { T3Session, layer as t3SessionLayer } from "./t3/T3Session.ts"; + +const BotObservabilityLive = Layer.unwrap( + Effect.gen(function* () { + const tracesUrl = yield* Config.option(Config.nonEmptyString("T3CODE_OTLP_TRACES_URL")); + return Option.match(tracesUrl, { + onNone: () => Layer.empty, + onSome: (url) => + OtlpTracer.layer({ + url, + resource: { + serviceName: "t3-discord-bot", + attributes: { + "service.runtime": "discord-bot", + }, + }, + }).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer)), + }); + }), +).pipe(Layer.provide(ConfigProvider.layer(ConfigProvider.fromEnv()))); + +/** + * Build layers so MentionRouter is a *required* dependency of the program + * (via DiscordBotRunning). effectDiscard-only layers can be pruned when + * nothing in the program Effect requires them. + */ +const MainLayer = Layer.unwrap( + Effect.gen(function* () { + const botConfig = yield* DiscordBotConfig; + const discordToken = botConfig.discordToken; + if (discordToken === undefined) { + return yield* Effect.die( + new Error( + "DISCORD_BOT_TOKEN is required by the Discord entrypoint. Use start:teams for Teams-only deployments.", + ), + ); + } + const discord = makeDiscordLayer(discordToken); + const bridgeHub = bridgeHubLayer(runBridge); + const core = Layer.mergeAll( + t3SessionLayer(botConfig), + threadLinkStoreLayer(botConfig.dataDir), + teamsSeenStoreLayer(botConfig.dataDir), + threadWarmCacheStoreLayer(botConfig.dataDir), + projectAliasStoreLayer(botConfig.projectAliasesPath), + identityMapStoreLayer(botConfig.identityMapPath), + bridgeHub, + ).pipe(Layer.provideMerge(discord)); + + const router = MentionRouterLive(botConfig).pipe(Layer.provide(core)); + + // Router first so DiscordBotRunning is provided; core+discord still available. + return router.pipe( + Layer.provideMerge(core), + Layer.provideMerge(discord), + Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromEnv())), + Layer.provideMerge(Logger.layer([Logger.consolePretty()])), + ); + }), +).pipe(Layer.provide(ConfigProvider.layer(ConfigProvider.fromEnv()))); + +const program = Effect.gen(function* () { + const botConfig = yield* DiscordBotConfig; + yield* Effect.logInfo("Starting T3 Discord bot", { + t3HttpBaseUrl: botConfig.t3HttpBaseUrl, + dataDir: botConfig.dataDir, + projectAliasesPath: botConfig.projectAliasesPath ?? "(unset)", + identityMapPath: botConfig.identityMapPath ?? "(unset)", + alertProcessRulesPath: botConfig.alertProcessRulesPath ?? "(unset)", + }); + + // Force acquisition of MentionRouter + Discord gateway (must not be pruned). + // Discord can become READY before guest T3 is listening — that is expected on + // restart. Mentions that land early wait (⏳) until the shell is ready. + const running = yield* DiscordBotRunning; + yield* Effect.logInfo("Discord gateway active", { botUserId: running.botUserId }); + + const t3 = yield* T3Session; + + // Capture ambient services so T3 auto-reconnect can rehydrate Discord bridges. + // Register before connectUntilReady so a drop immediately after first success + // still rehydrates. provideContext erases R at runtime; cast so Effect.runPromise + // accepts the program. (setOnReconnected is a Promise callback outside the Effect + // runtime, so runPromise is intentional.) + const services = yield* Effect.context(); + t3.setOnReconnected(() => + // @effect-diagnostics-next-line runEffectInsideEffect:off + Effect.runPromise( + rehydrateBridges("reconnect").pipe( + Effect.provideContext(services), + Effect.catchCause((cause) => + Effect.logError("Reconnect rehydrate failed").pipe( + Effect.andThen(Effect.logError(cause)), + ), + ), + Effect.asVoid, + ) as Effect.Effect, + ), + ); + + // Retry forever until shell is ready — do not exit the process when T3 is late. + yield* t3.connectUntilReady(); + const aliasStore = yield* ProjectAliasStore; + const identityStore = yield* IdentityMapStore; + yield* Effect.logInfo( + `Connected to T3; bot project aliases=${aliasStore.list().length}; identity map entries=${identityStore.list().length}`, + ); + + // Restore running/pending bridges + catch-up finalize for open stream tips. + // Without this, mid-turn Discord threads go silent until a human @mentions again. + yield* rehydrateBridges("boot").pipe( + Effect.catchCause((cause) => + Effect.logError("Boot rehydrate failed").pipe(Effect.andThen(Effect.logError(cause))), + ), + ); + + // Backfill pinned thread-info messages (Model / Open in Omegent / Jira links) for active links. + yield* backfillThreadInfoPins(botConfig).pipe( + Effect.catchCause((cause) => + Effect.logError("Thread info pin backfill failed").pipe( + Effect.andThen(Effect.logError(cause)), + ), + ), + ); + + // Guest ops alerts (load / mem / runaway Sentry MCP / long turns) → Discord channel. + // forkDetach: program Effect has no Scope (unlike Layer.effect fibers). + yield* Effect.forkDetach( + runAlertWatchdog(botConfig).pipe( + Effect.catchCause((cause) => + Effect.logError("Alert watchdog stopped").pipe(Effect.andThen(Effect.logError(cause))), + ), + ), + ); + if (botConfig.alertsChannelId) { + yield* Effect.logInfo("Discord ops alerts enabled", { + channelId: botConfig.alertsChannelId, + }); + } + + // Optional Teams Graph intake → Discord/T3 (off unless TEAMS_ENABLED=1). + yield* Effect.forkDetach( + runTeamsModule(botConfig).pipe( + Effect.catchCause((cause) => + Effect.logError("Teams module stopped").pipe(Effect.andThen(Effect.logError(cause))), + ), + ), + ); + + // Optional native Teams SDK endpoint. This can run beside Discord during migration. + yield* runTeamsNativeApp(botConfig).pipe( + Effect.catchCause((cause) => + Effect.logError("Native Teams app stopped").pipe(Effect.andThen(Effect.logError(cause))), + ), + ); + + // Keep process alive; router fibers are scoped to this layer lifetime. + return yield* Effect.never; +}); + +NodeRuntime.runMain( + program.pipe(Effect.provide(Layer.merge(MainLayer, BotObservabilityLive))) as Effect.Effect< + never, + unknown + >, +); diff --git a/apps/discord-bot/src/presentation/attachments.test.ts b/apps/discord-bot/src/presentation/attachments.test.ts new file mode 100644 index 000000000000..58eb4933064b --- /dev/null +++ b/apps/discord-bot/src/presentation/attachments.test.ts @@ -0,0 +1,117 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + appendT3DeepLinkToChunks, + attachmentKey, + buildStreamHistoryMarkdownText, + imageAttachmentsOf, + STREAM_HISTORY_MARKDOWN_NAME, + streamHistoryHasAdditionalContent, + unpostedAttachments, + withT3DeepLink, +} from "./attachments.ts"; + +describe("imageAttachmentsOf", () => { + it("filters to image attachments", () => { + const images = imageAttachmentsOf([ + { + type: "image", + id: "a1", + name: "shot.png", + mimeType: "image/png", + sizeBytes: 12, + }, + ]); + expect(images).toHaveLength(1); + expect(images[0]?.id).toBe("a1"); + }); + + it("returns empty for missing attachments", () => { + expect(imageAttachmentsOf(undefined)).toEqual([]); + expect(imageAttachmentsOf(null)).toEqual([]); + expect(imageAttachmentsOf([])).toEqual([]); + }); +}); + +describe("unpostedAttachments", () => { + it("skips already posted ids", () => { + const all = [ + { + type: "image" as const, + id: "a1", + name: "a.png", + mimeType: "image/png", + sizeBytes: 1, + }, + { + type: "image" as const, + id: "a2", + name: "b.png", + mimeType: "image/png", + sizeBytes: 1, + }, + ]; + expect(unpostedAttachments(all, ["a1"]).map((e) => e.id)).toEqual(["a2"]); + expect(attachmentKey(all)).toBe("a1,a2"); + }); +}); + +describe("streamHistoryHasAdditionalContent", () => { + it("is false when history equals the final message (no intermediate tips)", () => { + const body = "👍 Sounds good. Ping this thread anytime."; + expect(streamHistoryHasAdditionalContent(body, body)).toBe(false); + expect(streamHistoryHasAdditionalContent(` ${body}\n`, body)).toBe(false); + }); + + it("is false for empty or placeholder stream bodies", () => { + expect(streamHistoryHasAdditionalContent("", "final answer")).toBe(false); + expect(streamHistoryHasAdditionalContent(" \n", "final answer")).toBe(false); + expect(streamHistoryHasAdditionalContent("…", "final answer")).toBe(false); + }); + + it("is true when history has intermediate progress beyond the final answer", () => { + expect( + streamHistoryHasAdditionalContent( + "Checking PR…\n\n👍 Sounds good. Ping this thread anytime.", + "👍 Sounds good. Ping this thread anytime.", + ), + ).toBe(true); + }); +}); + +describe("buildStreamHistoryMarkdownText", () => { + it("archives non-empty stream text", () => { + const text = buildStreamHistoryMarkdownText("Working…\npartial answer"); + expect(text).not.toBeNull(); + expect(text).toContain("In-progress stream"); + expect(text).toContain("partial answer"); + expect(STREAM_HISTORY_MARKDOWN_NAME).toBe("stream-history.md"); + }); + + it("returns null for blank stream text", () => { + expect(buildStreamHistoryMarkdownText(" \n")).toBeNull(); + }); +}); + +describe("T3 deep link caption helpers", () => { + it("appends a short same-line T3 link on the stats footer", () => { + expect( + withT3DeepLink( + "_`grok-4.5` · effort high · 50s_", + "https://t3vm.tail86038f.ts.net/?thread=tid-1#message-msg-1", + ), + ).toBe( + "_`grok-4.5` · effort high · 50s_ · [T3](https://t3vm.tail86038f.ts.net/?thread=tid-1#message-msg-1)", + ); + expect(withT3DeepLink("Summary", null)).toBe("Summary"); + }); + + it("appends the link onto the last chunk without overflowing", () => { + const url = "https://t3vm.example/?thread=t#message-m"; + expect(appendT3DeepLinkToChunks(["hello"], url, 2000)).toEqual([`hello · [T3](${url})`]); + const almostFull = "x".repeat(1990); + const next = appendT3DeepLinkToChunks([almostFull], url, 2000); + expect(next).toHaveLength(2); + expect(next[1]).toBe(`[T3](${url})`); + }); +}); diff --git a/apps/discord-bot/src/presentation/attachments.ts b/apps/discord-bot/src/presentation/attachments.ts new file mode 100644 index 000000000000..a2c0a6503841 --- /dev/null +++ b/apps/discord-bot/src/presentation/attachments.ts @@ -0,0 +1,109 @@ +import type { ChatAttachment, ChatImageAttachment } from "@t3tools/contracts"; + +/** Discord allows up to 10 files per message. */ +export const DISCORD_MAX_FILES_PER_MESSAGE = 10; + +/** + * Filename for the archived in-progress stream (hidden after finalize). + * The final answer itself is posted as normal Discord message content. + */ +export const STREAM_HISTORY_MARKDOWN_NAME = "stream-history.md"; + +export function imageAttachmentsOf( + attachments: ReadonlyArray | null | undefined, +): ReadonlyArray { + if (attachments === undefined || attachments === null) return []; + return attachments.filter((entry): entry is ChatImageAttachment => entry.type === "image"); +} + +export function unpostedAttachments( + attachments: ReadonlyArray, + postedIds: ReadonlyArray, +): ReadonlyArray { + const posted = new Set(postedIds); + return attachments.filter((entry) => !posted.has(entry.id)); +} + +export function attachmentKey(attachments: ReadonlyArray): string { + return attachments.map((entry) => entry.id).join(","); +} + +/** + * True when the archived stream body has intermediate progress beyond the final answer. + * Skip `stream-history.md` when the tip body is empty/placeholder or equals the final post + * (single-bubble turns where message content already is the stream). + */ +export function streamHistoryHasAdditionalContent(historyText: string, finalText: string): boolean { + const history = historyText.trim(); + if (history === "" || history === "…") return false; + return history !== finalText.trim(); +} + +/** + * Archive the in-progress stream as markdown text for a real Discord file attachment. + * Final answer stays in Discord message content (chunked if needed). + */ +export function buildStreamHistoryMarkdownText(streamText: string): string | null { + const body = streamText.trimEnd(); + if (body.trim() === "") return null; + return [ + "# In-progress stream", + "", + "_Live tip updates from this turn (archived when the final answer was posted)._", + "", + body, + "", + ].join("\n"); +} + +/** @deprecated Use buildStreamHistoryMarkdownText + Discord multipart upload */ +export function buildStreamHistoryMarkdownFile(streamText: string): File | null { + const text = buildStreamHistoryMarkdownText(streamText); + if (text === null) return null; + return new File([text], STREAM_HISTORY_MARKDOWN_NAME, { + type: "text/markdown;charset=utf-8", + }); +} + +/** + * Append a compact T3 deep link on a Discord caption/chunk. + * Same-line ` · [T3](url)` — clickable Discord markdown, short label. + * Used on the stats footer of every final answer. + */ +export function withT3DeepLink(caption: string, t3Url: string | null | undefined): string { + const url = t3Url?.trim() ?? ""; + if (url === "") return caption; + const link = `[T3](${url})`; + const body = caption.trimEnd(); + if (body === "") return link; + return `${body} · ${link}`; +} + +/** + * Append a T3 deep link onto the last message chunk (the stats footer), + * respecting the Discord limit. Always used on finals when a URL is available. + * If the link would overflow the last chunk, emit it as its own trailing chunk. + */ +export function appendT3DeepLinkToChunks( + chunks: ReadonlyArray, + t3Url: string | null | undefined, + limit: number, +): string[] { + const url = t3Url?.trim() ?? ""; + if (url === "" || chunks.length === 0) return [...chunks]; + + const out = [...chunks]; + const lastIndex = out.length - 1; + const last = out[lastIndex] ?? ""; + const linked = withT3DeepLink(last, url); + if (linked.length <= limit) { + out[lastIndex] = linked; + return out; + } + + const solo = withT3DeepLink("", url); + if (solo.length <= limit) { + out.push(solo); + } + return out; +} diff --git a/apps/discord-bot/src/presentation/channelInfoPin.test.ts b/apps/discord-bot/src/presentation/channelInfoPin.test.ts new file mode 100644 index 000000000000..dc46b7496b6f --- /dev/null +++ b/apps/discord-bot/src/presentation/channelInfoPin.test.ts @@ -0,0 +1,157 @@ +import { ProviderInstanceId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + CHANNEL_INFO_PIN_MARKER, + DISCORD_MESSAGE_CONTENT_LIMIT, + renderChannelInfoPin, +} from "./channelInfoPin.ts"; +import { normalizeGitHubRemoteUrl } from "./githubLinks.ts"; + +describe("channel info pin helpers", () => { + it("normalizes GitHub SSH remotes", () => { + expect(normalizeGitHubRemoteUrl("git@github.com:pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + expect(normalizeGitHubRemoteUrl("ssh://git@github.com/pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + }); + + it("normalizes GitHub HTTPS remotes", () => { + expect(normalizeGitHubRemoteUrl("https://github.com/pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + }); + + it("rejects non-GitHub remotes", () => { + expect(normalizeGitHubRemoteUrl("https://gitlab.com/pingdotgg/t3code.git")).toBeNull(); + }); + + it("renders a fallback when the origin GitHub URL cannot be resolved", () => { + const rendered = renderChannelInfoPin({ + githubUrl: null, + workspaceRoot: "/tmp/t3code", + providers: [], + defaultModelSelection: null, + }); + + expect(rendered).toContain("GitHub: (unable to resolve origin GitHub URL)"); + expect(rendered).not.toContain("origin remote is not a GitHub repository"); + }); + + it("renders a stable pinned help message", () => { + const rendered = renderChannelInfoPin({ + githubUrl: "https://github.com/pingdotgg/t3code", + workspaceRoot: "/tmp/t3code", + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + enabled: true, + installed: true, + status: "ready", + availability: "available", + models: [ + { slug: "gpt-5.4", name: "GPT-5.4", isCustom: false, capabilities: null }, + { slug: "gpt-5.5", name: "GPT-5.5", isCustom: false, capabilities: null }, + ], + }, + { + instanceId: ProviderInstanceId.make("grok"), + enabled: true, + installed: false, + status: "disabled", + availability: "unavailable", + models: [{ slug: "grok-build", name: "Grok Build", isCustom: false, capabilities: null }], + }, + ], + defaultModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + }); + + expect(rendered).toContain(CHANNEL_INFO_PIN_MARKER); + expect(rendered).toContain("https://github.com/pingdotgg/t3code"); + expect(rendered).toContain("/tmp/t3code"); + expect(rendered).toContain("Bot commands (prefer **/omegent**, alias **/agent**):"); + expect(rendered).toContain("/omegent ask prompt:…"); + expect(rendered).toContain("/omegent today-recap"); + expect(rendered).toContain("/omegent help"); + expect(rendered).toContain("/omegent stop"); + expect(rendered).toContain("/omegent compact"); + expect(rendered).toContain("/omegent thread-talk action:on|off|status"); + expect(rendered).toContain("/omegent link ref:"); + expect(rendered).toContain("/omegent refresh-indicators"); + expect(rendered).toContain("/omegent assign [github:login]"); + expect(rendered).toContain("@Omegent …"); + expect(rendered).toContain("Same actions (fallback)"); + expect(rendered).toContain("/omegent steernow"); + expect(rendered).toContain("--steer (inject now) --queue (park; default mid-turn)"); + expect(rendered).toContain("delete your message to cancel"); + expect(rendered).toContain("Default provider/model: `codex/gpt-5.4`"); + // Labels pad to the widest provider label ("grok [missing]"). + expect(rendered).toContain("codex gpt-5.4, gpt-5.5"); + expect(rendered).toContain("grok [missing] grok-build"); + expect(rendered.length).toBeLessThanOrEqual(DISCORD_MESSAGE_CONTENT_LIMIT); + // Prefer slash commands before mention fallback in the command block. + const askIdx = rendered.indexOf("/omegent ask prompt:"); + const mentionIdx = rendered.indexOf("@Omegent …"); + expect(askIdx).toBeGreaterThan(-1); + expect(mentionIdx).toBeGreaterThan(askIdx); + }); + + it("keeps pin content within Discord's 2000-character limit for large model lists", () => { + const manyModels = Array.from({ length: 80 }, (_, index) => ({ + slug: `vendor/very-long-model-slug-name-${index}`, + name: `Model ${index}`, + isCustom: false, + capabilities: null, + })); + const rendered = renderChannelInfoPin({ + githubUrl: "https://github.com/pingdotgg/t3code", + workspaceRoot: "/var/lib/t3/src/t3code", + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + enabled: true, + installed: true, + status: "ready", + availability: "available", + models: manyModels, + }, + { + instanceId: ProviderInstanceId.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + availability: "available", + models: manyModels, + }, + { + instanceId: ProviderInstanceId.make("grok"), + enabled: true, + installed: true, + status: "ready", + availability: "available", + models: manyModels, + }, + { + instanceId: ProviderInstanceId.make("cursor"), + enabled: true, + installed: true, + status: "ready", + availability: "available", + models: manyModels, + }, + ], + defaultModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + }); + + expect(rendered.length).toBeLessThanOrEqual(DISCORD_MESSAGE_CONTENT_LIMIT); + expect(rendered).toContain(CHANNEL_INFO_PIN_MARKER); + }); +}); diff --git a/apps/discord-bot/src/presentation/channelInfoPin.ts b/apps/discord-bot/src/presentation/channelInfoPin.ts new file mode 100644 index 000000000000..fee79cb8e831 --- /dev/null +++ b/apps/discord-bot/src/presentation/channelInfoPin.ts @@ -0,0 +1,203 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodePath from "node:path"; +import type { ModelSelection, ServerProvider } from "@t3tools/contracts"; + +export { resolveGitHubUrlForWorkspace } from "./githubLinks.ts"; + +export const CHANNEL_INFO_PIN_MARKER = "Omegent Channel Info"; + +/** + * Markers the bot used before the Omegent rebrand. Pin detection matches these too so + * an existing pre-rebrand pin is found and rewritten in place instead of orphaned + * alongside a fresh one. + */ +export const LEGACY_CHANNEL_INFO_PIN_MARKERS = ["T3 Bot Channel Info"] as const; + +/** Discord hard limit for message content (pins use the same limit). */ +export const DISCORD_MESSAGE_CONTENT_LIMIT = 2000; + +function formatProviderLabel(provider: Pick): string { + return provider.instanceId; +} + +function providerStatusSuffix( + provider: Pick, +): string { + if (!provider.installed) return " [missing]"; + if (!provider.enabled) return " [off]"; + if (provider.availability === "unavailable") return " [down]"; + if (provider.status === "disabled") return " [off]"; + return ""; +} + +function shortenModelSlug(slug: string): string { + const trimmed = slug.trim(); + if (trimmed.length === 0) return trimmed; + const slashIndex = trimmed.lastIndexOf("/"); + return slashIndex >= 0 ? trimmed.slice(slashIndex + 1) : trimmed; +} + +function wrapItems( + prefix: string, + items: ReadonlyArray, + maxWidth: number, +): ReadonlyArray { + if (items.length === 0) return [`${prefix}(none)`]; + + const lines: string[] = []; + let current = prefix; + + for (const item of items) { + const separator = current === prefix ? "" : ", "; + const next = `${current}${separator}${item}`; + if (current !== prefix && next.length > maxWidth) { + lines.push(current); + current = `${" ".repeat(prefix.length)}${item}`; + continue; + } + current = next; + } + + lines.push(current); + return lines; +} + +function renderProviderLines( + providers: ReadonlyArray< + Pick< + ServerProvider, + "instanceId" | "models" | "enabled" | "installed" | "availability" | "status" + > + >, + options?: { readonly maxModelsPerProvider?: number }, +): ReadonlyArray { + if (providers.length === 0) return ["(no configured providers expose models)"]; + + const maxModels = options?.maxModelsPerProvider; + const labels = providers.map( + (provider) => `${formatProviderLabel(provider)}${providerStatusSuffix(provider)}`, + ); + const labelWidth = labels.reduce((max, label) => Math.max(max, label.length), 0); + + return providers.flatMap((provider, index) => { + const label = labels[index]!.padEnd(labelWidth, " "); + const allModels = provider.models.map((model) => shortenModelSlug(model.slug)); + const models = + maxModels === undefined || allModels.length <= maxModels + ? allModels + : [...allModels.slice(0, maxModels), `+${allModels.length - maxModels} more`]; + return wrapItems(`${label} `, models, 110); + }); +} + +function buildChannelInfoPinBody(input: { + readonly githubUrl: string | null; + readonly workspaceRoot: string; + readonly providers: ReadonlyArray< + Pick< + ServerProvider, + "instanceId" | "models" | "enabled" | "installed" | "availability" | "status" + > + >; + readonly defaultModelSelection: ModelSelection | null; + readonly maxModelsPerProvider?: number; +}): string { + const repoDirectory = NodePath.resolve(input.workspaceRoot); + const githubLine = input.githubUrl ?? "(unable to resolve origin GitHub URL)"; + const providerLines = renderProviderLines( + input.providers, + input.maxModelsPerProvider === undefined + ? {} + : { maxModelsPerProvider: input.maxModelsPerProvider }, + ); + const defaultLine = + input.defaultModelSelection === null + ? "(unable to resolve)" + : `${input.defaultModelSelection.instanceId}/${input.defaultModelSelection.model}`; + + // Keep the command block compact — every line counts against Discord's 2000 limit. + // Prefer /omegent slash commands (/agent is an alias); @Omegent mentions are a fallback. + return [ + `**${CHANNEL_INFO_PIN_MARKER}**`, + "", + `GitHub: ${githubLine}`, + "", + "Repository directory:", + "```text", + repoDirectory, + "```", + "Bot commands (prefer **/omegent**, alias **/agent**):", + "```text", + "/omegent ask prompt:… Start or continue work", + " options: model provider base local plan steer queue", + "/omegent today-recap Daily PR recap for this channel's repo", + "/omegent steer prompt:… Mid-turn: inject now", + "/omegent queue prompt:… Mid-turn: park (same as default)", + "/omegent steernow Inject the whole parked queue", + "/omegent help This pin", + "/omegent stop Stop active turn", + "/omegent compact Compact context (posts token stats)", + "/omegent thread-talk action:on|off|status", + "/omegent link ref:", + "/omegent refresh-indicators", + "/omegent assign [github:login] Assign linked PR(s) (default: you)", + "@Omegent … Same actions (fallback)", + " flags: --plan --local --base --provider --model ", + " --steer (inject now) --queue (park; default mid-turn)", + " queued: 📥 badge · delete your message to cancel · /steernow to flush", + "```", + `Default provider/model: \`${defaultLine}\``, + "Supported provider/model configurations:", + "```text", + ...providerLines, + "```", + ].join("\n"); +} + +/** + * Render the channel-info pin body, always ≤ Discord's message content limit. + * Provider model lists are truncated first; hard-truncation is a last resort. + */ +export function renderChannelInfoPin(input: { + readonly githubUrl: string | null; + readonly workspaceRoot: string; + readonly providers: ReadonlyArray< + Pick< + ServerProvider, + "instanceId" | "models" | "enabled" | "installed" | "availability" | "status" + > + >; + readonly defaultModelSelection: ModelSelection | null; + readonly maxLength?: number; +}): string { + const maxLength = input.maxLength ?? DISCORD_MESSAGE_CONTENT_LIMIT; + const modelCaps = [undefined, 12, 6, 3, 1] as const; + + for (const maxModelsPerProvider of modelCaps) { + const rendered = buildChannelInfoPinBody({ + githubUrl: input.githubUrl, + workspaceRoot: input.workspaceRoot, + providers: input.providers, + defaultModelSelection: input.defaultModelSelection, + ...(maxModelsPerProvider === undefined ? {} : { maxModelsPerProvider }), + }); + if (rendered.length <= maxLength) return rendered; + } + + // Last resort: keep the header/commands and drop the provider dump. + const header = buildChannelInfoPinBody({ + githubUrl: input.githubUrl, + workspaceRoot: input.workspaceRoot, + providers: [], + defaultModelSelection: input.defaultModelSelection, + }); + const withoutProviders = header.replace( + "Supported provider/model configurations:\n```text\n(no configured providers expose models)\n```", + "Supported provider/model configurations: _(truncated — too many models for a Discord pin)_", + ); + + if (withoutProviders.length <= maxLength) return withoutProviders; + + const ellipsis = "…"; + return `${withoutProviders.slice(0, Math.max(0, maxLength - ellipsis.length))}${ellipsis}`; +} diff --git a/apps/discord-bot/src/presentation/compactContext.test.ts b/apps/discord-bot/src/presentation/compactContext.test.ts new file mode 100644 index 000000000000..abec5e1677a9 --- /dev/null +++ b/apps/discord-bot/src/presentation/compactContext.test.ts @@ -0,0 +1,83 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + extractLatestContextWindowStats, + formatCompactionStatsReply, + hasNewContextCompaction, +} from "./compactContext.ts"; + +describe("extractLatestContextWindowStats", () => { + it("returns the newest resolvable context-window activity", () => { + const stats = extractLatestContextWindowStats([ + { + id: "a1", + kind: "context-window.updated", + payload: { usedTokens: 1000, maxTokens: 200_000 }, + }, + { id: "a2", kind: "context-compaction", payload: { state: "compacted" } }, + { + id: "a3", + kind: "context-window.updated", + payload: { usedTokens: 12_400, maxTokens: 200_000 }, + }, + ]); + expect(stats).toEqual({ + usedTokens: 12_400, + maxTokens: 200_000, + activityId: "a3", + }); + }); + + it("skips malformed rows", () => { + expect( + extractLatestContextWindowStats([ + { kind: "context-window.updated", payload: { usedTokens: -1 } }, + { kind: "context-window.updated", payload: { usedTokens: "nope" } }, + ]), + ).toBeNull(); + }); +}); + +describe("hasNewContextCompaction", () => { + it("detects compact after a marker activity", () => { + const activities = [ + { id: "w1", kind: "context-window.updated", payload: { usedTokens: 10 } }, + { id: "c1", kind: "context-compaction", payload: {} }, + ]; + expect(hasNewContextCompaction(activities, "w1")).toBe(true); + expect(hasNewContextCompaction(activities, "c1")).toBe(false); + }); +}); + +describe("formatCompactionStatsReply", () => { + it("formats a successful before → after with savings", () => { + expect( + formatCompactionStatsReply({ + before: { usedTokens: 45_200, maxTokens: 200_000, activityId: "b" }, + after: { usedTokens: 12_100, maxTokens: 200_000, activityId: "a" }, + compacted: true, + }), + ).toBe("Context compacted: **45k/200k** → **12k/200k** tokens (saved 33k, 73%)."); + }); + + it("reports errors", () => { + expect( + formatCompactionStatsReply({ + before: null, + after: null, + compacted: false, + error: "Provider grok does not support manual context compact.", + }), + ).toContain("Context compact failed:"); + }); + + it("reports pending when not compacted yet", () => { + expect( + formatCompactionStatsReply({ + before: { usedTokens: 1500, maxTokens: null, activityId: null }, + after: { usedTokens: 1500, maxTokens: null, activityId: null }, + compacted: false, + }), + ).toContain("Current window:"); + }); +}); diff --git a/apps/discord-bot/src/presentation/compactContext.ts b/apps/discord-bot/src/presentation/compactContext.ts new file mode 100644 index 000000000000..303e81d4fddb --- /dev/null +++ b/apps/discord-bot/src/presentation/compactContext.ts @@ -0,0 +1,126 @@ +/** + * Context-window / compaction stats for `/omegent compact`. + * + * Pure helpers: extract latest context-window activity, format a public Discord + * reply with before → after token counts. + */ +import { formatCompactTokenCount } from "@t3tools/shared/turnResponseStats"; + +export type ContextWindowStats = { + readonly usedTokens: number; + readonly maxTokens: number | null; + readonly activityId: string | null; +}; + +export type CompactActivityLike = { + readonly id?: string | null; + readonly kind: string; + readonly payload: unknown; +}; + +function asRecord(value: unknown): Record | null { + return value !== null && typeof value === "object" && !Array.isArray(value) + ? (value as Record) + : null; +} + +function nonNegativeInt(value: unknown): number | null { + if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null; + return Math.round(value); +} + +/** Latest resolvable context-window.updated activity (walks newest → oldest). */ +export function extractLatestContextWindowStats( + activities: ReadonlyArray, +): ContextWindowStats | null { + for (let index = activities.length - 1; index >= 0; index -= 1) { + const activity = activities[index]; + if (!activity || activity.kind !== "context-window.updated") continue; + const payload = asRecord(activity.payload); + if (payload === null) continue; + const usedTokens = nonNegativeInt(payload.usedTokens); + if (usedTokens === null) continue; + const maxTokens = nonNegativeInt(payload.maxTokens); + return { + usedTokens, + maxTokens, + activityId: typeof activity.id === "string" ? activity.id : null, + }; + } + return null; +} + +/** True when a newer context-compaction activity appeared after `sinceActivityId`. */ +export function hasNewContextCompaction( + activities: ReadonlyArray, + sinceActivityId: string | null, +): boolean { + let seenSince = sinceActivityId === null; + for (const activity of activities) { + if (!seenSince) { + if (activity.id === sinceActivityId) seenSince = true; + continue; + } + if (activity.kind === "context-compaction") return true; + } + // If we never found the marker (windowed out), any compact activity counts. + if (!seenSince) { + return activities.some((activity) => activity.kind === "context-compaction"); + } + return false; +} + +function formatTokens(value: number, maxTokens: number | null): string { + const used = formatCompactTokenCount(value) ?? `${value}`; + if (maxTokens === null) return used; + const max = formatCompactTokenCount(maxTokens) ?? `${maxTokens}`; + return `${used}/${max}`; +} + +/** + * Public Discord reply for a completed (or partial) compact attempt. + */ +export function formatCompactionStatsReply(input: { + readonly before: ContextWindowStats | null; + readonly after: ContextWindowStats | null; + readonly compacted: boolean; + readonly error?: string | null; +}): string { + if (input.error !== undefined && input.error !== null && input.error.length > 0) { + return `Context compact failed: ${input.error}`; + } + + if (!input.compacted && input.before === null && input.after === null) { + return "Context compact requested, but no context-window stats are available for this thread yet."; + } + + if (!input.compacted) { + const current = input.after ?? input.before; + const currentLabel = + current === null ? "unknown" : formatTokens(current.usedTokens, current.maxTokens); + return `Context compact requested. Current window: **${currentLabel}** tokens (provider may still be compacting, or does not support manual compact).`; + } + + const before = input.before; + const after = input.after ?? input.before; + if (before === null || after === null) { + return "Context compacted."; + } + + const beforeLabel = formatTokens(before.usedTokens, before.maxTokens); + const afterLabel = formatTokens(after.usedTokens, after.maxTokens); + const saved = before.usedTokens - after.usedTokens; + if (saved > 0) { + const savedLabel = formatCompactTokenCount(saved) ?? `${saved}`; + const pct = Math.round((saved / Math.max(before.usedTokens, 1)) * 100); + return `Context compacted: **${beforeLabel}** → **${afterLabel}** tokens (saved ${savedLabel}, ${pct}%).`; + } + if (saved < 0) { + return `Context compacted: **${beforeLabel}** → **${afterLabel}** tokens.`; + } + return `Context compacted: **${afterLabel}** tokens.`; +} + +/** How long the Discord command waits for compaction / token drop before reporting. */ +export const COMPACT_WAIT_TIMEOUT_MS = 90_000; +export const COMPACT_POLL_INTERVAL_MS = 1_500; diff --git a/apps/discord-bot/src/presentation/discordFiles.ts b/apps/discord-bot/src/presentation/discordFiles.ts new file mode 100644 index 000000000000..fe32e20a9b71 --- /dev/null +++ b/apps/discord-bot/src/presentation/discordFiles.ts @@ -0,0 +1,129 @@ +/** + * Discord file uploads must use multipart createMessage: + * - payload_json: { content, attachments: [{ id: 0, filename }] } + * - files[0], files[1], ... + * + * Attachments cannot be added later via message edit. + */ +// @effect-diagnostics globalFetch:off globalFetchInEffect:off unknownInEffectCatch:off anyUnknownInErrorContext:off preferSchemaOverJson:off globalErrorInEffectCatch:off globalErrorInEffectFailure:off missingEffectError:off + +import { SUPPRESS_EMBEDS_FLAG } from "./suppressEmbeds.ts"; + +export interface DiscordUploadFile { + readonly name: string; + readonly mimeType: string; + readonly data: Uint8Array; +} + +export class DiscordUploadError extends Error { + readonly status: number | undefined; + readonly body: string | undefined; + + constructor(message: string, status?: number, body?: string) { + super(message); + this.name = "DiscordUploadError"; + this.status = status; + this.body = body; + } +} + +/** + * Create a channel message with binary attachments in a single multipart POST. + * Pure async helper — pass bot token + baseUrl from DiscordConfig at the call site. + */ +export async function createMessageWithAttachments(input: { + readonly baseUrl: string; + readonly botToken: string; + readonly channelId: string; + readonly content: string; + readonly files: ReadonlyArray; +}): Promise<{ readonly id: string }> { + const content = input.content; + const files = input.files; + + const form = new FormData(); + const payload: { + content: string; + flags: number; + attachments?: ReadonlyArray<{ id: number; filename: string }>; + } = { + content, + // Suppress link embeds; attachments (files[]) are separate and unaffected. + flags: SUPPRESS_EMBEDS_FLAG, + }; + + if (files.length > 0) { + payload.attachments = files.map((file, index) => ({ + id: index, + filename: file.name, + })); + } + + // Discord rejects completely empty messages; allow empty content when files exist. + if (payload.content.trim() === "" && files.length === 0) { + payload.content = "\u200b"; + } + + // payload_json must be a field name Discord recognizes — not an attachment. + form.append("payload_json", JSON.stringify(payload)); + + for (let index = 0; index < files.length; index += 1) { + const file = files[index]!; + // Copy into a plain ArrayBuffer-backed Uint8Array for BlobPart typing. + const copy = new Uint8Array(file.data.byteLength); + copy.set(file.data); + // Prefer File (filename is first-class). Blob+filename can show up as "blob" + // in some Discord clients when the multipart disposition is incomplete. + const safeName = + file.name.trim() !== "" + ? file.name.trim() + : file.mimeType.startsWith("image/") + ? "image.png" + : "attachment.bin"; + form.append( + `files[${index}]`, + new File([copy], safeName, { + type: file.mimeType || "application/octet-stream", + }), + ); + } + + // Strip trailing slash so we don't double up. + const base = input.baseUrl.replace(/\/+$/, ""); + const url = `${base}/channels/${input.channelId}/messages`; + + // Prefer global fetch (Node undici over HTTP/1.1) — Effect's layerUndici + HTTP/2 + // multipart has been observed to fail with NGHTTP2_PROTOCOL_ERROR on ~1MB images. + const response = await globalThis.fetch(url, { + method: "POST", + headers: { + Authorization: `Bot ${input.botToken}`, + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + body: form, + }); + + if (!response.ok) { + const errBody = await response.text().catch(() => ""); + throw new DiscordUploadError( + `Discord createMessage with files failed (${response.status}): ${errBody}`, + response.status, + errBody, + ); + } + + const json = (await response.json()) as { readonly id: string }; + return { id: json.id }; +} + +export function textFile( + name: string, + text: string, + mimeType = "text/markdown;charset=utf-8", +): DiscordUploadFile { + return { + name, + mimeType, + data: new TextEncoder().encode(text), + }; +} diff --git a/apps/discord-bot/src/presentation/discordInboundFiles.test.ts b/apps/discord-bot/src/presentation/discordInboundFiles.test.ts new file mode 100644 index 000000000000..cea3729f3f26 --- /dev/null +++ b/apps/discord-bot/src/presentation/discordInboundFiles.test.ts @@ -0,0 +1,161 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test"; + +import { + appendDiscordAttachmentPromptBlock, + ATTACHMENT_ONLY_PROMPT, + downloadDiscordAttachmentsToWorkspace, + formatDiscordAttachmentPromptBlock, +} from "./discordInboundFiles.ts"; + +describe("discordInboundFiles", () => { + const originalFetch = globalThis.fetch; + let tempDir: string; + + beforeEach(() => { + tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "discord-files-")); + }); + + afterEach(() => { + globalThis.fetch = originalFetch; + NodeFS.rmSync(tempDir, { recursive: true, force: true }); + vi.restoreAllMocks(); + }); + + it("downloads arbitrary Discord attachments into a temp staging directory", async () => { + globalThis.fetch = vi.fn( + async () => + new Response("hello", { + status: 200, + headers: { "content-type": "text/html; charset=utf-8" }, + }), + ) as typeof fetch; + + const result = await downloadDiscordAttachmentsToWorkspace({ + attachments: [ + { + filename: "../incident report.html", + content_type: "text/html; charset=utf-8", + url: "https://cdn.discordapp.com/report.html", + }, + ], + discordThreadId: "thread-123", + messageId: "message-456", + }); + + expect(result.skipped).toEqual([]); + expect(result.saved).toHaveLength(1); + expect(result.saved[0]?.name).toBe("incident report.html"); + expect(result.saved[0]?.absolutePath).toContain( + `${NodePath.sep}t3-discord-attachments${NodePath.sep}thread-123${NodePath.sep}message-456${NodePath.sep}`, + ); + expect(NodeFS.readFileSync(result.saved[0]!.absolutePath, "utf8")).toBe("hello"); + }); + + it("deduplicates filenames within the same message", async () => { + globalThis.fetch = vi.fn(async () => new Response("a", { status: 200 })) as typeof fetch; + + const result = await downloadDiscordAttachmentsToWorkspace({ + attachments: [ + { filename: "report.html", url: "https://cdn.discordapp.com/1" }, + { filename: "report.html", url: "https://cdn.discordapp.com/2" }, + ], + discordThreadId: "thread", + messageId: "message", + }); + + expect(result.saved.map((attachment) => attachment.name)).toEqual([ + "report.html", + "report-2.html", + ]); + }); + + it("falls back to the alternate Discord attachment URL when the first source fails", async () => { + globalThis.fetch = vi.fn(async (input) => { + const url = String(input); + if (url === "https://cdn.discordapp.com/report.html") { + return new Response("unsupported", { status: 415 }); + } + if (url === "https://media.discordapp.net/report.html") { + return new Response("Developer handover", { + status: 200, + headers: { "content-type": "text/html; charset=utf-8" }, + }); + } + return new Response("missing", { status: 404 }); + }) as typeof fetch; + + const result = await downloadDiscordAttachmentsToWorkspace({ + attachments: [ + { + filename: "report.html", + content_type: "text/html; charset=utf-8", + url: "https://cdn.discordapp.com/report.html", + proxy_url: "https://media.discordapp.net/report.html", + }, + ], + discordThreadId: "thread", + messageId: "message", + }); + + expect(result.skipped).toEqual([]); + expect(result.saved).toHaveLength(1); + expect(NodeFS.readFileSync(result.saved[0]!.absolutePath, "utf8")).toBe( + "Developer handover", + ); + expect(globalThis.fetch).toHaveBeenCalledTimes(2); + }); + + it("records all attempted Discord attachment sources when every download fails", async () => { + globalThis.fetch = vi.fn(async (input) => { + const url = String(input); + return new Response(url.includes("cdn.discordapp.com") ? "unsupported" : "missing", { + status: url.includes("cdn.discordapp.com") ? 415 : 404, + }); + }) as typeof fetch; + + const result = await downloadDiscordAttachmentsToWorkspace({ + attachments: [ + { + filename: "report.html", + url: "https://cdn.discordapp.com/report.html", + proxy_url: "https://media.discordapp.net/report.html", + }, + ], + discordThreadId: "thread", + messageId: "message", + }); + + expect(result.saved).toEqual([]); + expect(result.skipped).toEqual([ + { + filename: "report.html", + reason: "url:http 415; proxy_url:http 404", + }, + ]); + }); + + it("formats markdown links for prompt injection", () => { + const prompt = appendDiscordAttachmentPromptBlock({ + prompt: ATTACHMENT_ONLY_PROMPT, + attachments: [ + { + name: "report.html", + absolutePath: "/tmp/t3-discord-attachments/thread/message/report.html", + mimeType: "text/html", + sizeBytes: 42, + }, + ], + }); + + expect(formatDiscordAttachmentPromptBlock([])).toBe(""); + expect(prompt).toContain("## Discord attachments"); + expect(prompt).toContain( + "[report.html](/tmp/t3-discord-attachments/thread/message/report.html)", + ); + }); +}); diff --git a/apps/discord-bot/src/presentation/discordInboundFiles.ts b/apps/discord-bot/src/presentation/discordInboundFiles.ts new file mode 100644 index 000000000000..395e05ac1bbd --- /dev/null +++ b/apps/discord-bot/src/presentation/discordInboundFiles.ts @@ -0,0 +1,219 @@ +// @effect-diagnostics globalFetch:off nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import type { DiscordInboundAttachment } from "./discordInboundImages.ts"; + +const DISCORD_ATTACHMENT_STAGE_DIR = "t3-discord-attachments"; +const MAX_DISCORD_ATTACHMENT_BYTES = 50 * 1024 * 1024; +const MAX_FILENAME_LENGTH = 120; + +export interface SavedDiscordAttachment { + readonly name: string; + readonly absolutePath: string; + readonly mimeType: string | null; + readonly sizeBytes: number; +} + +interface DiscordAttachmentSourceAttempt { + readonly kind: "url" | "proxy_url"; + readonly url: string; +} + +function sanitizePathSegment(value: string, fallback: string): string { + const trimmed = value.trim(); + if (trimmed.length === 0) return fallback; + const withoutControlChars = [...trimmed] + .filter((char) => (char.codePointAt(0) ?? 0x20) >= 0x20) + .join(""); + const sanitized = withoutControlChars + .replace(/[\\/:*?"<>|]+/g, "-") + .replace(/\s+/g, " ") + .replace(/^[.\-\s]+/g, "") + .trim(); + return sanitized.length > 0 ? sanitized : fallback; +} + +function splitExtension(filename: string): { readonly stem: string; readonly extension: string } { + const extension = NodePath.extname(filename); + if (extension.length === 0) { + return { stem: filename, extension: "" }; + } + return { stem: filename.slice(0, -extension.length), extension }; +} + +function sanitizeAttachmentFilename(filename: string, index: number): string { + const original = filename.trim() !== "" ? filename : `attachment-${index + 1}`; + const { stem, extension } = splitExtension(original); + const safeStem = sanitizePathSegment(stem, `attachment-${index + 1}`); + const safeExtension = extension.replace(/[^a-z0-9.]+/gi, "").toLowerCase(); + const maxStemLength = Math.max(1, MAX_FILENAME_LENGTH - safeExtension.length); + const trimmedStem = safeStem.slice(0, maxStemLength).trim() || `attachment-${index + 1}`; + return `${trimmedStem}${safeExtension}`; +} + +function ensureUniqueFilename(filename: string, seen: Set, index: number): string { + if (!seen.has(filename)) { + seen.add(filename); + return filename; + } + + const { stem, extension } = splitExtension(filename); + for (let attempt = 2; attempt < 10_000; attempt += 1) { + const suffix = `-${attempt}`; + const maxStemLength = Math.max(1, MAX_FILENAME_LENGTH - extension.length - suffix.length); + const candidate = + `${stem.slice(0, maxStemLength)}${suffix}${extension}` || `attachment-${index + 1}`; + if (!seen.has(candidate)) { + seen.add(candidate); + return candidate; + } + } + + const fallback = `attachment-${index + 1}${extension}`; + seen.add(fallback); + return fallback; +} + +export function formatDiscordAttachmentPromptBlock( + attachments: ReadonlyArray, +): string { + if (attachments.length === 0) return ""; + const lines = [ + "## Discord attachments", + "These files were attached to the Discord message that mentioned you. Open them from the local filesystem if needed.", + ...attachments.map( + (attachment) => + `- [${attachment.name}](${attachment.absolutePath})${ + attachment.mimeType + ? ` (${attachment.mimeType}, ${attachment.sizeBytes} bytes)` + : ` (${attachment.sizeBytes} bytes)` + }`, + ), + ]; + return lines.join("\n"); +} + +export function appendDiscordAttachmentPromptBlock(input: { + readonly prompt: string; + readonly attachments: ReadonlyArray; +}): string { + const block = formatDiscordAttachmentPromptBlock(input.attachments); + if (block.length === 0) return input.prompt; + const prompt = input.prompt.trim(); + return prompt.length === 0 ? block : `${prompt}\n\n${block}`; +} + +function getAttachmentSourceAttempts( + attachment: DiscordInboundAttachment, +): ReadonlyArray { + const attempts: DiscordAttachmentSourceAttempt[] = []; + for (const candidate of [ + { kind: "url" as const, url: attachment.url }, + { kind: "proxy_url" as const, url: attachment.proxy_url }, + ]) { + const sourceUrl = candidate.url; + if (!sourceUrl) continue; + if (attempts.some((attempt) => attempt.url === sourceUrl)) continue; + attempts.push({ kind: candidate.kind, url: sourceUrl }); + } + return attempts; +} + +export async function downloadDiscordAttachmentsToWorkspace(input: { + readonly attachments: ReadonlyArray; + readonly discordThreadId: string; + readonly messageId: string; +}): Promise<{ + readonly saved: ReadonlyArray; + readonly skipped: ReadonlyArray<{ readonly filename: string; readonly reason: string }>; +}> { + if (input.attachments.length === 0) { + return { saved: [], skipped: [] }; + } + + const baseDir = NodePath.join( + NodeOS.tmpdir(), + DISCORD_ATTACHMENT_STAGE_DIR, + sanitizePathSegment(input.discordThreadId, "thread"), + sanitizePathSegment(input.messageId, "message"), + ); + await NodeFSP.mkdir(baseDir, { recursive: true }); + + const seenNames = new Set(); + const saved: SavedDiscordAttachment[] = []; + const skipped: Array<{ filename: string; reason: string }> = []; + + for (const [index, attachment] of input.attachments.entries()) { + const filename = sanitizeAttachmentFilename(attachment.filename ?? "", index); + const uniqueFilename = ensureUniqueFilename(filename, seenNames, index); + const sourceAttempts = getAttachmentSourceAttempts(attachment); + if (sourceAttempts.length === 0) { + skipped.push({ filename: uniqueFilename, reason: "missing url" }); + continue; + } + if (typeof attachment.size === "number" && attachment.size > MAX_DISCORD_ATTACHMENT_BYTES) { + skipped.push({ + filename: uniqueFilename, + reason: `too large (${attachment.size} > ${MAX_DISCORD_ATTACHMENT_BYTES})`, + }); + continue; + } + + try { + const failures: string[] = []; + let savedAttachment: SavedDiscordAttachment | null = null; + + for (const source of sourceAttempts) { + const response = await fetch(source.url); + if (!response.ok) { + failures.push(`${source.kind}:http ${response.status}`); + continue; + } + + const buffer = new Uint8Array(await response.arrayBuffer()); + if (buffer.byteLength === 0) { + failures.push(`${source.kind}:empty body`); + continue; + } + if (buffer.byteLength > MAX_DISCORD_ATTACHMENT_BYTES) { + failures.push( + `${source.kind}:too large (${buffer.byteLength} > ${MAX_DISCORD_ATTACHMENT_BYTES})`, + ); + continue; + } + + const absolutePath = NodePath.join(baseDir, uniqueFilename); + await NodeFSP.writeFile(absolutePath, buffer); + savedAttachment = { + name: uniqueFilename, + absolutePath, + mimeType: attachment.content_type?.split(";")[0]?.trim() ?? null, + sizeBytes: buffer.byteLength, + }; + break; + } + + if (savedAttachment) { + saved.push(savedAttachment); + continue; + } + + skipped.push({ + filename: uniqueFilename, + reason: failures.join("; ") || "download failed", + }); + } catch (cause) { + skipped.push({ + filename: uniqueFilename, + reason: cause instanceof Error ? cause.message : String(cause), + }); + } + } + + return { saved, skipped }; +} + +export const ATTACHMENT_ONLY_PROMPT = + "[User attached one or more files without additional text. Inspect the linked file(s) and respond using the conversation context.]"; diff --git a/apps/discord-bot/src/presentation/discordInboundImages.test.ts b/apps/discord-bot/src/presentation/discordInboundImages.test.ts new file mode 100644 index 000000000000..2331f6890aa7 --- /dev/null +++ b/apps/discord-bot/src/presentation/discordInboundImages.test.ts @@ -0,0 +1,78 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + filterDiscordImageAttachments, + guessMimeFromFilename, + isDiscordImageAttachment, +} from "./discordInboundImages.ts"; + +describe("isDiscordImageAttachment", () => { + it("accepts image content types", () => { + expect( + isDiscordImageAttachment({ + filename: "shot.png", + content_type: "image/png", + url: "https://cdn.discordapp.com/a.png", + }), + ).toBe(true); + }); + + it("rejects svg", () => { + expect( + isDiscordImageAttachment({ + filename: "x.svg", + content_type: "image/svg+xml", + url: "https://cdn.discordapp.com/x.svg", + }), + ).toBe(false); + }); + + it("accepts image extensions without content_type", () => { + expect( + isDiscordImageAttachment({ + filename: "ui.jpg", + url: "https://cdn.discordapp.com/ui.jpg", + }), + ).toBe(true); + }); + + it("accepts dimensioned attachments", () => { + expect( + isDiscordImageAttachment({ + filename: "paste", + width: 800, + height: 600, + url: "https://cdn.discordapp.com/paste", + }), + ).toBe(true); + }); + + it("rejects non-images", () => { + expect( + isDiscordImageAttachment({ + filename: "notes.txt", + content_type: "text/plain", + url: "https://cdn.discordapp.com/notes.txt", + }), + ).toBe(false); + }); +}); + +describe("filterDiscordImageAttachments", () => { + it("keeps only images", () => { + const out = filterDiscordImageAttachments([ + { filename: "a.png", content_type: "image/png", url: "u1" }, + { filename: "b.pdf", content_type: "application/pdf", url: "u2" }, + { filename: "c.webp", url: "u3" }, + ]); + expect(out.map((a) => a.filename)).toEqual(["a.png", "c.webp"]); + }); +}); + +describe("guessMimeFromFilename", () => { + it("maps common extensions", () => { + expect(guessMimeFromFilename("x.PNG")).toBe("image/png"); + expect(guessMimeFromFilename("x.jpeg")).toBe("image/jpeg"); + expect(guessMimeFromFilename("x")).toBe(null); + }); +}); diff --git a/apps/discord-bot/src/presentation/discordInboundImages.ts b/apps/discord-bot/src/presentation/discordInboundImages.ts new file mode 100644 index 000000000000..a56e7ad23742 --- /dev/null +++ b/apps/discord-bot/src/presentation/discordInboundImages.ts @@ -0,0 +1,149 @@ +// @effect-diagnostics globalFetch:off +/** + * Convert Discord message attachments into T3 UploadChatAttachment images + * (data URLs) so providers receive the same shape as the web composer. + */ +import type { UploadChatAttachment } from "@t3tools/contracts"; +import { + PROVIDER_SEND_TURN_MAX_ATTACHMENTS, + PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, +} from "@t3tools/contracts"; + +/** Minimal Discord attachment shape (gateway or REST). */ +export interface DiscordInboundAttachment { + readonly id?: string; + readonly filename?: string; + readonly url?: string; + readonly proxy_url?: string; + readonly size?: number; + readonly content_type?: string | null; + readonly width?: number; + readonly height?: number; +} + +const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i; + +export function guessMimeFromFilename(filename: string): string | null { + const lower = filename.toLowerCase(); + if (lower.endsWith(".png")) return "image/png"; + if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg"; + if (lower.endsWith(".gif")) return "image/gif"; + if (lower.endsWith(".webp")) return "image/webp"; + if (lower.endsWith(".bmp")) return "image/bmp"; + return null; +} + +export function isDiscordImageAttachment(att: DiscordInboundAttachment): boolean { + const ct = att.content_type?.toLowerCase() ?? ""; + if (ct.startsWith("image/") && !ct.includes("svg")) return true; + const name = att.filename ?? ""; + if (IMAGE_EXT.test(name)) return true; + // Discord sometimes omits content_type but sets dimensions for images. + if ( + typeof att.width === "number" && + att.width > 0 && + typeof att.height === "number" && + att.height > 0 && + name !== "" + ) { + return true; + } + return false; +} + +export function filterDiscordImageAttachments( + attachments: ReadonlyArray | null | undefined, +): ReadonlyArray { + if (attachments === undefined || attachments === null) return []; + return attachments.filter(isDiscordImageAttachment).slice(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS); +} + +function uint8ToBase64(bytes: Uint8Array): string { + // Chunk to avoid call-stack / argument limits on large images. + const chunk = 0x8000; + let binary = ""; + for (let i = 0; i < bytes.length; i += chunk) { + binary += String.fromCharCode(...bytes.subarray(i, i + chunk)); + } + return btoa(binary); +} + +/** + * Download Discord CDN images and build T3 upload attachments. + * Skips oversize / failed downloads (logged by caller via returned skipped list). + */ +export async function downloadDiscordImagesAsUploadAttachments( + attachments: ReadonlyArray, +): Promise<{ + readonly uploads: ReadonlyArray; + readonly skipped: ReadonlyArray<{ readonly filename: string; readonly reason: string }>; +}> { + const images = filterDiscordImageAttachments(attachments); + const uploads: UploadChatAttachment[] = []; + const skipped: Array<{ filename: string; reason: string }> = []; + + for (const att of images) { + const filename = (att.filename ?? "image.png").slice(0, 255) || "image.png"; + const sourceUrl = att.proxy_url || att.url; + if (sourceUrl === undefined || sourceUrl === "") { + skipped.push({ filename, reason: "missing url" }); + continue; + } + if (typeof att.size === "number" && att.size > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) { + skipped.push({ + filename, + reason: `too large (${att.size} > ${PROVIDER_SEND_TURN_MAX_IMAGE_BYTES})`, + }); + continue; + } + + try { + const response = await fetch(sourceUrl); + if (!response.ok) { + skipped.push({ filename, reason: `http ${response.status}` }); + continue; + } + const buffer = new Uint8Array(await response.arrayBuffer()); + if (buffer.byteLength === 0) { + skipped.push({ filename, reason: "empty body" }); + continue; + } + if (buffer.byteLength > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) { + skipped.push({ + filename, + reason: `too large (${buffer.byteLength} > ${PROVIDER_SEND_TURN_MAX_IMAGE_BYTES})`, + }); + continue; + } + + const headerType = response.headers.get("content-type")?.split(";")[0]?.trim() ?? ""; + const mimeType = + (att.content_type && att.content_type.startsWith("image/") + ? att.content_type.split(";")[0]!.trim() + : null) ?? + (headerType.startsWith("image/") ? headerType : null) ?? + guessMimeFromFilename(filename) ?? + "image/png"; + + const dataUrl = `data:${mimeType};base64,${uint8ToBase64(buffer)}`; + uploads.push({ + type: "image", + name: filename, + mimeType, + sizeBytes: buffer.byteLength, + dataUrl, + }); + } catch (cause) { + skipped.push({ + filename, + reason: cause instanceof Error ? cause.message : String(cause), + }); + } + } + + return { uploads, skipped }; +} + +/** Prompt when the user only attached images (mirrors web empty-text image turns). */ +export const IMAGE_ONLY_PROMPT = + "[User attached one or more images without additional text. Respond using the conversation context and the attached image(s).]"; diff --git a/apps/discord-bot/src/presentation/discordPrAttribution.test.ts b/apps/discord-bot/src/presentation/discordPrAttribution.test.ts new file mode 100644 index 000000000000..7ab46d468a93 --- /dev/null +++ b/apps/discord-bot/src/presentation/discordPrAttribution.test.ts @@ -0,0 +1,268 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + appendDiscordPrAttributionFooter, + buildDiscordThreadJumpUrl, + buildOmegentThreadMessageUrl, + buildT3WebThreadUrl, + DISCORD_PR_ATTRIBUTION_MARKER, + ensureDiscordPrAttributionFooters, + formatDiscordPrAttributionFooter, + newlyObservedPullRequestUrls, + pickT3ThreadUrlForGithubRepo, + prBodyHasDiscordAttribution, + starterDisplayName, + starterUserId, + toT3PublicShortThreadUrl, + withT3ThreadLink, +} from "./discordPrAttribution.ts"; + +describe("formatDiscordPrAttributionFooter", () => { + it("formats starter profile URL + full thread jump link", () => { + expect( + formatDiscordPrAttributionFooter({ + starterDisplayName: "joshuadima", + starterUserId: "593167616273809448", + threadTitle: "Open Random PR Test", + threadJumpUrl: + "https://discord.com/channels/1083767712431480922/1531376362399465595/1531376362399465595", + }), + ).toBe( + "opened by [joshuadima](https://discord.com/users/593167616273809448) in chat thread **Discord** · [Open Random PR Test](https://discord.com/channels/1083767712431480922/1531376362399465595/1531376362399465595)", + ); + }); + + it("omits broken/truncated thread links", () => { + expect( + formatDiscordPrAttributionFooter({ + starterDisplayName: "joshuadima", + starterUserId: "593167616273809448", + threadTitle: "Thread", + threadJumpUrl: "https://discord.com/channels", + }), + ).toBe( + "opened by [joshuadima](https://discord.com/users/593167616273809448) in chat thread **Discord**", + ); + }); + + it("escapes markdown brackets in names/titles", () => { + const footer = formatDiscordPrAttributionFooter({ + starterDisplayName: "a[b]c", + starterUserId: "1", + threadTitle: "Title [x]", + threadJumpUrl: "https://discord.com/channels/1/2/3", + }); + expect(footer).toContain("[a\\[b\\]c](https://discord.com/users/1)"); + expect(footer).toContain("[Title \\[x\\]](https://discord.com/channels/1/2/3)"); + }); + + it("appends T3 thread link when provided", () => { + expect( + formatDiscordPrAttributionFooter({ + starterDisplayName: "patroza", + starterUserId: "1", + threadTitle: "Thread", + threadJumpUrl: "https://discord.com/channels/1/2/3", + t3ThreadUrl: "https://t3vm.tail.example.ts.net/?thread=abc", + }), + ).toContain(" · [T3](https://t3vm.tail.example.ts.net/?thread=abc)"); + }); +}); + +describe("T3 thread URL helpers", () => { + it("builds full and short t3 thread URLs", () => { + expect(buildT3WebThreadUrl("https://t3vm.tail86038f.ts.net/", "tid-1")).toBe( + "https://t3vm.tail86038f.ts.net/?thread=tid-1", + ); + expect(toT3PublicShortThreadUrl("https://t3vm.tail86038f.ts.net/?thread=tid-1")).toBe( + "https://t3vm/?thread=tid-1", + ); + expect( + pickT3ThreadUrlForGithubRepo({ + fullUrl: "https://t3vm.tail86038f.ts.net/?thread=tid-1", + repoIsPrivate: true, + }), + ).toBe("https://t3vm.tail86038f.ts.net/?thread=tid-1"); + expect( + pickT3ThreadUrlForGithubRepo({ + fullUrl: "https://t3vm.tail86038f.ts.net/?thread=tid-1", + repoIsPrivate: false, + }), + ).toBe("https://t3vm/?thread=tid-1"); + expect( + pickT3ThreadUrlForGithubRepo({ + fullUrl: "https://t3vm.tail86038f.ts.net/?thread=tid-1", + repoIsPrivate: null, + }), + ).toBe("https://t3vm/?thread=tid-1"); + }); + + it("withT3ThreadLink is idempotent", () => { + const base = + "opened by [x](https://discord.com/users/1) in chat thread **Discord** · [t](https://discord.com/channels/1/2/3)"; + const once = withT3ThreadLink(base, "https://t3vm/?thread=1"); + expect(once).toBe(`${base} · [T3](https://t3vm/?thread=1)`); + expect(withT3ThreadLink(once, "https://t3vm/?thread=1")).toBe(once); + }); + + it("builds message deep links from the configured web UI base", () => { + expect( + buildOmegentThreadMessageUrl({ + webUiBaseUrl: "https://t3vm.tail86038f.ts.net/", + threadId: "tid-1", + messageId: "msg-1", + }), + ).toBe("https://t3vm.tail86038f.ts.net/?thread=tid-1#message-msg-1"); + expect( + buildOmegentThreadMessageUrl({ + webUiBaseUrl: undefined, + threadId: "tid-1", + messageId: "msg-1", + }), + ).toBeNull(); + }); +}); + +describe("buildDiscordThreadJumpUrl", () => { + it("prefers message id when provided", () => { + expect( + buildDiscordThreadJumpUrl({ + guildId: "g", + discordThreadId: "t", + messageId: "m", + }), + ).toBe("https://discord.com/channels/g/t/m"); + }); + + it("falls back to thread id as message id", () => { + expect( + buildDiscordThreadJumpUrl({ + guildId: "g", + discordThreadId: "t", + messageId: null, + }), + ).toBe("https://discord.com/channels/g/t/t"); + }); +}); + +describe("starter helpers", () => { + it("prefers displayName over username", () => { + expect( + starterDisplayName({ + id: "m1", + author: { id: "u1", username: "user", displayName: "Display" }, + }), + ).toBe("Display"); + expect(starterUserId({ id: "m1", author: { id: "u1" } })).toBe("u1"); + }); + + it("handles missing starter", () => { + expect(starterDisplayName(null)).toBe("unknown"); + expect(starterUserId(null)).toBeNull(); + }); +}); + +describe("prBodyHasDiscordAttribution / appendDiscordPrAttributionFooter", () => { + const footer = formatDiscordPrAttributionFooter({ + starterDisplayName: "joshuadima", + starterUserId: "593167616273809448", + threadTitle: "Thread", + threadJumpUrl: "https://discord.com/channels/1/2/3", + }); + + it("detects existing footer marker", () => { + expect(prBodyHasDiscordAttribution(`hello\n${DISCORD_PR_ATTRIBUTION_MARKER}\n`)).toBe(true); + expect(prBodyHasDiscordAttribution("## Summary\n- stuff")).toBe(false); + }); + + it("appends footer with separator when missing", () => { + expect(appendDiscordPrAttributionFooter("## Summary\n- a", footer)).toBe( + `## Summary\n- a\n\n---\n\n${footer}\n`, + ); + }); + + it("returns null when already present (idempotent)", () => { + const body = `## Summary\n\n---\n\n${footer}\n`; + expect(appendDiscordPrAttributionFooter(body, footer)).toBeNull(); + }); + + it("works on empty body", () => { + expect(appendDiscordPrAttributionFooter("", footer)).toBe(`${footer}\n`); + }); +}); + +describe("newlyObservedPullRequestUrls", () => { + it("returns only new canonical PR urls", () => { + expect( + newlyObservedPullRequestUrls( + ["https://github.com/owner/repo/pull/1"], + [ + "https://github.com/owner/repo/pull/1/files", + "https://github.com/owner/repo/pull/2", + "https://example.com/not-a-pr", + ], + ), + ).toEqual(["https://github.com/owner/repo/pull/2"]); + }); +}); + +describe("ensureDiscordPrAttributionFooters", () => { + it("patches missing footers and skips ones already present", async () => { + const bodies = new Map([ + ["repos/o/r/pulls/1", "## Summary\n- a\n"], + [ + "repos/o/r/pulls/2", + `## Summary\n\n---\n\nopened by [x](1) ${DISCORD_PR_ATTRIBUTION_MARKER} [t](https://discord.com/channels/1/2/3)\n`, + ], + ]); + const repoPrivate = new Map([["repos/o/r", "true"]]); + const patched: string[] = []; + const writtenBodies: string[] = []; + + const results = await ensureDiscordPrAttributionFooters({ + prUrls: [ + "https://github.com/o/r/pull/1", + "https://github.com/o/r/pull/2", + "https://github.com/o/r/pull/3", + ], + footer: formatDiscordPrAttributionFooter({ + starterDisplayName: "joshuadima", + starterUserId: "593167616273809448", + threadTitle: "Open Random PR Test", + threadJumpUrl: "https://discord.com/channels/1/2/3", + }), + t3FullThreadUrl: "https://t3vm.tail.example.ts.net/?thread=t1", + execFile: async (_file, args) => { + const path = String(args[1] ?? ""); + if (args.includes("--jq")) { + const jq = String(args[args.indexOf("--jq") + 1] ?? ""); + if (jq.includes(".private")) { + return { stdout: repoPrivate.get(path) ?? "false", stderr: "" }; + } + if (!bodies.has(path)) { + throw new Error(`not found: ${path}`); + } + return { stdout: bodies.get(path) ?? "", stderr: "" }; + } + if (args.includes("PATCH")) { + patched.push(path); + // body written via temp file; just record path + writtenBodies.push(path); + return { stdout: "", stderr: "" }; + } + throw new Error(`unexpected gh args: ${args.join(" ")}`); + }, + }); + + expect(results).toEqual([ + { url: "https://github.com/o/r/pull/1", status: "updated" }, + { url: "https://github.com/o/r/pull/2", status: "already_present" }, + { + url: "https://github.com/o/r/pull/3", + status: "error", + detail: "not found: repos/o/r/pulls/3", + }, + ]); + expect(patched).toEqual(["repos/o/r/pulls/1"]); + }); +}); diff --git a/apps/discord-bot/src/presentation/discordPrAttribution.ts b/apps/discord-bot/src/presentation/discordPrAttribution.ts new file mode 100644 index 000000000000..efbe628a784d --- /dev/null +++ b/apps/discord-bot/src/presentation/discordPrAttribution.ts @@ -0,0 +1,394 @@ +/** + * Hardcoded Discord PR attribution footer. + * + * When a PR URL is first linked to a Discord thread, the bot appends a footer + * using the **thread starter** (not the current requester) and the Discord + * thread title. No agent prompt is required. + */ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeChildProcess from "node:child_process"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as NodeUtil from "node:util"; + +import { gitCommandEnv } from "./githubLinks.ts"; +import { normalizePullRequestUrl } from "./prLinks.ts"; + +const execFile = NodeUtil.promisify(NodeChildProcess.execFile); + +type ExecFileResult = { + readonly stdout: string; + readonly stderr: string; +}; + +type ExecFileLike = ( + file: string, + args: ReadonlyArray, + options?: NodeChildProcess.ExecFileOptions, +) => Promise; + +/** Marker used to detect an existing Discord attribution footer (idempotent). */ +export const DISCORD_PR_ATTRIBUTION_MARKER = "in chat thread **Discord** ·"; + +/** Marker for optional T3 thread link on the same footer line. */ +export const T3_PR_THREAD_LINK_MARKER = " · [T3]("; + +export type DiscordPrAttributionInput = { + /** Thread starter display name (fallback: username). */ + readonly starterDisplayName: string; + /** Thread starter Discord snowflake user id. */ + readonly starterUserId: string; + /** Discord thread title (channel name). */ + readonly threadTitle: string; + /** Jump URL into the Discord thread (prefer starter message). */ + readonly threadJumpUrl: string; + /** + * Optional T3 web thread URL. Full host for private GitHub repos; short + * `https://t3vm/?thread=…` for public repos (see pickT3ThreadUrlForGithubRepo). + */ + readonly t3ThreadUrl?: string | null | undefined; +}; + +export type DiscordThreadStarterLike = { + readonly id: string; + readonly author?: + | { + readonly id?: string | undefined; + readonly username?: string | undefined; + readonly displayName?: string | undefined; + } + | undefined + | null; +}; + +/** + * Public Discord user profile URL (opens profile in app/browser when signed in). + * Prefer this over bare snowflake ids, which are not navigable links. + */ +export function buildDiscordUserProfileUrl(userId: string): string { + return `https://discord.com/users/${userId.trim()}`; +} + +/** True when the URL is a full discord.com/channels/... jump (not a truncated placeholder). */ +export function isValidDiscordChannelJumpUrl(url: string): boolean { + const trimmed = url.trim(); + if (trimmed.length === 0) return false; + // Require guild + channel segments; optional message id. + return /^https:\/\/(?:ptb\.|canary\.)?discord(?:app)?\.com\/channels\/[^/\s]+\/[^/\s]+(?:\/[^/\s]+)?$/u.test( + trimmed, + ); +} + +/** + * Full T3 web UI deep link for a thread (`{base}/?thread={id}`). + * Returns null when base or thread id is missing. + */ +export function buildT3WebThreadUrl( + webUiBaseUrl: string | undefined | null, + threadId: string | undefined | null, +): string | null { + const base = webUiBaseUrl?.trim(); + const id = threadId?.trim(); + if (base === undefined || base.length === 0 || id === undefined || id.length === 0) { + return null; + } + return `${base.replace(/\/+$/u, "")}/?thread=${id}`; +} + +/** + * Same web UI base as the pin's "Open in Omegent" (`T3_WEB_UI_BASE_URL`), + * plus `#message-{messageId}` for client scroll-into-view. + * Does not invent a short `t3vm` host — that rewrite is only for public PR bodies. + */ +export function buildOmegentThreadMessageUrl(input: { + readonly webUiBaseUrl?: string | null | undefined; + readonly threadId: string | undefined | null; + readonly messageId: string | undefined | null; +}): string | null { + const messageId = input.messageId?.trim() ?? ""; + if (messageId === "") return null; + + const threadUrl = buildT3WebThreadUrl(input.webUiBaseUrl, input.threadId); + if (threadUrl === null) return null; + + try { + const url = new URL(threadUrl); + url.hash = `message-${messageId}`; + return url.toString(); + } catch { + const withoutHash = threadUrl.replace(/#.*$/u, ""); + return `${withoutHash}#message-${messageId}`; + } +} + +/** + * Public-safe short form: same URL with hostname forced to `t3vm` (no port). + * Example: `https://t3vm.tail….ts.net/?thread=x` → `https://t3vm/?thread=x` + */ +export function toT3PublicShortThreadUrl(fullUrl: string): string { + const trimmed = fullUrl.trim(); + try { + const url = new URL(trimmed); + url.hostname = "t3vm"; + url.port = ""; + return url.toString(); + } catch { + return trimmed.replace(/^(https?:\/\/)[^/?#]+/u, "$1t3vm"); + } +} + +/** + * Private GitHub repo → full t3vm host URL. Public/unknown → short `t3vm` host only + * (avoids leaking tailnet hostnames on public PR bodies). + */ +export function pickT3ThreadUrlForGithubRepo(input: { + readonly fullUrl: string | null | undefined; + readonly repoIsPrivate: boolean | null; +}): string | null { + const full = input.fullUrl?.trim(); + if (full === undefined || full.length === 0) return null; + if (input.repoIsPrivate === true) return full; + return toT3PublicShortThreadUrl(full); +} + +/** Append ` · [T3](url)` when missing. */ +export function withT3ThreadLink( + discordFooter: string, + t3ThreadUrl: string | null | undefined, +): string { + const base = discordFooter.trim(); + const t3 = t3ThreadUrl?.trim(); + if (base.length === 0) return t3 !== undefined && t3.length > 0 ? `[T3](${t3})` : ""; + if (t3 === undefined || t3.length === 0) return base; + if (base.includes(T3_PR_THREAD_LINK_MARKER) || base.includes(`](${t3})`)) return base; + return `${base}${T3_PR_THREAD_LINK_MARKER}${t3})`; +} + +/** + * Build the single-line attribution footer from thread starter + title. + * User link uses Discord profile URL; thread link must be a full channel jump URL. + * Optional T3 thread link is appended as ` · [T3](url)`. + */ +export function formatDiscordPrAttributionFooter(input: DiscordPrAttributionInput): string { + const displayName = input.starterDisplayName.trim() || "unknown"; + const userId = input.starterUserId.trim(); + const title = sanitizeMarkdownLinkLabel(input.threadTitle.trim() || "Discord thread"); + const profileUrl = buildDiscordUserProfileUrl(userId); + const jumpUrl = input.threadJumpUrl.trim(); + + const openedBy = `opened by [${escapeMarkdownLinkLabel(displayName)}](${profileUrl}) in chat thread **Discord**`; + const withDiscord = isValidDiscordChannelJumpUrl(jumpUrl) + ? `${openedBy} · [${escapeMarkdownLinkLabel(title)}](${jumpUrl})` + : openedBy; + return withT3ThreadLink(withDiscord, input.t3ThreadUrl); +} + +export function buildDiscordThreadJumpUrl(input: { + readonly guildId: string; + readonly discordThreadId: string; + /** Prefer the starter message id; falls back to the thread id. */ + readonly messageId?: string | null | undefined; +}): string { + const guildId = input.guildId.trim(); + const discordThreadId = input.discordThreadId.trim(); + if (guildId.length === 0 || discordThreadId.length === 0) { + return ""; + } + const messageId = + input.messageId !== null && input.messageId !== undefined && input.messageId.trim() !== "" + ? input.messageId.trim() + : discordThreadId; + return `https://discord.com/channels/${guildId}/${discordThreadId}/${messageId}`; +} + +export function starterDisplayName(starter: DiscordThreadStarterLike | null | undefined): string { + if (starter === null || starter === undefined) return "unknown"; + const display = starter.author?.displayName?.trim(); + if (display !== undefined && display.length > 0) return display; + const username = starter.author?.username?.trim(); + if (username !== undefined && username.length > 0) return username; + return "unknown"; +} + +export function starterUserId(starter: DiscordThreadStarterLike | null | undefined): string | null { + const id = starter?.author?.id?.trim(); + return id !== undefined && id.length > 0 ? id : null; +} + +/** True when the PR body already has a Discord attribution footer. */ +export function prBodyHasDiscordAttribution(body: string | null | undefined): boolean { + if (body === null || body === undefined || body.length === 0) return false; + return ( + body.includes(DISCORD_PR_ATTRIBUTION_MARKER) || + /opened by \[.+?\]\(.+?\) in chat thread/u.test(body) + ); +} + +/** + * Append the footer when missing. Returns null when body already has attribution + * (caller should skip the GitHub update). + */ +export function appendDiscordPrAttributionFooter( + body: string | null | undefined, + footer: string, +): string | null { + const trimmedFooter = footer.trim(); + if (trimmedFooter.length === 0) return null; + if (prBodyHasDiscordAttribution(body)) return null; + + const base = (body ?? "").replace(/\s+$/u, ""); + if (base.length === 0) return `${trimmedFooter}\n`; + return `${base}\n\n---\n\n${trimmedFooter}\n`; +} + +/** + * Newly observed PR URLs that are not already in the durable first-seen list. + */ +export function newlyObservedPullRequestUrls( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, +): ReadonlyArray { + const seen = new Set(); + for (const raw of existing ?? []) { + const normalized = normalizePullRequestUrl(raw); + if (normalized !== null) seen.add(normalized.url); + } + + const result: string[] = []; + for (const raw of incoming ?? []) { + const normalized = normalizePullRequestUrl(raw); + if (normalized === null || seen.has(normalized.url)) continue; + seen.add(normalized.url); + result.push(normalized.url); + } + return result; +} + +function escapeMarkdownLinkLabel(value: string): string { + return value.replace(/\[/gu, "\\[").replace(/\]/gu, "\\]"); +} + +function sanitizeMarkdownLinkLabel(value: string): string { + // Collapse newlines / excessive whitespace so the footer stays one line. + return value.replace(/\s+/gu, " ").trim(); +} + +export type EnsureDiscordPrAttributionResult = { + readonly url: string; + readonly status: "updated" | "already_present" | "skipped" | "error"; + readonly detail?: string | undefined; +}; + +/** + * For each PR URL, append the Discord attribution footer when missing. + * When `t3FullThreadUrl` is set, appends ` · [T3](…)` using the full host for + * private GitHub repos and the short `t3vm` host for public/unknown repos. + * Best-effort: failures are returned per-URL and never throw. + */ +export async function ensureDiscordPrAttributionFooters(input: { + readonly prUrls: ReadonlyArray; + /** Discord attribution line (may already include T3; otherwise T3 is chosen per-repo). */ + readonly footer: string; + /** Full T3 web URL (`{T3_WEB_UI_BASE_URL}/?thread=…`). Shortened for public repos. */ + readonly t3FullThreadUrl?: string | null | undefined; + readonly execFile?: ExecFileLike; +}): Promise> { + const execImpl = input.execFile ?? execFile; + const results: EnsureDiscordPrAttributionResult[] = []; + const footerHasT3 = input.footer.includes(T3_PR_THREAD_LINK_MARKER); + + for (const raw of input.prUrls) { + const normalized = normalizePullRequestUrl(raw); + if (normalized === null) { + results.push({ url: raw, status: "skipped", detail: "not a github pull request url" }); + continue; + } + + try { + const currentBody = await readPullRequestBody(normalized, execImpl); + let footer = input.footer; + if (!footerHasT3 && input.t3FullThreadUrl !== undefined && input.t3FullThreadUrl !== null) { + const repoIsPrivate = await readGithubRepoIsPrivate(normalized, execImpl); + const t3Url = pickT3ThreadUrlForGithubRepo({ + fullUrl: input.t3FullThreadUrl, + repoIsPrivate, + }); + footer = withT3ThreadLink(input.footer, t3Url); + } + const nextBody = appendDiscordPrAttributionFooter(currentBody, footer); + if (nextBody === null) { + results.push({ url: normalized.url, status: "already_present" }); + continue; + } + + await writePullRequestBody(normalized, nextBody, execImpl); + results.push({ url: normalized.url, status: "updated" }); + } catch (error) { + results.push({ + url: normalized.url, + status: "error", + detail: error instanceof Error ? error.message : String(error), + }); + } + } + + return results; +} + +async function readGithubRepoIsPrivate( + pr: { readonly owner: string; readonly repo: string }, + execImpl: ExecFileLike, +): Promise { + try { + const { stdout } = await execImpl( + "gh", + ["api", `repos/${pr.owner}/${pr.repo}`, "--jq", ".private"], + { env: gitCommandEnv(), maxBuffer: 64 * 1024 }, + ); + const value = stdout.trim().toLowerCase(); + if (value === "true") return true; + if (value === "false") return false; + return null; + } catch { + return null; + } +} + +async function readPullRequestBody( + pr: { readonly owner: string; readonly repo: string; readonly number: number }, + execImpl: ExecFileLike, +): Promise { + const { stdout } = await execImpl( + "gh", + ["api", `repos/${pr.owner}/${pr.repo}/pulls/${pr.number}`, "--jq", '.body // ""'], + { env: gitCommandEnv(), maxBuffer: 4 * 1024 * 1024 }, + ); + return stdout; +} + +async function writePullRequestBody( + pr: { readonly owner: string; readonly repo: string; readonly number: number }, + body: string, + execImpl: ExecFileLike, +): Promise { + const tempDir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-discord-pr-body-")); + const bodyFile = NodePath.join(tempDir, "body.json"); + try { + await NodeFSP.writeFile(bodyFile, JSON.stringify({ body }), "utf8"); + await execImpl( + "gh", + [ + "api", + `repos/${pr.owner}/${pr.repo}/pulls/${pr.number}`, + "-X", + "PATCH", + "--input", + bodyFile, + ], + { env: gitCommandEnv(), maxBuffer: 4 * 1024 * 1024 }, + ); + } finally { + await NodeFSP.rm(tempDir, { recursive: true, force: true }).catch(() => undefined); + } +} diff --git a/apps/discord-bot/src/presentation/githubLinks.test.ts b/apps/discord-bot/src/presentation/githubLinks.test.ts new file mode 100644 index 000000000000..2b726ac76915 --- /dev/null +++ b/apps/discord-bot/src/presentation/githubLinks.test.ts @@ -0,0 +1,302 @@ +import { describe, expect, it } from "vite-plus/test"; +import { + createGitHubLinkResolutionCache, + normalizeGitHubRemoteUrl, + resolveGitHubBlobUrlForLocalPath, + resolveGitHubBlobUrlForPathReference, + resolveGitHubUrlForWorkspace, +} from "./githubLinks.ts"; + +describe("normalizeGitHubRemoteUrl", () => { + it("normalizes GitHub SSH remotes", () => { + expect(normalizeGitHubRemoteUrl("git@github.com:pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + expect(normalizeGitHubRemoteUrl("ssh://git@github.com/pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + }); + + it("normalizes GitHub deploy-key style SCP remotes", () => { + expect(normalizeGitHubRemoteUrl("org-12345678@github.com:pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + }); + + it("normalizes GitHub HTTPS remotes", () => { + expect(normalizeGitHubRemoteUrl("https://github.com/pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + expect(normalizeGitHubRemoteUrl("https://www.github.com/pingdotgg/t3code.git")).toBe( + "https://github.com/pingdotgg/t3code", + ); + }); + + it("rejects non-GitHub remotes", () => { + expect(normalizeGitHubRemoteUrl("https://gitlab.com/pingdotgg/t3code.git")).toBeNull(); + }); +}); + +describe("resolveGitHubBlobUrlForLocalPath", () => { + it("uses the remote branch when origin already has it", async () => { + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + return { stdout: "git@github.com:pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "feature/code-links\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/feature/code-links": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "ls-files --error-unmatch -- apps/server/src/index.ts": + return { stdout: "apps/server/src/index.ts\n", stderr: "" }; + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + + await expect( + resolveGitHubBlobUrlForLocalPath("/repo/apps/server/src/index.ts:42", { execFile }), + ).resolves.toBe( + "https://github.com/pingdotgg/t3code/blob/feature/code-links/apps/server/src/index.ts#L42", + ); + }); + + it("falls back to the current commit sha for detached or local-only worktree refs", async () => { + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + return { stdout: "https://github.com/pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "abc123def456\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "t3code/1dd39f28\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/t3code/1dd39f28": + throw new Error("missing remote branch"); + case "ls-files --error-unmatch -- packages/contracts/src/settings.ts": + return { stdout: "packages/contracts/src/settings.ts\n", stderr: "" }; + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + + await expect( + resolveGitHubBlobUrlForLocalPath("/repo/packages/contracts/src/settings.ts:316", { + execFile, + }), + ).resolves.toBe( + "https://github.com/pingdotgg/t3code/blob/abc123def456/packages/contracts/src/settings.ts#L316", + ); + }); + + it("returns null for files outside a GitHub-backed repo", async () => { + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + if (key === "rev-parse --show-toplevel") { + return { stdout: "/repo\n", stderr: "" }; + } + if (key === "remote get-url origin") { + return { stdout: "https://gitlab.com/pingdotgg/t3code.git\n", stderr: "" }; + } + if (key === "rev-parse HEAD") { + return { stdout: "abc123def456\n", stderr: "" }; + } + throw new Error(`Unexpected git call: ${key}`); + }; + + await expect(resolveGitHubBlobUrlForLocalPath("/repo/file.ts:1", { execFile })).resolves.toBe( + null, + ); + }); + + it("reuses cached repo context across multiple files in one repo", async () => { + let remoteCallCount = 0; + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + remoteCallCount += 1; + return { stdout: "git@github.com:pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "abc123def456\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "main\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/main": + return { stdout: "abc123def456\n", stderr: "" }; + case "ls-files --error-unmatch -- a.ts": + return { stdout: "a.ts\n", stderr: "" }; + case "ls-files --error-unmatch -- b.ts": + return { stdout: "b.ts\n", stderr: "" }; + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + const repoContextCache = new Map(); + + await resolveGitHubBlobUrlForLocalPath("/repo/a.ts:1", { execFile, repoContextCache }); + await resolveGitHubBlobUrlForLocalPath("/repo/b.ts:2", { execFile, repoContextCache }); + + expect(remoteCallCount).toBe(1); + }); + + it("returns null for untracked files inside the repo", async () => { + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + return { stdout: "git@github.com:pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "abc123def456\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "main\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/main": + return { stdout: "abc123def456\n", stderr: "" }; + case "ls-files --error-unmatch -- tmp/generated-report.html": + throw new Error("not tracked"); + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + + await expect( + resolveGitHubBlobUrlForLocalPath("/repo/tmp/generated-report.html:1", { execFile }), + ).resolves.toBe(null); + }); +}); + +describe("resolveGitHubBlobUrlForPathReference", () => { + it("resolves repo-relative line ranges against the provided cwd", async () => { + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + return { stdout: "git@github.com:pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "main\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/main": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "ls-files --error-unmatch -- api/src/EasyLife/Standard/RealPacking.Controllers.ts": + return { + stdout: "api/src/EasyLife/Standard/RealPacking.Controllers.ts\n", + stderr: "", + }; + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + + await expect( + resolveGitHubBlobUrlForPathReference( + "api/src/EasyLife/Standard/RealPacking.Controllers.ts:186-212", + { + cwd: "/repo", + execFile, + }, + ), + ).resolves.toBe( + "https://github.com/pingdotgg/t3code/blob/main/api/src/EasyLife/Standard/RealPacking.Controllers.ts#L186", + ); + }); +}); + +describe("GitHub link resolution cache", () => { + it("reuses git results across independent and concurrent resolutions", async () => { + const calls = new Map(); + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + calls.set(key, (calls.get(key) ?? 0) + 1); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + return { stdout: "git@github.com:pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "main\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/main": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "ls-files --error-unmatch -- apps/server/src/index.ts": + return { stdout: "apps/server/src/index.ts\n", stderr: "" }; + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + const cache = createGitHubLinkResolutionCache(); + const options = { cache, execFile }; + + const [first, second] = await Promise.all([ + resolveGitHubBlobUrlForLocalPath("/repo/apps/server/src/index.ts:10", options), + resolveGitHubBlobUrlForLocalPath("/repo/apps/server/src/index.ts:20", options), + ]); + const third = await resolveGitHubBlobUrlForLocalPath( + "/repo/apps/server/src/index.ts:30", + options, + ); + const workspaceUrl = await resolveGitHubUrlForWorkspace("/repo", options); + + expect(first).toContain("#L10"); + expect(second).toContain("#L20"); + expect(third).toContain("#L30"); + expect(workspaceUrl).toBe("https://github.com/pingdotgg/t3code"); + expect([...calls.values()].every((count) => count === 1)).toBe(true); + }); + + it("refreshes tracked state after its short TTL", async () => { + let now = 0; + let tracked = true; + let trackedCalls = 0; + const execFile = async (_file: string, args: ReadonlyArray) => { + const key = args.slice(2).join(" "); + switch (key) { + case "rev-parse --show-toplevel": + return { stdout: "/repo\n", stderr: "" }; + case "remote get-url origin": + return { stdout: "git@github.com:pingdotgg/t3code.git\n", stderr: "" }; + case "rev-parse HEAD": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "symbolic-ref --quiet --short HEAD": + return { stdout: "main\n", stderr: "" }; + case "rev-parse --verify --quiet refs/remotes/origin/main": + return { stdout: "deadbeefcafebabe\n", stderr: "" }; + case "ls-files --error-unmatch -- generated/report.html": + trackedCalls += 1; + if (!tracked) throw new Error("not tracked"); + return { stdout: "generated/report.html\n", stderr: "" }; + default: + throw new Error(`Unexpected git call: ${key}`); + } + }; + const cache = createGitHubLinkResolutionCache({ now: () => now, trackedPathTtlMs: 10 }); + const options = { cache, execFile }; + + await expect( + resolveGitHubBlobUrlForLocalPath("/repo/generated/report.html", options), + ).resolves.toContain("/generated/report.html"); + tracked = false; + await expect( + resolveGitHubBlobUrlForLocalPath("/repo/generated/report.html", options), + ).resolves.toContain("/generated/report.html"); + + now = 11; + await expect( + resolveGitHubBlobUrlForLocalPath("/repo/generated/report.html", options), + ).resolves.toBeNull(); + expect(trackedCalls).toBe(2); + }); +}); diff --git a/apps/discord-bot/src/presentation/githubLinks.ts b/apps/discord-bot/src/presentation/githubLinks.ts new file mode 100644 index 000000000000..26982a531142 --- /dev/null +++ b/apps/discord-bot/src/presentation/githubLinks.ts @@ -0,0 +1,408 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeChildProcess from "node:child_process"; +import * as NodePath from "node:path"; +import * as NodeUtil from "node:util"; + +const execFile = NodeUtil.promisify(NodeChildProcess.execFile); + +type ExecFileResult = { + readonly stdout: string; + readonly stderr: string; +}; + +type ExecFileLike = ( + file: string, + args: ReadonlyArray, + options?: NodeChildProcess.ExecFileOptions, +) => Promise; + +interface ParsedPathPosition { + readonly path: string; + readonly line?: number | undefined; +} + +interface GitHubRepositoryContext { + readonly repoRoot: string; + readonly githubUrl: string; + readonly ref: string; +} + +interface CacheEntry { + readonly expiresAt: number; + readonly value: Promise; +} + +export interface GitHubLinkResolutionCache { + readonly repositoryRoots: Map>; + readonly repositoryUrls: Map>; + readonly repositoryContexts: Map>; + readonly trackedPaths: Map>; + readonly now: () => number; + readonly maxEntries: number; + readonly repositoryRootTtlMs: number; + readonly repositoryContextTtlMs: number; + readonly trackedPathTtlMs: number; +} + +const DEFAULT_CACHE_OPTIONS = { + maxEntries: 2_048, + repositoryRootTtlMs: 60_000, + repositoryContextTtlMs: 15_000, + trackedPathTtlMs: 5_000, +} as const; + +export function createGitHubLinkResolutionCache( + options: Partial< + Pick< + GitHubLinkResolutionCache, + "maxEntries" | "repositoryRootTtlMs" | "repositoryContextTtlMs" | "trackedPathTtlMs" | "now" + > + > = {}, +): GitHubLinkResolutionCache { + return { + repositoryRoots: new Map(), + repositoryUrls: new Map(), + repositoryContexts: new Map(), + trackedPaths: new Map(), + now: options.now ?? Date.now, + maxEntries: options.maxEntries ?? DEFAULT_CACHE_OPTIONS.maxEntries, + repositoryRootTtlMs: options.repositoryRootTtlMs ?? DEFAULT_CACHE_OPTIONS.repositoryRootTtlMs, + repositoryContextTtlMs: + options.repositoryContextTtlMs ?? DEFAULT_CACHE_OPTIONS.repositoryContextTtlMs, + trackedPathTtlMs: options.trackedPathTtlMs ?? DEFAULT_CACHE_OPTIONS.trackedPathTtlMs, + }; +} + +const sharedResolutionCache = createGitHubLinkResolutionCache(); + +function cached(input: { + readonly entries: Map>; + readonly key: string; + readonly ttlMs: number; + readonly cache: GitHubLinkResolutionCache; + readonly load: () => Promise; +}): Promise { + const now = input.cache.now(); + const existing = input.entries.get(input.key); + if (existing && existing.expiresAt > now) { + return existing.value; + } + if (existing) input.entries.delete(input.key); + + while (input.entries.size >= input.cache.maxEntries) { + const oldest = input.entries.keys().next().value; + if (oldest === undefined) break; + input.entries.delete(oldest); + } + + const value = input.load(); + input.entries.set(input.key, { expiresAt: now + input.ttlMs, value }); + return value; +} + +/** + * Ensure git is discoverable even when the process PATH is a minimal systemd + * default that omits environment.systemPackages (common in the microVM units). + */ +export function gitCommandEnv(env: NodeJS.ProcessEnv = globalThis.process.env): NodeJS.ProcessEnv { + const prefixes = ["/run/current-system/sw/bin", "/usr/bin", "/bin"]; + const current = env.PATH ?? ""; + const merged = [...prefixes, ...current.split(":").filter((part) => part.length > 0)]; + return { + ...env, + PATH: [...new Set(merged)].join(":"), + }; +} + +function splitPathAndPosition(value: string): ParsedPathPosition { + let path = value; + let line: number | undefined; + + const columnMatch = path.match(/:(\d+)$/u); + if (!columnMatch?.[1]) { + return { path }; + } + + const trailing = Number.parseInt(columnMatch[1], 10); + path = path.slice(0, -columnMatch[0].length); + + const lineMatch = path.match(/:(\d+)$/u); + if (lineMatch?.[1]) { + line = Number.parseInt(lineMatch[1], 10); + path = path.slice(0, -lineMatch[0].length); + } else { + line = trailing; + } + + return Number.isFinite(line) ? { path, line } : { path }; +} + +function parsePathReference(value: string): ParsedPathPosition { + const trimmed = value.trim(); + const rangeMatch = + /^(?.+?\.[A-Za-z0-9_-]{1,16}):(?\d+)(?:-\d+)?(?:,\d+(?:-\d+)?)*$/u.exec(trimmed); + if (rangeMatch?.groups?.path && rangeMatch.groups.line) { + const line = Number.parseInt(rangeMatch.groups.line, 10); + return Number.isFinite(line) ? { path: rangeMatch.groups.path, line } : { path: trimmed }; + } + return splitPathAndPosition(trimmed); +} + +async function runGit( + cwd: string, + args: ReadonlyArray, + execImpl: ExecFileLike, +): Promise { + try { + const { stdout } = await execImpl("git", ["-C", cwd, ...args], { + cwd, + env: gitCommandEnv(), + }); + const trimmed = stdout.trim(); + return trimmed.length > 0 ? trimmed : null; + } catch { + return null; + } +} + +async function resolveRepositoryContext( + repoRoot: string, + execImpl: ExecFileLike, + cache: GitHubLinkResolutionCache | null, +): Promise { + const githubUrl = await resolveRepositoryGitHubUrl(repoRoot, execImpl, cache); + if (!githubUrl) { + return null; + } + + const sha = await runGit(repoRoot, ["rev-parse", "HEAD"], execImpl); + if (!sha) { + return null; + } + + const branch = await runGit(repoRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"], execImpl); + if (!branch) { + return { repoRoot, githubUrl, ref: sha }; + } + + const remoteBranch = await runGit( + repoRoot, + ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${branch}`], + execImpl, + ); + + return { + repoRoot, + githubUrl, + ref: remoteBranch ? branch : sha, + }; +} + +async function resolveRepositoryGitHubUrl( + repoRoot: string, + execImpl: ExecFileLike, + cache: GitHubLinkResolutionCache | null, +): Promise { + const load = async () => { + const remoteUrl = await runGit(repoRoot, ["remote", "get-url", "origin"], execImpl); + return remoteUrl ? normalizeGitHubRemoteUrl(remoteUrl) : null; + }; + return cache + ? cached({ + entries: cache.repositoryUrls, + key: repoRoot, + ttlMs: cache.repositoryRootTtlMs, + cache, + load, + }) + : load(); +} + +async function isTrackedRepositoryPath( + repoRoot: string, + relativePath: string, + execImpl: ExecFileLike, +): Promise { + try { + await execImpl("git", ["-C", repoRoot, "ls-files", "--error-unmatch", "--", relativePath], { + cwd: repoRoot, + env: gitCommandEnv(), + }); + return true; + } catch { + return false; + } +} + +function resolutionCache(options: { + readonly execFile?: ExecFileLike | undefined; + readonly cache?: GitHubLinkResolutionCache | undefined; +}): GitHubLinkResolutionCache | null { + if (options.cache) return options.cache; + // Test/custom executors must never share results with production git calls. + return options.execFile ? null : sharedResolutionCache; +} + +function encodeGitHubPath(value: string): string { + return value + .split("/") + .filter((segment) => segment.length > 0) + .map((segment) => encodeURIComponent(segment)) + .join("/"); +} + +function buildGitHubBlobUrl(input: { + readonly githubUrl: string; + readonly ref: string; + readonly relativePath: string; + readonly line?: number | undefined; +}): string { + const refPath = encodeGitHubPath(input.ref); + const relativePath = encodeGitHubPath(input.relativePath.replaceAll("\\", "/")); + const hash = input.line !== undefined ? `#L${input.line}` : ""; + return `${input.githubUrl}/blob/${refPath}/${relativePath}${hash}`; +} + +export function normalizeGitHubRemoteUrl(remoteUrl: string): string | null { + const trimmed = remoteUrl.trim(); + if (trimmed.length === 0) return null; + + // SCP-like, including deploy-key / machine users (e.g. org-123@github.com:owner/repo). + const scpLike = /^(?:[\w.-]+@)?github\.com:([^/\s]+)\/(.+?)(?:\.git)?$/u.exec(trimmed); + if (scpLike) { + return `https://github.com/${scpLike[1]}/${scpLike[2]}`; + } + + // ssh:// with optional user and optional port (ssh.github.com is GitHub's HTTPS-port SSH endpoint). + const sshLike = + /^ssh:\/\/(?:[\w.-]+@)?(?:github\.com|ssh\.github\.com)(?::\d+)?\/([^/\s]+)\/(.+?)(?:\.git)?$/u.exec( + trimmed, + ); + if (sshLike) { + return `https://github.com/${sshLike[1]}/${sshLike[2]}`; + } + + try { + const url = new URL(trimmed); + const host = url.hostname.toLowerCase(); + if (host !== "github.com" && host !== "www.github.com" && host !== "ssh.github.com") { + return null; + } + const path = url.pathname.replace(/\.git$/u, "").replace(/\/+$/u, ""); + if (path === "" || !path.includes("/", 1)) return null; + return `https://github.com${path}`; + } catch { + return null; + } +} + +export async function resolveGitHubBlobUrlForLocalPath( + filePath: string, + options?: { + readonly execFile?: ExecFileLike | undefined; + readonly repoContextCache?: Map | undefined; + readonly cache?: GitHubLinkResolutionCache | undefined; + }, +): Promise { + const execImpl = options?.execFile ?? execFile; + const parsed = parsePathReference(filePath); + if (!NodePath.isAbsolute(parsed.path)) { + return null; + } + + const fileDirectory = NodePath.dirname(parsed.path); + const cache = resolutionCache(options ?? {}); + const repoRoot = cache + ? await cached({ + entries: cache.repositoryRoots, + key: fileDirectory, + ttlMs: cache.repositoryRootTtlMs, + cache, + load: () => runGit(fileDirectory, ["rev-parse", "--show-toplevel"], execImpl), + }) + : await runGit(fileDirectory, ["rev-parse", "--show-toplevel"], execImpl); + if (!repoRoot) { + return null; + } + + const requestCache = options?.repoContextCache; + const cachedContext = requestCache?.get(repoRoot); + const context = + cachedContext !== undefined + ? cachedContext + : cache + ? await cached({ + entries: cache.repositoryContexts, + key: repoRoot, + ttlMs: cache.repositoryContextTtlMs, + cache, + load: () => resolveRepositoryContext(repoRoot, execImpl, cache), + }) + : await resolveRepositoryContext(repoRoot, execImpl, null); + if (cachedContext === undefined) { + requestCache?.set(repoRoot, context); + } + if (!context) { + return null; + } + + const relativePath = NodePath.relative(context.repoRoot, parsed.path); + if (relativePath === "" || relativePath.startsWith("..") || NodePath.isAbsolute(relativePath)) { + return null; + } + const trackedCacheKey = `${context.repoRoot}\0${relativePath}`; + const tracked = cache + ? await cached({ + entries: cache.trackedPaths, + key: trackedCacheKey, + ttlMs: cache.trackedPathTtlMs, + cache, + load: () => isTrackedRepositoryPath(context.repoRoot, relativePath, execImpl), + }) + : await isTrackedRepositoryPath(context.repoRoot, relativePath, execImpl); + if (!tracked) { + return null; + } + + return buildGitHubBlobUrl({ + githubUrl: context.githubUrl, + ref: context.ref, + relativePath, + line: parsed.line, + }); +} + +export async function resolveGitHubBlobUrlForPathReference( + pathReference: string, + options?: { + readonly cwd?: string | undefined; + readonly execFile?: ExecFileLike | undefined; + readonly repoContextCache?: Map | undefined; + readonly cache?: GitHubLinkResolutionCache | undefined; + }, +): Promise { + const parsed = parsePathReference(pathReference); + const absolutePath = NodePath.isAbsolute(parsed.path) + ? parsed.path + : options?.cwd + ? NodePath.resolve(options.cwd, parsed.path) + : null; + if (absolutePath === null) { + return null; + } + + const suffix = parsed.line !== undefined ? `:${parsed.line}` : ""; + return resolveGitHubBlobUrlForLocalPath(`${absolutePath}${suffix}`, options); +} + +export async function resolveGitHubUrlForWorkspace( + workspaceRoot: string, + options?: { + readonly execFile?: ExecFileLike | undefined; + readonly cache?: GitHubLinkResolutionCache | undefined; + }, +): Promise { + const execImpl = options?.execFile ?? execFile; + const cache = resolutionCache(options ?? {}); + return resolveRepositoryGitHubUrl(NodePath.resolve(workspaceRoot), execImpl, cache); +} diff --git a/apps/discord-bot/src/presentation/jiraLinks.test.ts b/apps/discord-bot/src/presentation/jiraLinks.test.ts new file mode 100644 index 000000000000..513e7aa24c11 --- /dev/null +++ b/apps/discord-bot/src/presentation/jiraLinks.test.ts @@ -0,0 +1,179 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + extractJiraIssueKeys, + extractJiraIssueKeysFromDiscordMessage, + formatJiraLinksForDiscord, + jiraBrowseUrl, + jiraIssueKeysAfterExcludingSentryFalsePositives, + jiraIssueKeysMaskedBySentryContext, + mergeJiraIssueKeys, + normalizeJiraIssueKey, + resolveJiraBrowseBaseUrl, +} from "./jiraLinks.ts"; + +describe("normalizeJiraIssueKey", () => { + it("uppercases valid keys", () => { + expect(normalizeJiraIssueKey("proj-367")).toBe("PROJ-367"); + expect(normalizeJiraIssueKey("ACV2-642")).toBe("ACV2-642"); + }); + + it("rejects invalid shapes", () => { + expect(normalizeJiraIssueKey("EXAMPLE-PROJECT-API-JW")).toBeNull(); + expect(normalizeJiraIssueKey("not-a-key")).toBeNull(); + expect(normalizeJiraIssueKey("A-1")).toBeNull(); + }); +}); + +describe("resolveJiraBrowseBaseUrl", () => { + it("keeps classic atlassian site roots", () => { + expect(resolveJiraBrowseBaseUrl("https://example.atlassian.net/")).toBe( + "https://example.atlassian.net", + ); + expect(resolveJiraBrowseBaseUrl("https://example.atlassian.net/browse/PROJ-1")).toBe( + "https://example.atlassian.net", + ); + }); + + it("rejects API gateway URLs that are not browse sites", () => { + expect( + resolveJiraBrowseBaseUrl( + "https://api.atlassian.com/ex/jira/a6978c4b-b79e-4b1f-83ea-c537c2b19316", + ), + ).toBeUndefined(); + }); +}); + +describe("extractJiraIssueKeys", () => { + it("extracts bare keys in first-seen order without duplicates", () => { + expect( + extractJiraIssueKeys("Please look at PROJ-367 then PROJ-400 and PROJ-367 again"), + ).toEqual(["PROJ-367", "PROJ-400"]); + }); + + it("extracts keys from browse URLs and selectedIssue params", () => { + const text = [ + "https://example.atlassian.net/browse/PROJ-100", + "also https://example.atlassian.net/jira/software/c/projects/SA/boards/1?selectedIssue=PROJ-200", + "and PROJ-100 again", + ].join(" "); + expect(extractJiraIssueKeys(text)).toEqual(["PROJ-100", "PROJ-200"]); + }); + + it("reads embeds as well as content", () => { + expect( + extractJiraIssueKeysFromDiscordMessage({ + content: "ping", + embeds: [ + { + url: "https://example.atlassian.net/browse/PROJ-50", + title: "PROJ-50 Fix packing", + }, + ], + }), + ).toEqual(["PROJ-50"]); + }); + + it("does not treat sentry.io short ids as Jira keys", () => { + expect(extractJiraIssueKeys("see https://macs-scanner.sentry.io/issues/SCANNER-313/")).toEqual( + [], + ); + expect( + extractJiraIssueKeysFromDiscordMessage({ + author: { username: "Sentry", bot: true }, + content: "", + embeds: [ + { + title: "T3 did not become ready after a server restart", + url: "https://macs-scanner.sentry.io/issues/7506163172/", + footer: { text: "SCANNER-313" }, + }, + ], + }), + ).toEqual([]); + }); + + it("still extracts Atlassian keys next to a Sentry embed", () => { + expect( + extractJiraIssueKeysFromDiscordMessage({ + author: { username: "Sentry", bot: true }, + content: "also https://example.atlassian.net/browse/PROJ-9", + embeds: [ + { + url: "https://macs-scanner.sentry.io/issues/7506163172/", + footer: { text: "SCANNER-313" }, + }, + ], + }), + ).toEqual(["PROJ-9"]); + }); +}); + +describe("sentry-masked Jira false positives", () => { + it("returns the Sentry short id so stored Jira keys can be dropped", () => { + expect( + jiraIssueKeysMaskedBySentryContext({ + author: { username: "Sentry", bot: true }, + embeds: [ + { + url: "https://macs-scanner.sentry.io/issues/7506163172/", + footer: { text: "SCANNER-313" }, + }, + ], + }), + ).toEqual(["SCANNER-313"]); + }); + + it("drops stored Sentry short ids unless they were also extracted as real Jira", () => { + expect( + jiraIssueKeysAfterExcludingSentryFalsePositives( + ["SCANNER-313", "PROJ-1"], + ["PROJ-1"], + ["SCANNER-313"], + ), + ).toEqual(["PROJ-1"]); + expect( + jiraIssueKeysAfterExcludingSentryFalsePositives( + ["SCANNER-313"], + ["SCANNER-313"], + ["SCANNER-313"], + ), + ).toEqual(["SCANNER-313"]); + }); +}); + +describe("mergeJiraIssueKeys", () => { + it("appends only new keys in order", () => { + expect(mergeJiraIssueKeys(["PROJ-1", "PROJ-2"], ["PROJ-2", "PROJ-3", "proj-1"])).toEqual([ + "PROJ-1", + "PROJ-2", + "PROJ-3", + ]); + }); +}); + +describe("formatJiraLinksForDiscord", () => { + it("renders markdown links when browse base is set", () => { + expect(formatJiraLinksForDiscord(["PROJ-367"], "https://example.atlassian.net")).toBe( + ["**Jira**", "• [PROJ-367](https://example.atlassian.net/browse/PROJ-367)"].join("\n"), + ); + }); + + it("falls back to bare keys without a browse base", () => { + expect(formatJiraLinksForDiscord(["PROJ-367"], undefined)).toBe( + ["**Jira**", "• `PROJ-367`"].join("\n"), + ); + }); + + it("returns null for empty key lists", () => { + expect(formatJiraLinksForDiscord([], "https://example.atlassian.net")).toBeNull(); + }); +}); + +describe("jiraBrowseUrl", () => { + it("builds browse URLs", () => { + expect(jiraBrowseUrl("https://example.atlassian.net", "proj-367")).toBe( + "https://example.atlassian.net/browse/PROJ-367", + ); + }); +}); diff --git a/apps/discord-bot/src/presentation/jiraLinks.ts b/apps/discord-bot/src/presentation/jiraLinks.ts new file mode 100644 index 000000000000..59384fc3156b --- /dev/null +++ b/apps/discord-bot/src/presentation/jiraLinks.ts @@ -0,0 +1,247 @@ +/** + * Extract and format Jira issue keys / browse links from Discord message text. + * + * Keys are stored in first-seen order. Duplicates are ignored (case-insensitive match + * with canonical uppercase key form). + * + * Sentry short ids (`SCANNER-313`) match the Jira key shape. Tokens inside sentry.io + * URLs, Sentry Discord embeds, or Sentry-bot messages are not treated as Jira. + */ + +import { + discordMessageLooksLikeSentry, + sentryIssueUrlRanges, + type SentryDiscordMessageInput, +} from "./sentryLinks.ts"; + +/** Classic Jira issue key: PROJ-123 (project 2–10 alnum chars, numeric id). */ +const JIRA_ISSUE_KEY_PATTERN = /\b([A-Z][A-Z0-9]{1,9}-\d{1,7})\b/g; + +/** Browse-style Atlassian URLs that embed an issue key. */ +const JIRA_BROWSE_URL_PATTERN = + /https?:\/\/[^\s<>"']+\.atlassian\.net\/(?:browse|jira\/browse)\/([A-Z][A-Z0-9]{1,9}-\d{1,7})(?:[^\s<>"']*)?/gi; + +/** Board / issue navigator deep links: ?selectedIssue=PROJ-123 */ +const JIRA_SELECTED_ISSUE_PATTERN = /[?&]selectedIssue=([A-Z][A-Z0-9]{1,9}-\d{1,7})\b/gi; + +const FALSE_POSITIVE_KEYS = new Set([ + // Common non-Jira tokens that match the key shape + "UTF-8", + "ISO-8601", + "HTTP-1", + "HTTP-2", + "TLS-1", +]); + +export function normalizeJiraIssueKey(raw: string): string | null { + const key = raw.trim().toUpperCase(); + if (!/^[A-Z][A-Z0-9]{1,9}-\d{1,7}$/u.test(key)) return null; + if (FALSE_POSITIVE_KEYS.has(key)) return null; + return key; +} + +/** + * Strip trailing slash and normalize a browse base URL. + * Accepts either `https://org.atlassian.net` or a full API URL that embeds the site. + */ +export function resolveJiraBrowseBaseUrl(raw: string | undefined | null): string | undefined { + if (raw === undefined || raw === null) return undefined; + const trimmed = raw.trim().replace(/\/+$/u, ""); + if (trimmed.length === 0) return undefined; + + // Classic site URL + const siteMatch = trimmed.match(/^(https?:\/\/[a-z0-9.-]+\.atlassian\.net)(?:\/.*)?$/iu); + if (siteMatch?.[1] !== undefined) return siteMatch[1]; + + // Leave non-atlassian bases as-is when they look like a site root (no /ex/jira/) + if (/^https?:\/\//iu.test(trimmed) && !trimmed.includes("/ex/jira/")) { + return trimmed; + } + return undefined; +} + +export function jiraBrowseUrl(baseUrl: string | undefined, key: string): string | null { + const normalized = normalizeJiraIssueKey(key); + if (normalized === null) return null; + const base = resolveJiraBrowseBaseUrl(baseUrl); + if (base === undefined) return null; + return `${base}/browse/${normalized}`; +} + +export type ExtractJiraIssueKeysOptions = { + /** + * When false, only keys from Atlassian browse / selectedIssue URLs are returned. + * Default true, unless the text already contains a sentry.io URL (bare keys in + * that blob are Sentry short ids, not Jira). + */ + readonly includeBareKeys?: boolean; + /** Skip tokens whose match index sits inside a sentry.io URL. Default true. */ + readonly skipSentryUrls?: boolean; +}; + +type JiraKeyHit = { readonly index: number; readonly key: string }; + +function collectJiraKeyHits( + text: string, + patterns: ReadonlyArray, + sentryRanges: ReadonlyArray<{ readonly start: number; readonly end: number }>, + skipSentryUrls: boolean, +): JiraKeyHit[] { + const hits: JiraKeyHit[] = []; + for (const pattern of patterns) { + pattern.lastIndex = 0; + let match: RegExpExecArray | null; + while ((match = pattern.exec(text)) !== null) { + const matchIndex = match.index; + if ( + skipSentryUrls && + sentryRanges.some((range) => matchIndex >= range.start && matchIndex < range.end) + ) { + continue; + } + const key = normalizeJiraIssueKey(match[1] ?? ""); + if (key === null) continue; + hits.push({ index: matchIndex, key }); + } + } + hits.sort((a, b) => a.index - b.index || a.key.localeCompare(b.key)); + return hits; +} + +const ATLASSIAN_KEY_PATTERNS = [JIRA_BROWSE_URL_PATTERN, JIRA_SELECTED_ISSUE_PATTERN]; +const ALL_KEY_PATTERNS = [...ATLASSIAN_KEY_PATTERNS, JIRA_ISSUE_KEY_PATTERN]; + +/** + * Extract issue keys from free text (message content, embed fields, etc.) + * in left-to-right first-seen order without duplicates. + */ +export function extractJiraIssueKeys( + text: string | null | undefined, + options?: ExtractJiraIssueKeysOptions, +): ReadonlyArray { + if (text === null || text === undefined || text.length === 0) return []; + + const skipSentryUrls = options?.skipSentryUrls ?? true; + const sentryRanges = + skipSentryUrls || options?.includeBareKeys === false ? sentryIssueUrlRanges(text) : []; + const includeBareKeys = + options?.includeBareKeys ?? (skipSentryUrls ? sentryRanges.length === 0 : true); + + const found: string[] = []; + const seen = new Set(); + const patterns = includeBareKeys ? ALL_KEY_PATTERNS : ATLASSIAN_KEY_PATTERNS; + for (const hit of collectJiraKeyHits(text, patterns, sentryRanges, skipSentryUrls)) { + if (seen.has(hit.key)) continue; + seen.add(hit.key); + found.push(hit.key); + } + return found; +} + +function joinDiscordMessageText(input: SentryDiscordMessageInput): string { + const parts: string[] = []; + if (input.content) parts.push(input.content); + for (const embed of input.embeds ?? []) { + if (embed.url) parts.push(embed.url); + if (embed.title) parts.push(embed.title); + if (embed.description) parts.push(embed.description); + if (embed.footer?.text) parts.push(embed.footer.text); + } + return parts.join("\n"); +} + +export function extractJiraIssueKeysFromDiscordMessage( + input: SentryDiscordMessageInput, +): ReadonlyArray { + const text = joinDiscordMessageText(input); + const sentryContext = discordMessageLooksLikeSentry(input); + return extractJiraIssueKeys(text, { + includeBareKeys: !sentryContext, + skipSentryUrls: true, + }); +} + +/** + * Jira-shaped tokens in a Sentry alert / sentry.io URL that must not be stored as Jira keys. + * Atlassian browse URLs in the same message are kept (not returned here). + */ +export function jiraIssueKeysMaskedBySentryContext( + input: SentryDiscordMessageInput, +): ReadonlyArray { + const text = joinDiscordMessageText(input); + const sentryContext = discordMessageLooksLikeSentry(input); + const sentryRanges = sentryIssueUrlRanges(text); + if (!sentryContext && sentryRanges.length === 0) return []; + + const atlassianOnly = new Set( + extractJiraIssueKeys(text, { includeBareKeys: false, skipSentryUrls: true }), + ); + return extractJiraIssueKeys(text, { includeBareKeys: true, skipSentryUrls: false }).filter( + (key) => !atlassianOnly.has(key), + ); +} + +export function jiraIssueKeysMaskedBySentryFromMessages( + messages: ReadonlyArray, +): ReadonlyArray { + const keys: string[] = []; + for (const message of messages) { + if (message === null || message === undefined) continue; + keys.push(...jiraIssueKeysMaskedBySentryContext(message)); + } + return mergeJiraIssueKeys([], keys); +} + +/** Drop `omit` from `keys` (canonical uppercase), preserving first-seen order. */ +export function omitJiraIssueKeys( + keys: ReadonlyArray | null | undefined, + omit: ReadonlyArray | null | undefined, +): ReadonlyArray { + const dropped = new Set(mergeJiraIssueKeys([], omit)); + if (dropped.size === 0) return mergeJiraIssueKeys([], keys); + return mergeJiraIssueKeys([], keys).filter((key) => !dropped.has(key)); +} + +/** + * Merge stored + newly extracted Jira keys, then drop Sentry short ids that were + * never independently extracted from a non-Sentry message / Atlassian URL. + */ +export function jiraIssueKeysAfterExcludingSentryFalsePositives( + existing: ReadonlyArray | null | undefined, + extracted: ReadonlyArray | null | undefined, + sentryMasked: ReadonlyArray | null | undefined, +): ReadonlyArray { + const keptExtracted = mergeJiraIssueKeys([], extracted); + const drop = omitJiraIssueKeys(sentryMasked, keptExtracted); + return omitJiraIssueKeys(mergeJiraIssueKeys(existing, keptExtracted), drop); +} + +/** Append newly seen keys preserving first-seen order; never duplicates. */ +export function mergeJiraIssueKeys( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, +): ReadonlyArray { + const result: string[] = []; + const seen = new Set(); + for (const raw of [...(existing ?? []), ...(incoming ?? [])]) { + const key = normalizeJiraIssueKey(raw); + if (key === null || seen.has(key)) continue; + seen.add(key); + result.push(key); + } + return result; +} + +export function formatJiraLinksForDiscord( + keys: ReadonlyArray, + browseBaseUrl: string | undefined, +): string | null { + const ordered = mergeJiraIssueKeys([], keys); + if (ordered.length === 0) return null; + + const lines = ordered.map((key) => { + const url = jiraBrowseUrl(browseBaseUrl, key); + return url === null ? `• \`${key}\`` : `• [${key}](${url})`; + }); + return ["**Jira**", ...lines].join("\n"); +} diff --git a/apps/discord-bot/src/presentation/markdownFiles.test.ts b/apps/discord-bot/src/presentation/markdownFiles.test.ts new file mode 100644 index 000000000000..7b6700cd2a5a --- /dev/null +++ b/apps/discord-bot/src/presentation/markdownFiles.test.ts @@ -0,0 +1,118 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { describe, expect, it } from "vite-plus/test"; + +import { + extractMarkdownLocalFileLinks, + fileNameForLocalFileRef, + guessFileMimeType, + isLocalFileSrc, + replaceMarkdownLocalFileLinks, + resolveLocalFilePathOnDisk, + stripMarkdownLocalFileLinks, +} from "./markdownFiles.ts"; + +const SAMPLE_CSV_PATH = "/tmp/carrier_usage/label_ops_proxy.csv"; + +describe("extractMarkdownLocalFileLinks", () => { + it("parses local csv markdown links", () => { + const text = `And the extracted table here: +[label_ops_proxy.csv](${SAMPLE_CSV_PATH})`; + const files = extractMarkdownLocalFileLinks(text); + expect(files).toHaveLength(1); + expect(files[0]?.src).toBe(SAMPLE_CSV_PATH); + expect(files[0]?.label).toBe("label_ops_proxy.csv"); + }); + + it("parses local file links with line numbers", () => { + const text = `[githubLinks.ts](/tmp/project/githubLinks.ts:96)`; + const files = extractMarkdownLocalFileLinks(text); + expect(files).toHaveLength(1); + expect(files[0]?.src).toBe("/tmp/project/githubLinks.ts"); + expect(files[0]?.target).toBe("/tmp/project/githubLinks.ts:96"); + }); + + it("ignores http links and local image links", () => { + const text = ` +[report.csv](https://example.com/report.csv) +[graph.png](/tmp/carrier_usage/graph.png) +`; + expect(extractMarkdownLocalFileLinks(text)).toEqual([]); + }); +}); + +describe("stripMarkdownLocalFileLinks", () => { + it("removes local file links but keeps surrounding prose", () => { + const text = `I saved the file here: + +[label_ops_proxy.csv](<${SAMPLE_CSV_PATH}>) + +Use it if you need exact counts.`; + const stripped = stripMarkdownLocalFileLinks(text); + expect(stripped).not.toContain("label_ops_proxy.csv]("); + expect(stripped).toContain("I saved the file here:"); + expect(stripped).toContain("Use it if you need exact counts."); + }); + + it("can replace local file links with readable attached markers", () => { + const text = `I saved the file here: + +[label_ops_proxy.csv](<${SAMPLE_CSV_PATH}>)`; + const replaced = replaceMarkdownLocalFileLinks(text, (ref) => `${ref.label} (attached below)`); + expect(replaced).toContain("I saved the file here:"); + expect(replaced).toContain("label_ops_proxy.csv (attached below)"); + expect(replaced).not.toContain("]("); + }); +}); + +describe("local file helpers", () => { + it("detects attachment: and relative local files", () => { + expect(isLocalFileSrc(`attachment:${SAMPLE_CSV_PATH}`)).toBe(true); + expect(isLocalFileSrc("./artifacts/table.csv")).toBe(true); + expect(isLocalFileSrc("https://example.com/table.csv")).toBe(false); + }); + + it("uses the visible label for the Discord attachment name", () => { + const ref = extractMarkdownLocalFileLinks(`[carrier data](${SAMPLE_CSV_PATH})`)[0]; + expect(ref).toBeDefined(); + expect(fileNameForLocalFileRef(ref!)).toBe("carrier_data.csv"); + }); + + it("guesses csv mime types", () => { + expect(guessFileMimeType(SAMPLE_CSV_PATH)).toBe("text/plain;charset=utf-8"); + expect(guessFileMimeType("/tmp/data.json")).toBe("text/plain;charset=utf-8"); + }); + + it("uses native media types for audio and video previews", () => { + expect(guessFileMimeType("/tmp/clip.mp4")).toBe("video/mp4"); + expect(guessFileMimeType("/tmp/voice.mp3")).toBe("audio/mpeg"); + }); +}); + +describe("resolveLocalFilePathOnDisk", () => { + it("resolves worktree-relative plan paths that agents emit", () => { + const tempRoot = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-discord-md-file-")); + try { + const plansDir = NodePath.join(tempRoot, ".plans"); + const relativeFile = ".plans/abas-markisen-agent-collisions.md"; + const absoluteFile = NodePath.join(tempRoot, relativeFile); + NodeFS.mkdirSync(plansDir, { recursive: true }); + NodeFS.writeFileSync(absoluteFile, "# note\n", "utf8"); + + expect(resolveLocalFilePathOnDisk(relativeFile, tempRoot)).toBe( + NodePath.normalize(absoluteFile), + ); + expect(resolveLocalFilePathOnDisk(`./${relativeFile}`, tempRoot)).toBe( + NodePath.normalize(absoluteFile), + ); + // Absolute path still works when present. + expect(resolveLocalFilePathOnDisk(absoluteFile, null)).toBe(NodePath.normalize(absoluteFile)); + // Without worktree, bot cwd cannot see the project-relative path. + expect(resolveLocalFilePathOnDisk(relativeFile, null)).toBeNull(); + } finally { + NodeFS.rmSync(tempRoot, { recursive: true, force: true }); + } + }); +}); diff --git a/apps/discord-bot/src/presentation/markdownFiles.ts b/apps/discord-bot/src/presentation/markdownFiles.ts new file mode 100644 index 000000000000..430b31f8410c --- /dev/null +++ b/apps/discord-bot/src/presentation/markdownFiles.ts @@ -0,0 +1,225 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; + +import { + assertFilesystemPath, + guessImageMimeType, + normalizeLocalImagePath, +} from "./markdownImages.ts"; + +export interface MarkdownLocalFileRef { + readonly label: string; + /** Normalized filesystem path without any :line or :line:column suffix. */ + readonly src: string; + /** Normalized link target including any :line or :line:column suffix. */ + readonly target: string; + /** Original destination before normalization (for debugging). */ + readonly rawSrc: string; + /** Full match including the markdown link syntax. */ + readonly match: string; +} + +/** [label](url) / [label]() */ +const MARKDOWN_LINK = /(?]+?)>?\s*\)/g; + +function splitLocalFileTarget(value: string): { + readonly path: string; + readonly line?: string | undefined; + readonly column?: string | undefined; +} { + let path = value; + let column: string | undefined; + let line: string | undefined; + + const columnMatch = path.match(/:(\d+)$/u); + if (!columnMatch?.[1]) { + return { path }; + } + + column = columnMatch[1]; + path = path.slice(0, -columnMatch[0].length); + + const lineMatch = path.match(/:(\d+)$/u); + if (lineMatch?.[1]) { + line = lineMatch[1]; + path = path.slice(0, -lineMatch[0].length); + } else { + line = column; + column = undefined; + } + + return { path, line, column }; +} + +function hasFileLikeName(path: string): boolean { + const base = path.split(/[/\\]/).at(-1) ?? ""; + return /\.[A-Za-z0-9_-]{1,16}$/u.test(base); +} + +export function isLocalFileSrc(src: string): boolean { + const raw = src.trim(); + if (raw === "") return false; + if (/^https?:\/\//i.test(raw)) return false; + if (/^data:/i.test(raw)) return false; + + const normalized = normalizeLocalImagePath(raw); + if (normalized === "") return false; + if (/^https?:\/\//i.test(normalized) || /^data:/i.test(normalized)) return false; + if (/\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(normalized)) return false; + + if (normalized.startsWith("/") || /^[A-Za-z]:[\\/]/.test(normalized)) return true; + if (normalized.startsWith("./") || normalized.startsWith("../")) return true; + return hasFileLikeName(normalized); +} + +function looksLikeLocalFileTarget(rawSrc: string): boolean { + if (!isLocalFileSrc(rawSrc)) return false; + return hasFileLikeName(splitLocalFileTarget(normalizeLocalImagePath(rawSrc)).path); +} + +export function extractMarkdownLocalFileLinks(text: string): ReadonlyArray { + const results: MarkdownLocalFileRef[] = []; + const seen = new Set(); + + for (const match of text.matchAll(MARKDOWN_LINK)) { + const full = match[0]; + const label = (match[1] ?? "").trim(); + const rawSrc = (match[2] ?? "").trim(); + if (full === undefined || rawSrc === "") continue; + if (!looksLikeLocalFileTarget(rawSrc)) continue; + + const target = normalizeLocalImagePath(rawSrc); + const src = splitLocalFileTarget(target).path; + const key = `${target}::${full}`; + if (seen.has(key)) continue; + seen.add(key); + results.push({ + label, + src, + target, + rawSrc, + match: full, + }); + } + + return results; +} + +export function stripMarkdownLocalFileLinks(text: string): string { + const refs = extractMarkdownLocalFileLinks(text); + let out = text; + const ordered = [...refs].sort((a, b) => b.match.length - a.match.length); + for (const ref of ordered) { + out = out.split(ref.match).join(""); + } + return out.replace(/\n{3,}/g, "\n\n").trimEnd(); +} + +export function replaceMarkdownLocalFileLinks( + text: string, + replacer: (ref: MarkdownLocalFileRef) => string, +): string { + const refs = extractMarkdownLocalFileLinks(text); + let out = text; + const ordered = [...refs].sort((a, b) => b.match.length - a.match.length); + for (const ref of ordered) { + out = out.split(ref.match).join(replacer(ref)); + } + return out.replace(/\n{3,}/g, "\n\n").trimEnd(); +} + +export function fileNameForLocalFileRef(ref: MarkdownLocalFileRef): string { + const path = assertFilesystemPath(ref.src); + const base = path.split(/[/\\]/).at(-1) ?? "attachment.bin"; + const ext = /\.[A-Za-z0-9_-]{1,16}$/u.exec(base)?.[0] ?? ""; + + const label = ref.label + .trim() + .replace(/[^\w.-]+/g, "_") + .replace(/_+/g, "_") + .replace(/^_|_$/g, "") + .slice(0, 128); + if (label.length > 0) { + if (ext !== "" && !label.toLowerCase().endsWith(ext.toLowerCase())) { + return `${label}${ext}`; + } + return label; + } + return base; +} + +/** + * Resolve a local markdown-linked file to an absolute path on disk. + * + * Agents usually write worktree-relative targets (`.plans/note.md`, `./out.csv`). + * The Discord bot process cwd is the bot package — resolve against `worktreePath` + * first so relative embeds actually upload. + */ +export function resolveLocalFilePathOnDisk( + path: string, + worktreePath?: string | null, +): string | null { + const normalized = assertFilesystemPath(path); + if (normalized === "" || /^https?:\/\//i.test(normalized) || /^data:/i.test(normalized)) { + return null; + } + + if (NodePath.isAbsolute(normalized)) { + return NodeFS.existsSync(normalized) ? NodePath.normalize(normalized) : null; + } + + const rel = normalized.replace(/^\.\//u, ""); + const roots: string[] = []; + const worktree = worktreePath?.trim() ?? ""; + if (worktree !== "") { + roots.push(worktree); + } + // Fallbacks when worktree is unknown (local / no-worktree threads). + roots.push(process.cwd()); + + for (const root of roots) { + const candidate = NodePath.join(root, rel); + if (NodeFS.existsSync(candidate) && NodeFS.statSync(candidate).isFile()) { + return NodePath.normalize(candidate); + } + } + + return null; +} + +export function guessFileMimeType(filePath: string): string { + const lower = filePath.toLowerCase(); + if (/\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(lower)) { + return guessImageMimeType(lower); + } + if (lower.endsWith(".mp4")) return "video/mp4"; + if (lower.endsWith(".mov")) return "video/quicktime"; + if (lower.endsWith(".webm")) return "video/webm"; + if (lower.endsWith(".m4v")) return "video/x-m4v"; + if (lower.endsWith(".mp3")) return "audio/mpeg"; + if (lower.endsWith(".m4a")) return "audio/mp4"; + if (lower.endsWith(".wav")) return "audio/wav"; + if (lower.endsWith(".ogg")) return "audio/ogg"; + if (lower.endsWith(".flac")) return "audio/flac"; + // Discord documents preview support for plain text files rather than + // structured formats like CSV/JSON specifically, so prefer text/plain for + // text-ish artifacts to preserve the best chance of inline preview. + if ( + lower.endsWith(".csv") || + lower.endsWith(".txt") || + lower.endsWith(".log") || + lower.endsWith(".md") || + lower.endsWith(".json") || + lower.endsWith(".yaml") || + lower.endsWith(".yml") + ) { + return "text/plain;charset=utf-8"; + } + if (lower.endsWith(".pdf")) return "application/pdf"; + if (lower.endsWith(".zip")) return "application/zip"; + if (lower.endsWith(".gz")) return "application/gzip"; + return "application/octet-stream"; +} + +export { assertFilesystemPath }; diff --git a/apps/discord-bot/src/presentation/markdownImages.test.ts b/apps/discord-bot/src/presentation/markdownImages.test.ts new file mode 100644 index 000000000000..a9b5f54c6758 --- /dev/null +++ b/apps/discord-bot/src/presentation/markdownImages.test.ts @@ -0,0 +1,131 @@ +// @effect-diagnostics nodeBuiltinImport:off +import { describe, expect, it } from "vite-plus/test"; + +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { + assertFilesystemPath, + extractMarkdownImages, + fileNameForImageRef, + isLocalImageSrc, + normalizeLocalImagePath, + resolveImagePathOnDisk, + stripMarkdownImages, +} from "./markdownImages.ts"; + +const SAMPLE_PATH = + "/var/lib/t3/.codex/generated_images/019f6511-7b93-7663-9908-41e3f45b5bac/call_5K1KcXmRdTGulQT91c2PtIl6.png"; + +describe("extractMarkdownImages", () => { + it("parses markdown images with angle brackets", () => { + const text = `![EasyLife]()`; + const images = extractMarkdownImages(text); + expect(images).toHaveLength(1); + expect(images[0]?.src).toContain("generated_images"); + expect(images[0]?.src.startsWith("attachment:")).toBe(false); + }); + + it("parses HTML img tags like Discord screenshot", () => { + const text = `EasyLife weekday activity estimate graph + +I can't force this client to inline a local filesystem image.`; + const images = extractMarkdownImages(text); + expect(images).toHaveLength(1); + expect(images[0]?.src).toBe(SAMPLE_PATH); + expect(images[0]?.alt).toContain("EasyLife"); + const stripped = stripMarkdownImages(text); + expect(stripped).not.toContain(" { + const text = `The image file is here: + +[call_5K1KcXmRdTGulQT91c2PtIl6.png](<${SAMPLE_PATH}>) + +If you want, I can regenerate it.`; + const images = extractMarkdownImages(text); + expect(images).toHaveLength(1); + expect(images[0]?.src).toBe(SAMPLE_PATH); + const stripped = stripMarkdownImages(text); + expect(stripped).not.toContain("call_5K1Kc"); + expect(stripped).toContain("If you want"); + }); + + it("extracts both html img and md link from the same message", () => { + const text = `EasyLife graph + +I can't force this client. + +[call_5K1KcXmRdTGulQT91c2PtIl6.png](<${SAMPLE_PATH}>) + +Regenerate?`; + const images = extractMarkdownImages(text); + // Same path twice is fine — load once by src key; extract may return both embeds + expect(images.length).toBeGreaterThanOrEqual(1); + expect(images.every((i) => i.src === SAMPLE_PATH)).toBe(true); + const stripped = stripMarkdownImages(text); + expect(stripped).not.toContain(" { + expect(normalizeLocalImagePath(`attachment:${SAMPLE_PATH}`)).toBe(SAMPLE_PATH); + expect(assertFilesystemPath(`attachment:${SAMPLE_PATH}`)).toBe(SAMPLE_PATH); + expect(isLocalImageSrc(`attachment:${SAMPLE_PATH}`)).toBe(true); + }); + + it("extracts attachment: markdown images", () => { + const text = `![EasyLife](attachment:${SAMPLE_PATH})`; + const images = extractMarkdownImages(text); + expect(images).toHaveLength(1); + expect(images[0]?.src).toBe(SAMPLE_PATH); + // Prefer human alt for Discord attachment name (image preview still uses .png). + expect(fileNameForImageRef(images[0]!)).toBe("EasyLife.png"); + }); + + it("falls back to path basename when alt is empty", () => { + const text = `![](${SAMPLE_PATH})`; + const images = extractMarkdownImages(text); + expect(images).toHaveLength(1); + expect(fileNameForImageRef(images[0]!)).toBe("call_5K1KcXmRdTGulQT91c2PtIl6.png"); + }); + + it("treats Grok session-relative images/1.jpg as a local image", () => { + const text = `Here’s a soft blush peony:\n\n![Beautiful flower](images/1.jpg)\n`; + const images = extractMarkdownImages(text); + expect(images).toHaveLength(1); + expect(images[0]?.src).toBe("images/1.jpg"); + expect(fileNameForImageRef(images[0]!)).toBe("Beautiful_flower.jpg"); + }); +}); + +describe("resolveImagePathOnDisk", () => { + it("resolves Grok session-relative images under a sessions tree", () => { + const root = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-mdimg-")); + const sessionImages = NodePath.join(root, "encoded-cwd", "session-id", "images"); + NodeFS.mkdirSync(sessionImages, { recursive: true }); + const absolute = NodePath.join(sessionImages, "1.jpg"); + NodeFS.writeFileSync(absolute, Buffer.from([0xff, 0xd8, 0xff, 0xd9])); // minimal jpeg-ish + + // Point search at our temp root by temporarily resolving via absolute path existence first. + expect(resolveImagePathOnDisk(absolute)).toBe(absolute); + + // Relative form: only finds files under HOME/.grok/sessions in prod. For unit coverage, + // verify absolute + cwd cases; relative search is integration-tested on the guest. + const cwdRel = NodePath.join(root, "images"); + NodeFS.mkdirSync(cwdRel, { recursive: true }); + const cwdFile = NodePath.join(cwdRel, "2.png"); + NodeFS.writeFileSync(cwdFile, Buffer.from([1, 2, 3])); + const prev = process.cwd(); + try { + process.chdir(root); + expect(resolveImagePathOnDisk("images/2.png")).toBe(NodeFS.realpathSync(cwdFile)); + } finally { + process.chdir(prev); + } + }); +}); diff --git a/apps/discord-bot/src/presentation/markdownImages.ts b/apps/discord-bot/src/presentation/markdownImages.ts new file mode 100644 index 000000000000..4484837ce962 --- /dev/null +++ b/apps/discord-bot/src/presentation/markdownImages.ts @@ -0,0 +1,339 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Agents embed local filesystem images in several wire formats: + * ![alt](/var/lib/t3/.codex/generated_images/.../file.png) + * ![alt](attachment:/var/lib/...) + * ... + * [file.png]() + * ![alt](images/1.jpg) — Grok ImageGen session-relative path + * + * Discord cannot render host paths — they must become real multipart file attachments. + */ +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +export interface MarkdownImageRef { + readonly alt: string; + /** Normalized filesystem path (never has attachment: / file:// prefixes). */ + readonly src: string; + /** Original destination before normalization (for debugging). */ + readonly rawSrc: string; + /** Full match including the embed syntax */ + readonly match: string; +} + +/** ![alt](url) and ![alt]() */ +const MARKDOWN_IMAGE = /!\[([^\]]*)\]\(\s*]+?)>?\s*\)/g; + +/** [label](url) / [label]() — only treated as images when the target looks local+image */ +const MARKDOWN_LINK = /(?]+?)>?\s*\)/g; + +/** HTML ... (attribute order flexible enough for common agent output) */ +const HTML_IMG = + /]*\bsrc\s*=\s*["']([^"']+)["'][^>]*\/?>|]*\bsrc\s*=\s*([^\s>]+)[^>]*\/?>/gi; + +/** ACP / Codex media scheme prefixes that are not real filesystem paths. */ +const MEDIA_SCHEME_PREFIX = /^(?:attachment:\/?\/?|file:\/\/)/i; + +const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp|svg)$/i; + +/** + * Normalize agent/Codex image targets to a bare filesystem path (or leave http(s)). + * Always strips angle brackets and attachment:/file:// schemes — repeatedly if nested. + */ +export function normalizeLocalImagePath(src: string): string { + let value = src.trim(); + if (value.startsWith("<") && value.endsWith(">")) { + value = value.slice(1, -1).trim(); + } + + // Strip media schemes until gone. + // IMPORTANT: only strip the scheme token — keep the leading `/` of absolute paths. + // attachment:/var/lib/... → /var/lib/... + for (let i = 0; i < 4; i += 1) { + if (/^https?:\/\//i.test(value) || /^data:/i.test(value)) { + return value; + } + if (/^attachment:/i.test(value)) { + value = value.replace(/^attachment:/i, "").trim(); + if (value.startsWith("//")) { + value = `/${value.replace(/^\/+/, "")}`; + } + continue; + } + if (/^file:/i.test(value)) { + try { + value = decodeURIComponent(new URL(value).pathname); + if (/^\/[A-Za-z]:[\\/]/.test(value)) { + value = value.slice(1); + } + } catch { + value = value + .replace(/^file:\/\//i, "") + .replace(/^file:/i, "") + .trim(); + } + continue; + } + break; + } + + return value; +} + +/** + * True when the image target is a local path rather than an http(s) URL. + */ +export function isLocalImageSrc(src: string): boolean { + const raw = src.trim(); + if (raw === "") return false; + if (/^https?:\/\//i.test(raw)) return false; + if (/^data:/i.test(raw)) return false; + if (MEDIA_SCHEME_PREFIX.test(raw) || /^attachment:/i.test(raw)) return true; + if (/^file:/i.test(raw)) return true; + const value = normalizeLocalImagePath(raw); + if (value === "") return false; + if (/^https?:\/\//i.test(value)) return false; + if (value.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(value)) return true; + if (value.startsWith("./") || value.startsWith("../")) return true; + if (IMAGE_EXT.test(value)) return true; + if (value.includes("generated_images")) return true; + return false; +} + +function looksLikeLocalImageTarget(rawSrc: string): boolean { + if (!isLocalImageSrc(rawSrc)) return false; + const path = normalizeLocalImagePath(rawSrc); + return IMAGE_EXT.test(path) || path.includes("generated_images"); +} + +function pushUnique( + results: MarkdownImageRef[], + seen: Set, + input: { alt: string; rawSrc: string; match: string }, +): void { + const rawSrc = input.rawSrc.trim(); + if (rawSrc === "") return; + if (!looksLikeLocalImageTarget(rawSrc) && !isLocalImageSrc(rawSrc)) return; + // Require image-like path for link/html to avoid stripping normal file links. + if (!looksLikeLocalImageTarget(rawSrc)) return; + + const src = normalizeLocalImagePath(rawSrc); + const key = `${src}::${input.match}`; + if (seen.has(key)) return; + seen.add(key); + results.push({ + alt: input.alt, + src, + rawSrc, + match: input.match, + }); +} + +/** + * Extract every local image embed the agent might have put in the message: + * markdown images, HTML , and markdown links to image files. + */ +export function extractMarkdownImages(text: string): ReadonlyArray { + const results: MarkdownImageRef[] = []; + const seen = new Set(); + + for (const match of text.matchAll(MARKDOWN_IMAGE)) { + const full = match[0]; + if (full === undefined) continue; + pushUnique(results, seen, { + alt: match[1] ?? "", + rawSrc: (match[2] ?? "").trim(), + match: full, + }); + } + + for (const match of text.matchAll(HTML_IMG)) { + const full = match[0]; + if (full === undefined) continue; + const rawSrc = (match[1] ?? match[2] ?? "").trim(); + const altMatch = /\balt\s*=\s*["']([^"']*)["']/i.exec(full); + pushUnique(results, seen, { + alt: altMatch?.[1] ?? "", + rawSrc, + match: full, + }); + } + + for (const match of text.matchAll(MARKDOWN_LINK)) { + const full = match[0]; + if (full === undefined) continue; + // Skip if already captured as markdown image (negative lookbehind is imperfect in JS). + if (full.startsWith("![")) continue; + pushUnique(results, seen, { + alt: match[1] ?? "", + rawSrc: (match[2] ?? "").trim(), + match: full, + }); + } + + return results; +} + +/** Remove all recognized local image embeds (md image, html img, md link-to-image). */ +export function stripMarkdownImages( + text: string, + predicate: (ref: MarkdownImageRef) => boolean = () => true, +): string { + const refs = extractMarkdownImages(text).filter(predicate); + let out = text; + // Remove longest matches first so nested/overlapping cases stay stable. + const ordered = [...refs].sort((a, b) => b.match.length - a.match.length); + for (const ref of ordered) { + out = out.split(ref.match).join(""); + } + return out.replace(/\n{3,}/g, "\n\n").trimEnd(); +} + +export function guessImageMimeType(filePath: string): string { + const lower = filePath.toLowerCase(); + if (lower.endsWith(".png")) return "image/png"; + if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg"; + if (lower.endsWith(".gif")) return "image/gif"; + if (lower.endsWith(".webp")) return "image/webp"; + if (lower.endsWith(".bmp")) return "image/bmp"; + if (lower.endsWith(".svg")) return "image/svg+xml"; + return "application/octet-stream"; +} + +/** + * Discord attachment filename — extension drives image preview vs generic file chip. + * Prefer a human alt when present; fall back to the path basename. + */ +export function fileNameForImageRef(ref: MarkdownImageRef): string { + const path = normalizeLocalImagePath(ref.src); + const base = path.split(/[/\\]/).at(-1) ?? "image.png"; + const extMatch = IMAGE_EXT.exec(base); + const ext = extMatch?.[0]?.toLowerCase() ?? ".png"; + + const alt = ref.alt + .trim() + .replace(/[^\w.-]+/g, "_") + .replace(/_+/g, "_") + .replace(/^_|_$/g, "") + .slice(0, 64); + if (alt.length > 0 && !/^call_[A-Za-z0-9]+$/i.test(alt)) { + return IMAGE_EXT.test(alt) ? alt : `${alt}${ext}`; + } + if (IMAGE_EXT.test(base)) return base; + return `image${ext}`; +} + +/** Guard: never return a path that still starts with a media scheme. */ +export function assertFilesystemPath(path: string): string { + const normalized = normalizeLocalImagePath(path); + if (/^attachment:/i.test(normalized) || /^file:/i.test(normalized)) { + throw new Error(`Refusing to open media-scheme path: ${JSON.stringify(path)}`); + } + return normalized; +} + +function safeStatMtimeMs(path: string): number { + try { + return NodeFS.statSync(path).mtimeMs; + } catch { + return 0; + } +} + +/** + * Bounded walk for files under `root` whose path ends with `relativeSuffix` + * (e.g. `images/1.jpg`) or whose basename matches when under an `images/` dir. + * Returns newest match first. Depth-capped so large trees stay cheap. + */ +function findRecentImageFiles( + root: string, + relativeSuffix: string, + fileBase: string, + maxDepth = 6, + maxHits = 8, +): string[] { + if (!NodeFS.existsSync(root)) return []; + const suffix = relativeSuffix + .replace(/^\.?\//, "") + .split(/[/\\]/) + .join(NodePath.sep); + const hits: Array<{ path: string; mtime: number }> = []; + + const walk = (dir: string, depth: number) => { + if (hits.length >= maxHits || depth > maxDepth) return; + let entries: ReadonlyArray<{ name: string; isDirectory: () => boolean; isFile: () => boolean }>; + try { + entries = NodeFS.readdirSync(dir, { withFileTypes: true }); + } catch { + return; + } + for (const ent of entries) { + if (hits.length >= maxHits) return; + const full = NodePath.join(dir, ent.name); + if (ent.isDirectory()) { + walk(full, depth + 1); + continue; + } + if (!ent.isFile()) continue; + if (!IMAGE_EXT.test(ent.name)) continue; + const relFromRoot = full.slice(root.length).replace(/^[/\\]/, ""); + const underImages = `${NodePath.sep}images${NodePath.sep}${fileBase}`; + const match = + relFromRoot === suffix || + relFromRoot.endsWith(`${NodePath.sep}${suffix}`) || + (fileBase !== "" && (relFromRoot.endsWith(underImages) || ent.name === fileBase)); + if (!match) continue; + // Prefer Grok/Codex generated locations over random repo assets named 1.jpg. + const preferred = + relFromRoot.includes(`${NodePath.sep}images${NodePath.sep}`) || + full.includes(`${NodePath.sep}.grok${NodePath.sep}sessions${NodePath.sep}`) || + full.includes(`${NodePath.sep}.codex${NodePath.sep}generated_images${NodePath.sep}`); + if (!preferred && !relFromRoot.endsWith(suffix) && relFromRoot !== suffix) continue; + hits.push({ path: full, mtime: safeStatMtimeMs(full) }); + } + }; + + walk(root, 0); + return hits.sort((a, b) => b.mtime - a.mtime).map((h) => h.path); +} + +/** + * Resolve a markdown image target to an on-disk absolute path. + * + * Grok ImageGen embeds session-relative paths like `images/1.jpg` while the real + * file lives under `~/.grok/sessions///images/1.jpg`. + * Codex usually emits absolute paths under `~/.codex/generated_images/…`. + */ +export function resolveImagePathOnDisk(path: string): string | null { + const normalized = assertFilesystemPath(path); + if (normalized === "" || /^https?:\/\//i.test(normalized) || /^data:/i.test(normalized)) { + return null; + } + + if (NodePath.isAbsolute(normalized)) { + return NodeFS.existsSync(normalized) ? NodePath.normalize(normalized) : null; + } + + const rel = normalized.replace(/^\.\//, ""); + const fromCwd = NodePath.join(process.cwd(), rel); + if (NodeFS.existsSync(fromCwd)) return NodePath.normalize(fromCwd); + + const home = NodeOS.homedir(); + const fileBase = NodePath.basename(rel); + const searchRoots = [ + NodePath.join(home, ".grok", "sessions"), + NodePath.join(home, ".codex", "generated_images"), + // Guest data layout (bot runs as t3; HOME may already be /var/lib/t3). + "/var/lib/t3/.grok/sessions", + "/var/lib/t3/.codex/generated_images", + ]; + + for (const root of searchRoots) { + const hits = findRecentImageFiles(root, rel, fileBase); + if (hits[0] !== undefined) return hits[0]; + } + + return null; +} diff --git a/apps/discord-bot/src/presentation/markdownTables.test.ts b/apps/discord-bot/src/presentation/markdownTables.test.ts new file mode 100644 index 000000000000..01df56a5e25b --- /dev/null +++ b/apps/discord-bot/src/presentation/markdownTables.test.ts @@ -0,0 +1,154 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + extractMarkdownTables, + hasMarkdownTables, + isSeparatorRow, + renderTableAsBullets, + rewriteMarkdownTablesForDiscord, + splitTableCells, +} from "./markdownTables.ts"; + +describe("splitTableCells", () => { + it("splits on unescaped pipes and trims cells", () => { + expect(splitTableCells("| Doc | What it is |")).toEqual(["Doc", "What it is"]); + expect(splitTableCells("Doc | What it is")).toEqual(["Doc", "What it is"]); + }); + + it("keeps escaped pipes inside a cell", () => { + expect(splitTableCells("| a \\| b | c |")).toEqual(["a | b", "c"]); + }); +}); + +describe("isSeparatorRow", () => { + it("accepts GFM separator cells", () => { + expect(isSeparatorRow(["---", ":---", "---:", ":---:"])).toBe(true); + expect(isSeparatorRow(["Doc", "What"])).toBe(false); + }); +}); + +describe("extractMarkdownTables", () => { + it("extracts a short unfenced table", () => { + const text = `| Doc | What it actually is | +|---|---| +| effect-cluster-worker-migration.md | Mixed topology notes. | +| durable-print-roundtrip.md | EasyLife workflow. |`; + + const matches = extractMarkdownTables(text); + expect(matches).toHaveLength(1); + expect(matches[0]?.headers).toEqual(["Doc", "What it actually is"]); + expect(matches[0]?.rows).toEqual([ + ["effect-cluster-worker-migration.md", "Mixed topology notes."], + ["durable-print-roundtrip.md", "EasyLife workflow."], + ]); + }); + + it("extracts a table wrapped in a code fence", () => { + const text = `\`\`\`md +| Doc | What | +|---|---| +| a.md | first | +\`\`\``; + const matches = extractMarkdownTables(text); + expect(matches).toHaveLength(1); + expect(matches[0]?.headers).toEqual(["Doc", "What"]); + expect(matches[0]?.rows).toEqual([["a.md", "first"]]); + expect(matches[0]?.raw.startsWith("```")).toBe(true); + }); + + it("returns empty when there is no complete table", () => { + expect(extractMarkdownTables("just a paragraph\nand another")).toEqual([]); + expect(extractMarkdownTables("| not a table without separator |")).toEqual([]); + }); + + it("requires at least two columns", () => { + const text = `| Note | +|---| +| only |`; + expect(extractMarkdownTables(text)).toEqual([]); + }); +}); + +describe("renderTableAsBullets", () => { + it("formats two-column tables as labeled bullets", () => { + expect( + renderTableAsBullets( + ["Piece", "Behavior"], + [ + ["Event Hub meta", "enqueuedTimeUtc + sequenceNumber"], + ["Logging", "Warning with order id"], + ], + ), + ).toBe( + [ + "- **Event Hub meta:** enqueuedTimeUtc + sequenceNumber", + "- **Logging:** Warning with order id", + ].join("\n"), + ); + }); + + it("formats wider tables with header labels per field", () => { + expect( + renderTableAsBullets( + ["Name", "Amount", "Unit"], + [ + ["a", "10", "kg"], + ["b", "2", "g"], + ], + ), + ).toBe( + [ + "- **Name:** a · **Amount:** 10 · **Unit:** kg", + "- **Name:** b · **Amount:** 2 · **Unit:** g", + ].join("\n"), + ); + }); +}); + +describe("rewriteMarkdownTablesForDiscord", () => { + it("rewrites a short table to bullets and drops pipe syntax", () => { + const input = `| Doc | What | +|---|---| +| a.md | first |`; + const result = rewriteMarkdownTablesForDiscord(input); + expect(result).toBe("- **a.md:** first"); + expect(result).not.toContain("|"); + expect(result).not.toContain("---"); + }); + + it("preserves surrounding text", () => { + const input = `Before. + +| A | B | +|---|---| +| 1 | 2 | + +After.`; + const result = rewriteMarkdownTablesForDiscord(input); + expect(result.startsWith("Before.")).toBe(true); + expect(result.endsWith("After.")).toBe(true); + expect(result).toContain("- **1:** 2"); + expect(result).not.toContain("|---|"); + }); + + it("is a passthrough when there is no table", () => { + const input = "No tables here, just prose."; + expect(rewriteMarkdownTablesForDiscord(input)).toBe(input); + }); + + it("replaces fenced markdown tables", () => { + const input = `\`\`\`md +| Doc | What | +|---|---| +| a.md | first | +\`\`\``; + const result = rewriteMarkdownTablesForDiscord(input); + expect(result).not.toContain("```"); + expect(result).toBe("- **a.md:** first"); + }); + + it("hasMarkdownTables tracks complete tables only", () => { + expect(hasMarkdownTables("| Doc | What |\n|---|---|\n| a | b |")).toBe(true); + expect(hasMarkdownTables("no table")).toBe(false); + }); +}); diff --git a/apps/discord-bot/src/presentation/markdownTables.ts b/apps/discord-bot/src/presentation/markdownTables.ts new file mode 100644 index 000000000000..28bed7f90fe6 --- /dev/null +++ b/apps/discord-bot/src/presentation/markdownTables.ts @@ -0,0 +1,275 @@ +/** + * Detect GFM pipe tables and rewrite them for Discord delivery. + * Discord does not render markdown tables; raw pipes are unreadable. + * Convert complete tables to bullet lists (content kept, grid dropped). + */ + +export interface TableMatch { + /** Inclusive start offset of the matched source span. */ + readonly start: number; + /** Exclusive end offset of the matched source span. */ + readonly end: number; + /** Original matched text (may include surrounding code fences). */ + readonly raw: string; + readonly headers: ReadonlyArray; + readonly rows: ReadonlyArray>; +} + +/** Split a markdown table row into cells on unescaped `|`. */ +export function splitTableCells(line: string): string[] { + let body = line.trim(); + if (body.startsWith("|")) body = body.slice(1); + if (body.endsWith("|")) body = body.slice(0, -1); + + const cells: string[] = []; + let current = ""; + let escaped = false; + for (const char of body) { + if (escaped) { + current += char; + escaped = false; + continue; + } + if (char === "\\") { + escaped = true; + continue; + } + if (char === "|") { + cells.push(unescapeTableCell(current.trim())); + current = ""; + continue; + } + current += char; + } + cells.push(unescapeTableCell(current.trim())); + return cells; +} + +function unescapeTableCell(value: string): string { + return value + .replace(/\\([\\|`*_{}[\]()#+\-.!])/g, "$1") + .replace(/\s+/g, " ") + .trim(); +} + +/** True when every cell looks like a GFM separator segment (`---`, `:---:`, etc.). */ +export function isSeparatorRow(cells: ReadonlyArray): boolean { + if (cells.length === 0) return false; + return cells.every((cell) => /^:?-{1,}:?$/.test(cell.replace(/\s+/g, ""))); +} + +function isTableRowLine(line: string): boolean { + const trimmed = line.trim(); + if (trimmed.length === 0) return false; + if (!trimmed.includes("|")) return false; + if (trimmed.startsWith("```")) return false; + return true; +} + +function normalizeRow(cells: ReadonlyArray, columnCount: number): string[] { + const row = cells.slice(0, columnCount).map((cell) => cell); + while (row.length < columnCount) row.push(""); + return row; +} + +function tryParseTableLines( + lines: ReadonlyArray, + startIndex: number, +): { + readonly endIndex: number; + readonly headers: string[]; + readonly rows: string[][]; +} | null { + if (startIndex + 1 >= lines.length) return null; + const headerLine = lines[startIndex] ?? ""; + const separatorLine = lines[startIndex + 1] ?? ""; + if (!isTableRowLine(headerLine) || !isTableRowLine(separatorLine)) return null; + + const headers = splitTableCells(headerLine); + const separatorCells = splitTableCells(separatorLine); + if (headers.length === 0 || !isSeparatorRow(separatorCells)) return null; + // Require ≥2 columns so bash/prose like `| note` + `|---` is not treated as a table. + if (headers.length < 2 || separatorCells.length < 2) return null; + if (Math.abs(headers.length - separatorCells.length) > 1) return null; + + const columnCount = Math.max(headers.length, separatorCells.length); + const normalizedHeaders = normalizeRow(headers, columnCount); + const rows: string[][] = []; + let endIndex = startIndex + 1; + + for (let index = startIndex + 2; index < lines.length; index += 1) { + const line = lines[index] ?? ""; + if (!isTableRowLine(line)) break; + const cells = splitTableCells(line); + if (isSeparatorRow(cells)) break; + rows.push(normalizeRow(cells, columnCount)); + endIndex = index; + } + + if (rows.length === 0) return null; + return { endIndex, headers: normalizedHeaders, rows }; +} + +/** Exclusive end offset for `lineIndex`, including its trailing newline when present. */ +function lineEndExclusive( + text: string, + lineStarts: ReadonlyArray, + lines: ReadonlyArray, + lineIndex: number, +): number { + const start = lineStarts[lineIndex] ?? text.length; + const line = lines[lineIndex] ?? ""; + let exclusiveEnd = start + line.length; + if (exclusiveEnd < text.length && (text[exclusiveEnd] === "\n" || text[exclusiveEnd] === "\r")) { + exclusiveEnd = + text[exclusiveEnd] === "\r" && text[exclusiveEnd + 1] === "\n" + ? exclusiveEnd + 2 + : exclusiveEnd + 1; + } + return exclusiveEnd; +} + +/** + * Find GFM pipe tables in `text`. + * Also matches tables wrapped in fenced code blocks (``` / ```bash / etc.). + */ +export function extractMarkdownTables(text: string): TableMatch[] { + const matches: TableMatch[] = []; + const lineStarts: number[] = [0]; + for (let index = 0; index < text.length; index += 1) { + if (text[index] === "\n") lineStarts.push(index + 1); + } + const lines = text.split(/\r?\n/); + + let lineIndex = 0; + while (lineIndex < lines.length) { + const line = lines[lineIndex] ?? ""; + const fenceOpen = line.match(/^(\s*)```([\w+-]*)\s*$/); + if (fenceOpen) { + const openIndex = lineIndex; + let closeIndex = -1; + for (let probe = lineIndex + 1; probe < lines.length; probe += 1) { + if (/^\s*```\s*$/.test(lines[probe] ?? "")) { + closeIndex = probe; + break; + } + } + if (closeIndex === -1) { + lineIndex += 1; + continue; + } + + const innerStart = openIndex + 1; + let tableStart = innerStart; + while (tableStart < closeIndex && (lines[tableStart] ?? "").trim() === "") { + tableStart += 1; + } + const parsed = tryParseTableLines(lines, tableStart); + if (parsed !== null) { + let afterTable = parsed.endIndex + 1; + while (afterTable < closeIndex && (lines[afterTable] ?? "").trim() === "") { + afterTable += 1; + } + if (afterTable === closeIndex) { + const start = lineStarts[openIndex] ?? 0; + const exclusiveEnd = lineEndExclusive(text, lineStarts, lines, closeIndex); + matches.push({ + start, + end: exclusiveEnd, + raw: text.slice(start, exclusiveEnd), + headers: parsed.headers, + rows: parsed.rows, + }); + lineIndex = closeIndex + 1; + continue; + } + } + lineIndex = closeIndex + 1; + continue; + } + + const parsed = tryParseTableLines(lines, lineIndex); + if (parsed === null) { + lineIndex += 1; + continue; + } + + const start = lineStarts[lineIndex] ?? 0; + const exclusiveEnd = lineEndExclusive(text, lineStarts, lines, parsed.endIndex); + matches.push({ + start, + end: exclusiveEnd, + raw: text.slice(start, exclusiveEnd), + headers: parsed.headers, + rows: parsed.rows, + }); + lineIndex = parsed.endIndex + 1; + } + + return matches; +} + +/** True when `text` contains at least one GFM pipe table. */ +export function hasMarkdownTables(text: string): boolean { + return extractMarkdownTables(text).length > 0; +} + +/** + * Render a GFM table as Discord-readable bullets. + * Two-column tables use `- **left:** right`. Wider tables use labeled fields per row. + */ +export function renderTableAsBullets( + headers: ReadonlyArray, + rows: ReadonlyArray>, +): string { + if (rows.length === 0) { + return headers + .map((header) => header.trim()) + .filter((header) => header.length > 0) + .map((header) => `- ${header}`) + .join("\n"); + } + + if (headers.length === 2) { + return rows + .map((row) => { + const key = (row[0] ?? "").trim() || (headers[0] ?? "").trim() || "Item"; + const value = (row[1] ?? "").trim(); + if (value === "") return `- **${key}**`; + return `- **${key}:** ${value}`; + }) + .join("\n"); + } + + return rows + .map((row) => { + const parts: string[] = []; + for (let index = 0; index < headers.length; index += 1) { + const header = (headers[index] ?? "").trim() || `Col ${index + 1}`; + const cell = (row[index] ?? "").trim(); + if (cell === "") continue; + parts.push(`**${header}:** ${cell}`); + } + if (parts.length === 0) return null; + return `- ${parts.join(" · ")}`; + }) + .filter((line): line is string => line !== null) + .join("\n"); +} + +/** + * Replace GFM pipe tables with bullet lists for Discord channel content. + * Incomplete mid-stream tables (no separator / rows yet) are left alone. + */ +export function rewriteMarkdownTablesForDiscord(text: string): string { + const matches = extractMarkdownTables(text); + if (matches.length === 0) return text; + + let out = text; + for (let index = matches.length - 1; index >= 0; index -= 1) { + const match = matches[index]!; + const replacement = renderTableAsBullets(match.headers, match.rows); + out = `${out.slice(0, match.start)}${replacement}${out.slice(match.end)}`; + } + return out; +} diff --git a/apps/discord-bot/src/presentation/mentions.test.ts b/apps/discord-bot/src/presentation/mentions.test.ts new file mode 100644 index 000000000000..eb2a04852f65 --- /dev/null +++ b/apps/discord-bot/src/presentation/mentions.test.ts @@ -0,0 +1,301 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + bridgedTurnTopicResolutionError, + missingProjectBindingMessage, + normalizeWorkspacePath, + parseMentionFlags, + parseMentionIntent, + parseTopicShortName, + projectTopicFromParentLookup, + readChannelTopic, + resolveDiscordFollowUpDelivery, + shouldPostWorkingAckForContinue, +} from "./mentions.ts"; +import { + chunkDiscordContent, + formatInProgressChunk, + inProgressChunkLimit, + stripBotMention, + stripWorkingIndicator, + truncateTitle, + WORKING_INDICATOR, +} from "./messages.ts"; + +describe("parseTopicShortName", () => { + it("extracts short names from channel topics", () => { + expect(parseTopicShortName("t3-example-project")).toBe("example-project"); + expect(parseTopicShortName("Project channel t3-example-project please")).toBe( + "example-project", + ); + expect(parseTopicShortName("T3-Example-Project")).toBe("example-project"); + expect(parseTopicShortName("no alias here")).toBeNull(); + }); +}); + +describe("project topic lookup", () => { + it("reads topic from channel-like objects", () => { + expect(readChannelTopic({ topic: "t3-example-project" })).toBe("t3-example-project"); + expect(readChannelTopic({ topic: null })).toBeNull(); + expect(readChannelTopic({ id: "1" })).toBeNull(); + expect(readChannelTopic(null)).toBeNull(); + }); + + it("uses parent topic when parent fetch succeeds", () => { + expect( + projectTopicFromParentLookup({ + channel: { topic: null }, + parentId: "parent-1", + parent: { ok: true, channel: { topic: "t3-configurator please" } }, + }), + ).toEqual({ + kind: "resolved", + topic: "t3-configurator please", + parentChannelId: "parent-1", + }); + }); + + it("does not treat a failed parent fetch as a missing t3 tag", () => { + expect( + projectTopicFromParentLookup({ + channel: { topic: null }, + parentId: "parent-1", + parent: { ok: false, cause: "503 Service Unavailable" }, + }), + ).toEqual({ + kind: "parent-unavailable", + parentChannelId: "parent-1", + cause: "503 Service Unavailable", + }); + }); + + it("uses the channel topic when not in a thread", () => { + expect( + projectTopicFromParentLookup({ + channel: { topic: "t3-example-project" }, + parentId: null, + parent: null, + }), + ).toEqual({ + kind: "resolved", + topic: "t3-example-project", + parentChannelId: null, + }); + }); + + it("writes distinct user-facing errors for outages vs missing tags", () => { + expect(missingProjectBindingMessage({ inThread: true, parentUnavailable: true })).toContain( + "Discord API may be degraded", + ); + expect(missingProjectBindingMessage({ inThread: true, parentUnavailable: false })).toContain( + "t3-", + ); + expect( + bridgedTurnTopicResolutionError({ + topicError: "Channel topic has no t3- tag.", + parentUnavailable: true, + hasExistingLink: false, + recoveredFromLink: false, + }), + ).toContain("Discord API may be degraded"); + expect( + bridgedTurnTopicResolutionError({ + topicError: "Channel topic has no t3- tag.", + parentUnavailable: true, + hasExistingLink: true, + recoveredFromLink: true, + }), + ).toBeNull(); + }); +}); + +describe("parseMentionFlags", () => { + it("parses flags and residual prompt", () => { + const parsed = parseMentionFlags( + "--plan --local --base develop --model compose-2.5 --provider grok fix the flaky test", + ); + expect(parsed).toEqual({ + model: "compose-2.5", + provider: "grok", + base: "develop", + local: true, + plan: true, + prompt: "fix the flaky test", + }); + }); + + it("parses --steer and --queue with last-wins when both appear", () => { + expect(parseMentionFlags("--steer also check the race").followUpDelivery).toBe("steer"); + expect(parseMentionFlags("--queue park this for later").followUpDelivery).toBe("queue"); + expect(parseMentionFlags("--steer --queue prefer queue").followUpDelivery).toBe("queue"); + expect(parseMentionFlags("--queue --steer prefer steer").followUpDelivery).toBe("steer"); + expect(parseMentionFlags("plain follow-up").followUpDelivery).toBeUndefined(); + }); +}); + +describe("resolveDiscordFollowUpDelivery", () => { + it("defaults mid-turn Discord delivery to queue", () => { + expect(resolveDiscordFollowUpDelivery({})).toBe("queue"); + expect(resolveDiscordFollowUpDelivery({ followUpDelivery: "steer" })).toBe("steer"); + expect(resolveDiscordFollowUpDelivery({ followUpDelivery: "queue" })).toBe("queue"); + }); +}); + +describe("shouldPostWorkingAckForContinue", () => { + it("does not post Working for a parked mid-turn follow-up", () => { + expect( + shouldPostWorkingAckForContinue({ + turnAlreadyRunning: true, + followUpDelivery: "queue", + }), + ).toBe(false); + }); + + it("posts Working for a mid-turn steer and for idle continues", () => { + // Discord-originated relocate: new Working ack under the command. Queued + // follow-ups leave the live tip; echoed desktop commands hop separately. + expect( + shouldPostWorkingAckForContinue({ + turnAlreadyRunning: true, + followUpDelivery: "steer", + }), + ).toBe(true); + expect( + shouldPostWorkingAckForContinue({ + turnAlreadyRunning: false, + followUpDelivery: "queue", + }), + ).toBe(true); + }); + + it("never posts Working in final-only presentation", () => { + expect( + shouldPostWorkingAckForContinue({ + presentationMode: "final-only", + turnAlreadyRunning: false, + followUpDelivery: "steer", + }), + ).toBe(false); + }); +}); + +describe("parseMentionIntent", () => { + it("recognizes stop words as interrupt commands", () => { + expect(parseMentionIntent("stop")).toEqual({ kind: "interrupt" }); + expect(parseMentionIntent(" cancel! ")).toEqual({ kind: "interrupt" }); + expect(parseMentionIntent("--plan abort")).toEqual({ kind: "interrupt" }); + }); + + it("recognizes help as a help command", () => { + expect(parseMentionIntent("help")).toEqual({ kind: "help" }); + expect(parseMentionIntent(" help! ")).toEqual({ kind: "help" }); + }); + + it("recognizes today-recap as a recap command", () => { + expect(parseMentionIntent("today-recap")).toEqual({ kind: "today-recap" }); + expect(parseMentionIntent(" today recap! ")).toEqual({ kind: "today-recap" }); + }); + + it("keeps extra text after today-recap as a normal prompt", () => { + expect(parseMentionIntent("today-recap for last week")).toMatchObject({ + kind: "prompt", + prompt: "today-recap for last week", + }); + }); + + it("recognizes compact as a control command", () => { + expect(parseMentionIntent("compact")).toEqual({ kind: "compact" }); + expect(parseMentionIntent(" Compact! ")).toEqual({ kind: "compact" }); + }); + + it("recognizes refresh-indicators as a control command", () => { + expect(parseMentionIntent("refresh-indicators")).toEqual({ kind: "refresh-indicators" }); + expect(parseMentionIntent("refresh indicators")).toEqual({ kind: "refresh-indicators" }); + expect(parseMentionIntent("refresh title")).toEqual({ kind: "refresh-indicators" }); + }); + + it("keeps normal prompts as prompts", () => { + expect(parseMentionIntent("stop using the flaky snapshot test")).toEqual({ + kind: "prompt", + local: false, + plan: false, + prompt: "stop using the flaky snapshot test", + }); + }); + + it("recognizes link / pick-up of an existing T3 thread", () => { + expect(parseMentionIntent("link abc-123")).toEqual({ + kind: "link-thread", + t3ThreadId: "abc-123", + }); + expect(parseMentionIntent("pick-up https://t3.example/?thread=uuid-1&foo=1")).toEqual({ + kind: "link-thread", + t3ThreadId: "uuid-1", + }); + expect(parseMentionIntent("pickup http://localhost:5173/?thread=tid-9")).toEqual({ + kind: "link-thread", + t3ThreadId: "tid-9", + }); + }); + + it("does not treat ordinary prompts starting with link words as link commands", () => { + expect(parseMentionIntent("link these files together")).toEqual({ + kind: "prompt", + local: false, + plan: false, + prompt: "link these files together", + }); + expect(parseMentionIntent("please pick-up the slack")).toEqual({ + kind: "prompt", + local: false, + plan: false, + prompt: "please pick-up the slack", + }); + }); +}); + +describe("message helpers", () => { + it("strips bot mentions", () => { + expect(stripBotMention("<@123> please help <@!123>", "123")).toBe("please help"); + }); + + it("strips the app-managed role mention when provided", () => { + expect(stripBotMention("<@&456> thread-talk on", "123", "456")).toBe("thread-talk on"); + }); + + it("chunks long content", () => { + const chunks = chunkDiscordContent("a".repeat(2500), 2000); + expect(chunks.length).toBe(2); + expect(chunks[0]?.length).toBeLessThanOrEqual(2000); + }); + + it("appends italic Working.. only on the last in-progress chunk", () => { + expect(formatInProgressChunk("partial answer", true)).toContain(WORKING_INDICATOR); + expect(formatInProgressChunk("partial answer", true).endsWith(WORKING_INDICATOR)).toBe(true); + expect(WORKING_INDICATOR).toBe("_Working.._"); + expect(formatInProgressChunk("older chunk", false)).toBe("older chunk"); + expect(formatInProgressChunk("", true)).toBe(WORKING_INDICATOR); + expect(formatInProgressChunk("x".repeat(1990), true).length).toBeLessThanOrEqual(2000); + expect(inProgressChunkLimit(2000)).toBeLessThan(2000); + }); + + it("strips Working.. from finalized content", () => { + expect(stripWorkingIndicator(`partial answer\n\n${WORKING_INDICATOR}`)).toBe("partial answer"); + expect(stripWorkingIndicator("partial answer\n\nWorking..")).toBe("partial answer"); + expect(stripWorkingIndicator(WORKING_INDICATOR)).toBe(""); + expect(stripWorkingIndicator("keep Working.. in the middle")).toBe( + "keep Working.. in the middle", + ); + }); + + it("truncates titles", () => { + expect(truncateTitle("short")).toBe("short"); + expect(truncateTitle("x".repeat(120)).length).toBe(100); + }); +}); + +describe("normalizeWorkspacePath", () => { + it("normalizes separators and trailing slashes", () => { + expect(normalizeWorkspacePath("/tmp/Foo/")).toBe("/tmp/foo"); + }); +}); diff --git a/apps/discord-bot/src/presentation/mentions.ts b/apps/discord-bot/src/presentation/mentions.ts new file mode 100644 index 000000000000..29784d5bd939 --- /dev/null +++ b/apps/discord-bot/src/presentation/mentions.ts @@ -0,0 +1,268 @@ +import { parseProviderModelFlags } from "@t3tools/shared/providerModelSelection"; + +import { parseLinkThreadCommand, type LinkThreadCommand } from "./t3ThreadRef.ts"; + +/** How a mid-turn Discord follow-up is delivered to the server queue. */ +export type DiscordFollowUpDelivery = "steer" | "queue"; + +export interface ParsedMentionFlags { + readonly model?: string; + readonly provider?: string; + readonly base?: string; + readonly local: boolean; + readonly plan: boolean; + /** + * Explicit mid-turn delivery override. When omitted, busy-thread follow-ups + * **queue** server-side (platform default) and are badged with 📥. + * `--steer` injects into the active turn immediately; `--queue` forces park. + */ + readonly followUpDelivery?: DiscordFollowUpDelivery; + readonly prompt: string; +} + +/** + * Resolve mid-turn delivery. Default is **queue** (server-aligned); `--steer` + * / `/omegent steer` force injection. Idle threads ignore this (startTurn + * opens a normal turn). + */ +export function resolveDiscordFollowUpDelivery( + flags: Pick, +): DiscordFollowUpDelivery { + return flags.followUpDelivery ?? "queue"; +} + +/** + * Whether a continue-mention should post/adopt a fresh `_Working.._` tip. + * + * Discord-originated relocate path (idle turn or `--steer`). Stream/heartbeat + * also hop Working below an echoed desktop/web/mobile/GitHub command. Casual + * thread chat must not hop the live tip. + * + * Parked mid-turn follow-ups must not post a new tip. Adopting a new Working + * freezes the live tip and bumps the delivery epoch, so the in-flight answer is + * never posted (queued follow-up final lands; prior final is stuck as frozen + * progress). `--steer` / `/agent steer` still posts a new tip under the new + * mention. `/agent steernow` injects the queue without a new tip. + */ +export function shouldPostWorkingAckForContinue(input: { + readonly presentationMode?: "full" | "final-only" | undefined; + readonly turnAlreadyRunning: boolean; + readonly followUpDelivery: DiscordFollowUpDelivery; +}): boolean { + if (input.presentationMode === "final-only") return false; + if (input.turnAlreadyRunning && input.followUpDelivery === "queue") return false; + return true; +} + +export type ParsedMentionIntent = + | { readonly kind: "interrupt" } + | { readonly kind: "help" } + | { readonly kind: "today-recap" } + | { readonly kind: "refresh-indicators" } + | { readonly kind: "compact" } + | LinkThreadCommand + | ({ readonly kind: "prompt" } & ParsedMentionFlags); + +const INTERRUPT_PROMPTS = new Set(["stop", "cancel", "abort", "interrupt"]); +const HELP_PROMPTS = new Set(["help"]); +const TODAY_RECAP_PROMPTS = new Set(["today-recap", "today recap"]); +const COMPACT_PROMPTS = new Set(["compact"]); +const REFRESH_INDICATORS_PROMPTS = new Set([ + "refresh-indicators", + "refresh indicators", + "refresh-title", + "refresh title", +]); + +/** + * Parse optional flags from a bot mention body (after stripping the mention). + * Flags: --model --provider --base --local --plan + * --steer --queue + * + * `--steer` / `--queue` last-wins when both appear. + */ +export function parseMentionFlags(raw: string): ParsedMentionFlags { + const providerModel = parseProviderModelFlags(raw); + const tokens = providerModel.prompt + .trim() + .split(/\s+/u) + .filter((token) => token.length > 0); + let base: string | undefined; + let local = false; + let plan = false; + let followUpDelivery: DiscordFollowUpDelivery | undefined; + const promptParts: string[] = []; + + for (let index = 0; index < tokens.length; index += 1) { + const token = tokens[index]!; + if (token === "--local") { + local = true; + continue; + } + if (token === "--plan") { + plan = true; + continue; + } + if (token === "--steer") { + followUpDelivery = "steer"; + continue; + } + if (token === "--queue") { + followUpDelivery = "queue"; + continue; + } + if (token === "--base") { + const next = tokens[index + 1]; + if (next !== undefined && !next.startsWith("--")) { + base = next; + index += 1; + continue; + } + } + promptParts.push(token); + } + + return { + ...(providerModel.model === undefined ? {} : { model: providerModel.model }), + ...(providerModel.provider === undefined ? {} : { provider: providerModel.provider }), + ...(base === undefined ? {} : { base }), + local, + plan, + ...(followUpDelivery === undefined ? {} : { followUpDelivery }), + prompt: promptParts.join(" ").trim(), + }; +} + +export function parseMentionIntent(raw: string): ParsedMentionIntent { + const linkThread = parseLinkThreadCommand(raw); + if (linkThread !== null) return linkThread; + + const parsed = parseMentionFlags(raw); + const normalizedPrompt = parsed.prompt + .trim() + .toLocaleLowerCase() + .replace(/^[\s.,!?;:()[\]{}"'`~*_#-]+|[\s.,!?;:()[\]{}"'`~*_#-]+$/gu, ""); + + if (INTERRUPT_PROMPTS.has(normalizedPrompt)) { + return { kind: "interrupt" }; + } + + if (HELP_PROMPTS.has(normalizedPrompt)) { + return { kind: "help" }; + } + + if (TODAY_RECAP_PROMPTS.has(normalizedPrompt)) { + return { kind: "today-recap" }; + } + + if (COMPACT_PROMPTS.has(normalizedPrompt)) { + return { kind: "compact" }; + } + + if (REFRESH_INDICATORS_PROMPTS.has(normalizedPrompt)) { + return { kind: "refresh-indicators" }; + } + + return { kind: "prompt", ...parsed }; +} + +export function parseTopicShortName(topic: string | null | undefined): string | null { + if (topic === null || topic === undefined) return null; + const match = /\bt3-([a-z0-9]+(?:-[a-z0-9]+)*)\b/i.exec(topic); + return match?.[1]?.toLowerCase() ?? null; +} + +/** Read Discord channel.topic when present (threads usually have none). */ +export function readChannelTopic(channel: unknown): string | null | undefined { + if (channel === null || channel === undefined || typeof channel !== "object") return null; + if (!("topic" in channel)) return null; + return (channel as { readonly topic?: string | null | undefined }).topic; +} + +/** + * Result of resolving the project-binding topic for a mention/slash command. + * Distinguishes a missing `t3-*` tag from a failed parent-channel fetch (Discord outage). + */ +export type ProjectTopicLookup = + | { + readonly kind: "resolved"; + readonly topic: string | null | undefined; + readonly parentChannelId: string | null; + } + | { + readonly kind: "parent-unavailable"; + readonly parentChannelId: string; + readonly cause: string; + }; + +/** + * Pure merge of thread channel + optional parent GET outcome into a topic lookup. + * When `parentId` is set, the parent response is authoritative; a failed parent GET + * must not be confused with "channel has no t3-* tag". + */ +export function projectTopicFromParentLookup(input: { + readonly channel: unknown; + readonly parentId: string | null; + readonly parent: + | { readonly ok: true; readonly channel: unknown } + | { readonly ok: false; readonly cause: string } + | null; +}): ProjectTopicLookup { + if (input.parentId === null) { + return { + kind: "resolved", + topic: readChannelTopic(input.channel), + parentChannelId: null, + }; + } + if (input.parent === null || !input.parent.ok) { + return { + kind: "parent-unavailable", + parentChannelId: input.parentId, + cause: input.parent === null ? "parent channel not fetched" : input.parent.cause, + }; + } + return { + kind: "resolved", + topic: readChannelTopic(input.parent.channel), + parentChannelId: input.parentId, + }; +} + +/** User-facing copy when we cannot bind a Discord channel to a T3 project. */ +export function missingProjectBindingMessage(input: { + readonly inThread: boolean; + readonly parentUnavailable: boolean; +}): string { + if (input.parentUnavailable) { + return input.inThread + ? "Couldn't read the parent channel topic (Discord API may be degraded). Please try again in a moment." + : "Couldn't read the channel topic (Discord API may be degraded). Please try again in a moment."; + } + return input.inThread + ? "This channel is not linked to a T3 project. Set the parent channel topic to include `t3-` (e.g. `t3-example-project`)." + : "This channel is not linked to a T3 project. Set the channel topic to include `t3-` (e.g. `t3-example-project`)."; +} + +/** + * Error string when topic-based project resolution fails for a bridged turn. + * Prefers an existing Discord↔T3 link over a misleading "no topic tag" during outages. + */ +export function bridgedTurnTopicResolutionError(input: { + readonly topicError: string; + readonly parentUnavailable: boolean; + readonly hasExistingLink: boolean; + readonly recoveredFromLink: boolean; +}): string | null { + if (input.recoveredFromLink) return null; + if (input.parentUnavailable) { + return input.hasExistingLink + ? "Couldn't read the parent channel topic and could not recover the linked T3 project. Please try again in a moment." + : "Couldn't read the parent channel topic (Discord API may be degraded). Please try again in a moment."; + } + return input.topicError; +} + +export function normalizeWorkspacePath(path: string): string { + return path.replaceAll("\\", "/").replace(/\/+$/u, "").toLocaleLowerCase(); +} diff --git a/apps/discord-bot/src/presentation/messages.test.ts b/apps/discord-bot/src/presentation/messages.test.ts new file mode 100644 index 000000000000..5a4bbbe21885 --- /dev/null +++ b/apps/discord-bot/src/presentation/messages.test.ts @@ -0,0 +1,227 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + decorateDiscordThreadTitle, + formatInProgressChunk, + formatThreadTitle, + formatWakeUpTipContent, + idleMessageFields, + nextWorkingDotCount, + stripWorkingIndicator, + truncateTitle, + turnContinueCustomId, + turnStopCustomId, + WAKE_UP_STATUS_LINE, + wakeUpMessageFields, + workingMessageFields, +} from "./messages.ts"; + +describe("formatThreadTitle", () => { + it("collapses whitespace and uses the provided fallback", () => { + expect(formatThreadTitle(" review the open PR ", 72, "Discord thread")).toBe( + "review the open PR", + ); + expect(formatThreadTitle(" ", 72, "Discord thread")).toBe("Discord thread"); + }); + + it("truncates long titles with an ellipsis", () => { + expect(formatThreadTitle("x".repeat(80), 72)).toHaveLength(72); + expect(formatThreadTitle("x".repeat(80), 72).endsWith("…")).toBe(true); + }); +}); + +describe("truncateTitle", () => { + it("preserves the existing Discord thread-name behavior", () => { + expect(truncateTitle("short")).toBe("short"); + expect(truncateTitle("x".repeat(120)).length).toBe(100); + }); +}); + +describe("decorateDiscordThreadTitle", () => { + it("composes optional PR + activity columns like the T3 client", () => { + expect( + decorateDiscordThreadTitle("Review sidebar PR status", { + pr: "open", + activity: "busy", + }), + ).toBe("🔀 ⏳ Review sidebar PR status"); + expect( + decorateDiscordThreadTitle("Review sidebar PR status", { + pr: "open", + activity: "wake-required", + hasFailingChecks: true, + }), + ).toBe("❌ ❗ Review sidebar PR status"); + expect( + decorateDiscordThreadTitle("Review sidebar PR status", { + pr: "initialized", + activity: "busy", + }), + ).toBe("▫️ ⏳ Review sidebar PR status"); + }); + + it("allows either column to be omitted", () => { + expect(decorateDiscordThreadTitle("Review sidebar PR status", { pr: "open" })).toBe( + "🔀 Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("Review sidebar PR status", { activity: "busy" })).toBe( + "⏳ Review sidebar PR status", + ); + expect( + decorateDiscordThreadTitle("Review sidebar PR status", { activity: "wake-required" }), + ).toBe("❗ Review sidebar PR status"); + expect(decorateDiscordThreadTitle("Review sidebar PR status", {})).toBe( + "Review sidebar PR status", + ); + }); + + it("legacy single-slot states still work", () => { + expect(decorateDiscordThreadTitle("Review sidebar PR status", "wake-required")).toBe( + "❗ Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("Review sidebar PR status", "busy")).toBe( + "⏳ Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("Review sidebar PR status", "initialized")).toBe( + "▫️ Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("Review sidebar PR status", "open")).toBe( + "🔀 Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("Review sidebar PR status", "open", 100, true)).toBe( + "❌ Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("Ship the merge flow", "merged")).toBe( + "✔️ Ship the merge flow", + ); + expect(decorateDiscordThreadTitle("Ship the merge flow", "closed")).toBe( + "✖️ Ship the merge flow", + ); + }); + + it("strips dual and legacy prefixes when redecorating", () => { + expect( + decorateDiscordThreadTitle("🔀 ⏳ Review sidebar PR status", { + pr: "open", + activity: null, + }), + ).toBe("🔀 Review sidebar PR status"); + expect(decorateDiscordThreadTitle("❗ Review sidebar PR status", "open")).toBe( + "🔀 Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("⏳ Review sidebar PR status", "initialized")).toBe( + "▫️ Review sidebar PR status", + ); + expect(decorateDiscordThreadTitle("🔀 ⏳ Existing title", { pr: "merged" })).toBe( + "✔️ Existing title", + ); + }); + + it("removes stale pull request prefixes when the PR closes or changes state", () => { + expect(decorateDiscordThreadTitle("🍴 Existing title", null)).toBe("Existing title"); + expect(decorateDiscordThreadTitle("· Existing title", null)).toBe("Existing title"); + expect(decorateDiscordThreadTitle("▫️ Existing title", null)).toBe("Existing title"); + expect(decorateDiscordThreadTitle("⏳ Existing title", null)).toBe("Existing title"); + expect(decorateDiscordThreadTitle("🍴 Existing title", "initialized")).toBe( + "▫️ Existing title", + ); + expect(decorateDiscordThreadTitle("🍴 Existing title", "merged")).toBe("✔️ Existing title"); + expect(decorateDiscordThreadTitle("✅ Existing title", "closed")).toBe("✖️ Existing title"); + expect(decorateDiscordThreadTitle("❌ Existing title", "open")).toBe("🔀 Existing title"); + expect(decorateDiscordThreadTitle("❌ 🔀 Existing title", "open")).toBe("🔀 Existing title"); + }); + + it("never duplicates an existing pull request prefix", () => { + expect(decorateDiscordThreadTitle("▫️ Existing title", "initialized")).toBe( + "▫️ Existing title", + ); + expect(decorateDiscordThreadTitle("⏳ Existing title", "busy")).toBe("⏳ Existing title"); + expect( + decorateDiscordThreadTitle("🔀 ⏳ Existing title", { pr: "open", activity: "busy" }), + ).toBe("🔀 ⏳ Existing title"); + expect(decorateDiscordThreadTitle("🔀 Existing title", "open")).toBe("🔀 Existing title"); + expect(decorateDiscordThreadTitle("❌ Existing title", "open", 100, true)).toBe( + "❌ Existing title", + ); + // Legacy dual ❌ 🔀 redecorates to single ❌ when checks are still failing. + expect(decorateDiscordThreadTitle("❌ 🔀 Existing title", "open", 100, true)).toBe( + "❌ Existing title", + ); + expect(decorateDiscordThreadTitle("✔️ Existing title", "merged")).toBe("✔️ Existing title"); + expect(decorateDiscordThreadTitle("✖️ Existing title", "closed")).toBe("✖️ Existing title"); + }); +}); + +describe("turn stop controls", () => { + it("builds the stop custom id", () => { + expect(turnStopCustomId("thread-123")).toBe("t3_stop:thread-123"); + }); + + it("attaches a Stop button to working messages", () => { + const fields = workingMessageFields("_Working.._", "thread-123"); + expect(fields.content).toBe("_Working.._"); + expect(fields.components).toHaveLength(1); + expect(fields.components[0]?.components[0]?.custom_id).toBe("t3_stop:thread-123"); + }); + + it("clears components for idle messages", () => { + expect(idleMessageFields("done").components).toEqual([]); + }); +}); + +describe("wake-up controls", () => { + it("builds the continue custom id", () => { + expect(turnContinueCustomId("thread-123")).toBe("t3_continue:thread-123"); + }); + + it("formats empty Working tips as bold wake-up status only", () => { + expect(formatWakeUpTipContent("_Working.._")).toBe(WAKE_UP_STATUS_LINE); + expect(formatWakeUpTipContent("")).toBe(WAKE_UP_STATUS_LINE); + }); + + it("keeps partial stream prose above the wake-up status", () => { + expect(formatWakeUpTipContent("partial answer\n\n_Working.._")).toBe( + `partial answer\n\n${WAKE_UP_STATUS_LINE}`, + ); + }); + + it("attaches a blue Continue button and no Stop", () => { + const fields = wakeUpMessageFields(WAKE_UP_STATUS_LINE, "thread-123"); + expect(fields.content).toBe(WAKE_UP_STATUS_LINE); + expect(fields.components).toHaveLength(1); + const button = fields.components[0]?.components[0]; + expect(button?.custom_id).toBe("t3_continue:thread-123"); + expect(button?.label).toBe("Continue"); + expect(button?.style).toBe(1); // PRIMARY (blue) + }); +}); + +describe("Working heartbeat", () => { + it("cycles through two, three, and four dots", () => { + expect(nextWorkingDotCount(2)).toBe(3); + expect(nextWorkingDotCount(3)).toBe(4); + expect(nextWorkingDotCount(4)).toBe(2); + }); + + it("renders the selected heartbeat without exceeding the message limit", () => { + const rendered = formatInProgressChunk("x".repeat(2000), true, 2000, 4); + expect(rendered).toHaveLength(2000); + expect(rendered.endsWith("_Working...._")).toBe(true); + }); + + it("appends a tool-call count on the Working indicator when > 0", () => { + expect(formatInProgressChunk("", true, 2000, 2, 0)).toBe("_Working.._"); + expect(formatInProgressChunk("", true, 2000, 2, 1)).toBe("_Working.. · 1 tool call_"); + expect(formatInProgressChunk("partial", true, 2000, 3, 4)).toBe( + "partial\n\n_Working... · 4 tool calls_", + ); + }); + + it("strips every heartbeat variant during final cleanup", () => { + expect(stripWorkingIndicator("answer\n\n_Working.._")).toBe("answer"); + expect(stripWorkingIndicator("answer\n\n_Working..._")).toBe("answer"); + expect(stripWorkingIndicator("answer\n\n_Working...._")).toBe("answer"); + expect(stripWorkingIndicator("answer\n\n_Working.. · 3 tool calls_")).toBe("answer"); + expect(stripWorkingIndicator("answer\n\n_Working... · 1 tool call_")).toBe("answer"); + }); +}); diff --git a/apps/discord-bot/src/presentation/messages.ts b/apps/discord-bot/src/presentation/messages.ts new file mode 100644 index 000000000000..325978c1f5b1 --- /dev/null +++ b/apps/discord-bot/src/presentation/messages.ts @@ -0,0 +1,315 @@ +import { Discord } from "dfx"; + +const DISCORD_MESSAGE_LIMIT = 2000; + +/** Appended to the tip of in-progress Discord stream messages (italic in Discord markdown). */ +export const WORKING_INDICATOR = "_Working.._"; +export const WORKING_INDICATOR_SUFFIX = `\n\n${WORKING_INDICATOR}`; +export type WorkingDotCount = 2 | 3 | 4; + +/** Longest Working suffix we reserve room for (dots + large tool count). */ +const WORKING_INDICATOR_MAX = "_Working.... · 9999 tool calls_"; + +/** + * Optional tool-call progress on the Working indicator (Discord only shows a count, + * not individual tool rows — same cadence as the 10s dot heartbeat). + */ +export function formatWorkingToolCountLabel(toolCallCount: number): string | null { + if (!Number.isFinite(toolCallCount) || toolCallCount <= 0) return null; + const n = Math.floor(toolCallCount); + return n === 1 ? "1 tool call" : `${n} tool calls`; +} + +export function workingIndicator(dotCount: WorkingDotCount, toolCallCount = 0): string { + const dots = ".".repeat(dotCount); + const tools = formatWorkingToolCountLabel(toolCallCount); + // Keep the whole marker italic so Discord renders one clean status line. + return tools === null ? `_Working${dots}_` : `_Working${dots} · ${tools}_`; +} + +export function nextWorkingDotCount(current: WorkingDotCount): WorkingDotCount { + if (current === 2) return 3; + if (current === 3) return 4; + return 2; +} + +/** Strip trailing Working.. markers so finalize never leaves them on the final post. */ +export function stripWorkingIndicator(content: string): string { + // Optional " · N tool call(s)" inside the Working marker (italic or plain). + const toolSuffix = "(?:\\s*·\\s*\\d+\\s+tool calls?)?"; + const workingTail = new RegExp(`(?:\\r?\\n)+\\s*_Working\\.{2,4}${toolSuffix}_\\s*$`, "u"); + const workingTailPlain = new RegExp(`(?:\\r?\\n)+\\s*Working\\.{2,4}${toolSuffix}\\s*$`, "u"); + const workingInline = new RegExp(`\\s*_Working\\.{2,4}${toolSuffix}_\\s*$`, "u"); + const workingInlinePlain = new RegExp(`\\s*Working\\.{2,4}${toolSuffix}\\s*$`, "u"); + return content + .replace(workingTail, "") + .replace(workingTailPlain, "") + .replace(workingInline, "") + .replace(workingInlinePlain, "") + .trimEnd(); +} + +export function chunkDiscordContent(content: string, limit = DISCORD_MESSAGE_LIMIT): string[] { + const trimmed = content.trimEnd(); + if (trimmed.length === 0) return [""]; + if (trimmed.length <= limit) return [trimmed]; + + const chunks: string[] = []; + let remaining = trimmed; + while (remaining.length > limit) { + let splitAt = remaining.lastIndexOf("\n", limit); + if (splitAt < Math.floor(limit * 0.5)) { + splitAt = remaining.lastIndexOf(" ", limit); + } + if (splitAt < Math.floor(limit * 0.5)) { + splitAt = limit; + } + chunks.push(remaining.slice(0, splitAt).trimEnd()); + remaining = remaining.slice(splitAt).trimStart(); + } + if (remaining.length > 0) chunks.push(remaining); + return chunks; +} + +/** + * Format a stream chunk for Discord. The last (tip) chunk always ends with _Working.._ + * so users can see the turn is still in progress. Optional toolCallCount shows progress + * without listing individual tools (e.g. `_Working.. · 3 tool calls_`). + */ +export function formatInProgressChunk( + chunk: string, + isLastChunk: boolean, + limit = DISCORD_MESSAGE_LIMIT, + workingDots: WorkingDotCount = 2, + toolCallCount = 0, +): string { + if (!isLastChunk) { + return chunk.length > 0 ? chunk : "…"; + } + const body = chunk.trimEnd(); + const indicator = workingIndicator(workingDots, toolCallCount); + const indicatorSuffix = `\n\n${indicator}`; + if (body.length === 0) return indicator; + const maxBody = Math.max(0, limit - indicatorSuffix.length); + const trimmedBody = body.length > maxBody ? body.slice(0, maxBody).trimEnd() : body; + return `${trimmedBody}${indicatorSuffix}`; +} + +/** Chunk limit reserved so the tip can always fit the Working.. suffix (+ tool count). */ +export function inProgressChunkLimit(limit = DISCORD_MESSAGE_LIMIT): number { + return Math.max(1, limit - `\n\n${WORKING_INDICATOR_MAX}`.length); +} + +export function turnStopCustomId(threadId: string): string { + return `t3_stop:${threadId}`; +} + +export function turnContinueCustomId(threadId: string): string { + return `t3_continue:${threadId}`; +} + +/** Bold wake-up status line when a session was interrupted (e.g. server restart). */ +export const WAKE_UP_STATUS_LINE = "**This thread needs another message to wake the bot.**"; + +/** + * Replace a Working tip body with wake-up status (strip Working.. / Stop context). + * Keeps any partial stream prose above the status line. + */ +export function formatWakeUpTipContent(tipContent: string): string { + const body = stripWorkingIndicator(tipContent).trim(); + if (body === "" || body === "…") return WAKE_UP_STATUS_LINE; + return `${body}\n\n${WAKE_UP_STATUS_LINE}`; +} + +export function workingMessageFields(content: string, threadId: string) { + return { + content, + components: [ + [ + { + type: 2 as const, + custom_id: turnStopCustomId(threadId), + label: "Stop", + style: Discord.ButtonStyleTypes.DANGER, + }, + ], + ].map((components) => ({ + type: 1 as const, + components, + })), + }; +} + +/** Wake-required tip: no Stop; blue Continue to help the user resume. */ +export function wakeUpMessageFields(content: string, threadId: string) { + return { + content, + components: [ + [ + { + type: 2 as const, + custom_id: turnContinueCustomId(threadId), + label: "Continue", + style: Discord.ButtonStyleTypes.PRIMARY, + }, + ], + ].map((components) => ({ + type: 1 as const, + components, + })), + }; +} + +export function idleMessageFields(content: string) { + return { + content, + components: [], + }; +} + +export function formatThreadTitle(value: string, max = 100, fallback = "T3 thread"): string { + const compact = value.replace(/\s+/g, " ").trim(); + if (compact.length === 0) return fallback; + if (compact.length <= max) return compact; + return `${compact.slice(0, max - 1).trimEnd()}…`; +} + +export function truncateTitle(value: string, max = 100): string { + return formatThreadTitle(value, max); +} + +/** + * Discord thread title badges are two independent optional columns (like the T3 client): + * `| PR status | Working status | Title` + * + * Either column may be absent. Single emoji (+ space) so columns stay aligned. + */ +const DISCORD_THREAD_TITLE_PR_PREFIX = { + initialized: "▫️ ", + open: "🔀 ", + /** Open PR with failing checks — single ❌ (no dual ❌ 🔀). */ + openFailing: "❌ ", + merged: "✔️ ", + closed: "✖️ ", +} as const; + +const DISCORD_THREAD_TITLE_ACTIVITY_PREFIX = { + /** Session interrupted (Wake Required). */ + wakeRequired: "❗ ", + /** Turn in progress (Discord shows Working..). */ + busy: "⏳ ", +} as const; + +/** PR / change-request column (optional). */ +export type DiscordThreadPrDecorState = "initialized" | "open" | "merged" | "closed" | null; + +/** Working / lifecycle column (optional). */ +export type DiscordThreadActivityDecorState = "busy" | "wake-required" | null; + +/** Composed title decoration — both slots optional. */ +export type DiscordThreadTitleDecorParts = { + readonly pr?: DiscordThreadPrDecorState; + readonly activity?: DiscordThreadActivityDecorState; + readonly hasFailingChecks?: boolean; +}; + +/** + * Legacy single-slot state (exclusive PR *or* activity). Prefer `DiscordThreadTitleDecorParts`. + * Kept so existing call sites / tests keep compiling during the dual-slot transition. + */ +export type DiscordThreadTitleDecorState = + | DiscordThreadPrDecorState + | DiscordThreadActivityDecorState; + +// Standalone ❌ = open+failing; also strip legacy "❌ 🔀" and normal PR icons. +const DISCORD_THREAD_PR_PREFIX_RE = /^(?:❌\s+🔀\s+|❌\s+|(?:🍴|✅|·|▫️|🔀|✓|✔️|✕|✖️)\s+)/u; +const DISCORD_THREAD_ACTIVITY_PREFIX_RE = /^(?:❗|⏳)\s+/u; + +/** Strip every known badge prefix (any order / legacy single-slot titles). */ +export function stripDiscordThreadTitlePrefixes(title: string): string { + let remaining = title.trimStart(); + for (let i = 0; i < 4; i += 1) { + const next = remaining + .replace(DISCORD_THREAD_PR_PREFIX_RE, "") + .replace(DISCORD_THREAD_ACTIVITY_PREFIX_RE, ""); + if (next === remaining) break; + remaining = next; + } + return remaining; +} + +function prPrefixFor(pr: DiscordThreadPrDecorState, hasFailingChecks: boolean): string { + if (pr === "initialized") return DISCORD_THREAD_TITLE_PR_PREFIX.initialized; + if (pr === "open") { + return hasFailingChecks + ? DISCORD_THREAD_TITLE_PR_PREFIX.openFailing + : DISCORD_THREAD_TITLE_PR_PREFIX.open; + } + if (pr === "merged") return DISCORD_THREAD_TITLE_PR_PREFIX.merged; + if (pr === "closed") return DISCORD_THREAD_TITLE_PR_PREFIX.closed; + return ""; +} + +function activityPrefixFor(activity: DiscordThreadActivityDecorState): string { + if (activity === "wake-required") return DISCORD_THREAD_TITLE_ACTIVITY_PREFIX.wakeRequired; + if (activity === "busy") return DISCORD_THREAD_TITLE_ACTIVITY_PREFIX.busy; + return ""; +} + +function normalizeDecorParts( + stateOrParts: DiscordThreadTitleDecorState | DiscordThreadTitleDecorParts, + hasFailingChecks: boolean, +): { + readonly pr: DiscordThreadPrDecorState; + readonly activity: DiscordThreadActivityDecorState; + readonly hasFailingChecks: boolean; +} { + if (stateOrParts === null || stateOrParts === undefined) { + return { pr: null, activity: null, hasFailingChecks: false }; + } + if (typeof stateOrParts === "string") { + if (stateOrParts === "busy" || stateOrParts === "wake-required") { + return { pr: null, activity: stateOrParts, hasFailingChecks: false }; + } + return { pr: stateOrParts, activity: null, hasFailingChecks }; + } + return { + pr: stateOrParts.pr ?? null, + activity: stateOrParts.activity ?? null, + hasFailingChecks: stateOrParts.hasFailingChecks ?? hasFailingChecks, + }; +} + +/** + * Decorate a Discord thread title. + * + * Preferred: `decorateDiscordThreadTitle(title, { pr: "open", activity: "busy" })` + * → `🔀 ⏳ Title` + * + * Legacy single-slot still works: `decorateDiscordThreadTitle(title, "open")` → `🔀 Title`. + */ +export function decorateDiscordThreadTitle( + title: string, + stateOrParts: DiscordThreadTitleDecorState | DiscordThreadTitleDecorParts = null, + max = 100, + hasFailingChecks = false, +): string { + const parts = normalizeDecorParts(stateOrParts, hasFailingChecks); + const baseTitle = truncateTitle(stripDiscordThreadTitlePrefixes(title), max); + const prefix = `${prPrefixFor(parts.pr, parts.hasFailingChecks)}${activityPrefixFor(parts.activity)}`; + return truncateTitle(`${prefix}${baseTitle}`, max); +} + +export function stripBotMention( + content: string, + botUserId: string, + botRoleId?: string | null, +): string { + const userMention = new RegExp(`<@!?${botUserId}>`, "g"); + const withoutUserMention = content.replace(userMention, " "); + const withoutManagedRoleMention = + botRoleId === undefined || botRoleId === null + ? withoutUserMention + : withoutUserMention.replace(new RegExp(`<@&${botRoleId}>`, "g"), " "); + return withoutManagedRoleMention.replace(/\s+/g, " ").trim(); +} diff --git a/apps/discord-bot/src/presentation/pendingInteractions.ts b/apps/discord-bot/src/presentation/pendingInteractions.ts new file mode 100644 index 000000000000..75c2fc4965ed --- /dev/null +++ b/apps/discord-bot/src/presentation/pendingInteractions.ts @@ -0,0 +1,113 @@ +import type { OrchestrationThreadActivity, UserInputQuestion } from "@t3tools/contracts"; + +export interface PendingApproval { + readonly kind: "approval"; + readonly requestId: string; + readonly requestKind: "command" | "file-read" | "file-change"; + readonly detail: string | null; + readonly createdAt: string; +} + +export interface PendingUserInput { + readonly kind: "user-input"; + readonly requestId: string; + readonly questions: ReadonlyArray; + readonly createdAt: string; +} + +export type PendingInteraction = PendingApproval | PendingUserInput; + +function record(value: unknown): Record | null { + return typeof value === "object" && value !== null && !Array.isArray(value) + ? (value as Record) + : null; +} + +function requestKind(value: unknown): PendingApproval["requestKind"] | null { + if (value === "command" || value === "file-read" || value === "file-change") return value; + if ( + value === "command_execution_approval" || + value === "exec_command_approval" || + value === "dynamic_tool_call" + ) + return "command"; + if (value === "file_read_approval") return "file-read"; + if (value === "file_change_approval" || value === "apply_patch_approval") return "file-change"; + return null; +} + +function questions(value: unknown): ReadonlyArray | null { + if (!Array.isArray(value)) return null; + const parsed = value.filter((entry): entry is UserInputQuestion => { + const question = record(entry); + return ( + typeof question?.id === "string" && + typeof question.header === "string" && + typeof question.question === "string" && + Array.isArray(question.options) && + question.options.every((option) => { + const value = record(option); + return typeof value?.label === "string" && typeof value.description === "string"; + }) + ); + }); + return parsed.length === value.length && parsed.length > 0 ? parsed : null; +} + +function isStaleFailure(payload: Record): boolean { + const detail = typeof payload.detail === "string" ? payload.detail.toLowerCase() : ""; + return ( + detail.includes("stale pending approval request") || + detail.includes("stale pending user-input request") || + detail.includes("unknown pending approval request") || + detail.includes("unknown pending user-input request") + ); +} + +export function derivePendingInteractions( + activities: ReadonlyArray, +): ReadonlyArray { + const pending = new Map(); + for (const activity of [...activities].toSorted((left, right) => { + if (left.sequence !== undefined && right.sequence !== undefined) + return left.sequence - right.sequence; + return left.createdAt.localeCompare(right.createdAt); + })) { + const payload = record(activity.payload); + if (payload === null || typeof payload.requestId !== "string") continue; + const requestId = payload.requestId; + if (activity.kind === "approval.requested") { + const kind = requestKind(payload.requestKind ?? payload.requestType); + if (kind !== null) { + pending.set(requestId, { + kind: "approval", + requestId, + requestKind: kind, + detail: typeof payload.detail === "string" ? payload.detail : null, + createdAt: activity.createdAt, + }); + } + } else if (activity.kind === "user-input.requested") { + const parsed = questions(payload.questions); + if (parsed !== null) { + pending.set(requestId, { + kind: "user-input", + requestId, + questions: parsed, + createdAt: activity.createdAt, + }); + } + } else if (activity.kind === "approval.resolved" || activity.kind === "user-input.resolved") { + pending.delete(requestId); + } else if ( + (activity.kind === "provider.approval.respond.failed" || + activity.kind === "provider.user-input.respond.failed") && + isStaleFailure(payload) + ) { + pending.delete(requestId); + } + } + return [...pending.values()].toSorted((left, right) => + left.createdAt.localeCompare(right.createdAt), + ); +} diff --git a/apps/discord-bot/src/presentation/prAssign.test.ts b/apps/discord-bot/src/presentation/prAssign.test.ts new file mode 100644 index 000000000000..a6eb4f47bd96 --- /dev/null +++ b/apps/discord-bot/src/presentation/prAssign.test.ts @@ -0,0 +1,142 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + assignPullRequestAssignees, + formatAssignSlashReply, + parseAssignGithubOption, + resolveAssignGithubLogin, +} from "./prAssign.ts"; + +describe("parseAssignGithubOption", () => { + it("treats empty, @me, me, self as self", () => { + expect(parseAssignGithubOption(undefined)).toEqual({ kind: "self" }); + expect(parseAssignGithubOption(null)).toEqual({ kind: "self" }); + expect(parseAssignGithubOption("")).toEqual({ kind: "self" }); + expect(parseAssignGithubOption(" ")).toEqual({ kind: "self" }); + expect(parseAssignGithubOption("@me")).toEqual({ kind: "self" }); + expect(parseAssignGithubOption("ME")).toEqual({ kind: "self" }); + expect(parseAssignGithubOption("self")).toEqual({ kind: "self" }); + }); + + it("accepts logins with or without @", () => { + expect(parseAssignGithubOption("MindfulLearner")).toEqual({ + kind: "login", + login: "MindfulLearner", + }); + expect(parseAssignGithubOption("@MindfulLearner")).toEqual({ + kind: "login", + login: "MindfulLearner", + }); + }); + + it("rejects invalid logins", () => { + expect(parseAssignGithubOption("-bad")).toMatchObject({ kind: "invalid" }); + expect(parseAssignGithubOption("has space")).toMatchObject({ kind: "invalid" }); + }); +}); + +describe("resolveAssignGithubLogin", () => { + const map = new Map< + string, + { readonly github?: { readonly login?: string | undefined } | undefined } + >([ + ["111", { github: { login: "MindfulLearner" } }], + ["222", {}], + ]); + + it("returns explicit login without consulting the map", () => { + expect( + resolveAssignGithubLogin({ + githubOption: "@other-dev", + requesterDiscordId: "111", + resolveByDiscordId: (id) => map.get(id) ?? null, + }), + ).toEqual({ ok: true, login: "other-dev", source: "explicit" }); + }); + + it("resolves @me via identity map", () => { + expect( + resolveAssignGithubLogin({ + githubOption: undefined, + requesterDiscordId: "111", + resolveByDiscordId: (id) => map.get(id) ?? null, + }), + ).toEqual({ ok: true, login: "MindfulLearner", source: "self" }); + }); + + it("fails when unmapped or missing github login", () => { + expect( + resolveAssignGithubLogin({ + requesterDiscordId: "999", + resolveByDiscordId: (id) => map.get(id) ?? null, + }).ok, + ).toBe(false); + expect( + resolveAssignGithubLogin({ + requesterDiscordId: "222", + resolveByDiscordId: (id) => map.get(id) ?? null, + }).ok, + ).toBe(false); + }); +}); + +describe("assignPullRequestAssignees", () => { + it("posts assignees for each valid PR and reports errors", async () => { + const calls: string[][] = []; + const results = await assignPullRequestAssignees({ + prUrls: [ + "https://github.com/acme/app/pull/12", + "not-a-pr", + "https://github.com/acme/app/pull/13", + ], + login: "MindfulLearner", + execFile: async (_file, args) => { + calls.push([...args]); + if (args.includes("repos/acme/app/issues/13/assignees")) { + throw new Error("HTTP 422: Validation Failed"); + } + return { stdout: "", stderr: "" }; + }, + }); + + expect(results).toEqual([ + { url: "https://github.com/acme/app/pull/12", status: "assigned" }, + { url: "not-a-pr", status: "skipped", detail: "not a github pull request url" }, + { + url: "https://github.com/acme/app/pull/13", + status: "error", + detail: "HTTP 422: Validation Failed", + }, + ]); + expect(calls).toHaveLength(2); + expect(calls[0]).toEqual([ + "api", + "repos/acme/app/issues/12/assignees", + "-X", + "POST", + "-f", + "assignees[]=MindfulLearner", + ]); + }); +}); + +describe("formatAssignSlashReply", () => { + it("summarizes assigned and failed PRs", () => { + const text = formatAssignSlashReply({ + login: "MindfulLearner", + results: [ + { url: "https://github.com/a/b/pull/1", status: "assigned" }, + { url: "https://github.com/a/b/pull/2", status: "error", detail: "forbidden" }, + ], + }); + expect(text).toContain("@MindfulLearner"); + expect(text).toContain("https://github.com/a/b/pull/1"); + expect(text).toContain("forbidden"); + }); + + it("handles empty PR list", () => { + expect(formatAssignSlashReply({ login: "x", results: [] })).toContain( + "No linked pull requests", + ); + }); +}); diff --git a/apps/discord-bot/src/presentation/prAssign.ts b/apps/discord-bot/src/presentation/prAssign.ts new file mode 100644 index 000000000000..a1da66369283 --- /dev/null +++ b/apps/discord-bot/src/presentation/prAssign.ts @@ -0,0 +1,196 @@ +/** + * Assign linked GitHub PRs from Discord slash `/omegent assign` (alias `/agent assign`). + * + * - No `github` option → assign to the invoker's mapped GitHub login (`@me`). + * - `github: MindfulLearner` / `@MindfulLearner` → assign that login. + */ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeChildProcess from "node:child_process"; +import * as NodeUtil from "node:util"; + +import { gitCommandEnv } from "./githubLinks.ts"; +import { normalizePullRequestUrl, type NormalizedPullRequestLink } from "./prLinks.ts"; + +const execFile = NodeUtil.promisify(NodeChildProcess.execFile); + +type ExecFileResult = { + readonly stdout: string; + readonly stderr: string; +}; + +type ExecFileLike = ( + file: string, + args: ReadonlyArray, + options?: NodeChildProcess.ExecFileOptions, +) => Promise; + +/** Discord slash / mention placeholders that mean "the person who ran the command". */ +const SELF_ASSIGNEE_TOKENS = new Set(["", "@me", "me", "self"]); + +/** + * Normalize a GitHub login from slash input. + * Returns `null` for empty / @me / self (caller should resolve via identity map). + * Returns `{ ok: false }` for invalid logins. + */ +export function parseAssignGithubOption(raw: string | null | undefined): + | { readonly kind: "self" } + | { readonly kind: "login"; readonly login: string } + | { + readonly kind: "invalid"; + readonly detail: string; + } { + const trimmed = (raw ?? "").trim(); + if (SELF_ASSIGNEE_TOKENS.has(trimmed.toLowerCase())) { + return { kind: "self" }; + } + const withoutAt = trimmed.replace(/^@/u, "").trim(); + if (withoutAt.length === 0) { + return { kind: "self" }; + } + // GitHub login: alphanumeric / hyphen, max 39, cannot start/end with hyphen. + if (!/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/u.test(withoutAt)) { + return { + kind: "invalid", + detail: `Invalid GitHub username \`${trimmed}\`. Use a login like \`MindfulLearner\`, or omit for yourself.`, + }; + } + return { kind: "login", login: withoutAt }; +} + +export type ResolveAssignLoginInput = { + readonly githubOption?: string | null | undefined; + readonly requesterDiscordId?: string | null | undefined; + readonly resolveByDiscordId: ( + discordId: string, + ) => { readonly github?: { readonly login?: string | undefined } | undefined } | null; +}; + +export type ResolveAssignLoginResult = + | { readonly ok: true; readonly login: string; readonly source: "self" | "explicit" } + | { readonly ok: false; readonly message: string }; + +/** + * Resolve who to assign: explicit GitHub login, or requester via identity map. + */ +export function resolveAssignGithubLogin(input: ResolveAssignLoginInput): ResolveAssignLoginResult { + const parsed = parseAssignGithubOption(input.githubOption); + if (parsed.kind === "invalid") { + return { ok: false, message: parsed.detail }; + } + if (parsed.kind === "login") { + return { ok: true, login: parsed.login, source: "explicit" }; + } + + const discordId = input.requesterDiscordId?.trim() ?? ""; + if (discordId.length === 0) { + return { + ok: false, + message: "Could not resolve your Discord user id. Pass `github:` explicitly.", + }; + } + const person = input.resolveByDiscordId(discordId); + const login = person?.github?.login?.trim(); + if (login === undefined || login.length === 0) { + return { + ok: false, + message: + "You are not in the Discord→GitHub identity map (or have no `githubLogin`). Pass `github:`, or ask an operator to map your Discord id.", + }; + } + return { ok: true, login, source: "self" }; +} + +export type AssignPullRequestResult = { + readonly url: string; + readonly status: "assigned" | "skipped" | "error"; + readonly detail?: string | undefined; +}; + +/** + * Assign `login` on each PR URL via GitHub Issues assignees API (works for PRs). + * Best-effort: failures are returned per-URL and never throw. + */ +export async function assignPullRequestAssignees(input: { + readonly prUrls: ReadonlyArray; + readonly login: string; + readonly execFile?: ExecFileLike; +}): Promise> { + const execImpl = input.execFile ?? execFile; + const login = input.login.trim().replace(/^@/u, ""); + const results: AssignPullRequestResult[] = []; + + for (const raw of input.prUrls) { + const normalized = normalizePullRequestUrl(raw); + if (normalized === null) { + results.push({ url: raw, status: "skipped", detail: "not a github pull request url" }); + continue; + } + + try { + await postPullRequestAssignee(normalized, login, execImpl); + results.push({ url: normalized.url, status: "assigned" }); + } catch (error) { + results.push({ + url: normalized.url, + status: "error", + detail: error instanceof Error ? error.message : String(error), + }); + } + } + + return results; +} + +async function postPullRequestAssignee( + pr: NormalizedPullRequestLink, + login: string, + execImpl: ExecFileLike, +): Promise { + // Issues assignees endpoint is the supported way to set PR assignees. + await execImpl( + "gh", + [ + "api", + `repos/${pr.owner}/${pr.repo}/issues/${pr.number}/assignees`, + "-X", + "POST", + "-f", + `assignees[]=${login}`, + ], + { env: gitCommandEnv(), maxBuffer: 2 * 1024 * 1024 }, + ); +} + +/** Format a short public slash reply summarizing assign results. */ +export function formatAssignSlashReply(input: { + readonly login: string; + readonly results: ReadonlyArray; +}): string { + const loginLabel = `@${input.login.replace(/^@/u, "")}`; + if (input.results.length === 0) { + return `No linked pull requests on this thread to assign to ${loginLabel}.`; + } + + const assigned = input.results.filter((r) => r.status === "assigned"); + const errors = input.results.filter((r) => r.status === "error"); + const skipped = input.results.filter((r) => r.status === "skipped"); + + const lines: string[] = []; + if (assigned.length > 0) { + lines.push( + `Assigned ${loginLabel} on ${assigned.length} PR(s):`, + ...assigned.map((r) => `• ${r.url}`), + ); + } + if (errors.length > 0) { + lines.push( + `Failed ${errors.length} PR(s):`, + ...errors.map((r) => `• ${r.url}${r.detail !== undefined ? ` — ${r.detail}` : ""}`), + ); + } + if (skipped.length > 0 && assigned.length === 0 && errors.length === 0) { + lines.push(`Nothing assignable (${skipped.length} skipped).`); + } + + return lines.join("\n"); +} diff --git a/apps/discord-bot/src/presentation/prLinks.test.ts b/apps/discord-bot/src/presentation/prLinks.test.ts new file mode 100644 index 000000000000..af7b06ae902a --- /dev/null +++ b/apps/discord-bot/src/presentation/prLinks.test.ts @@ -0,0 +1,178 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + extractPullRequestUrls, + extractPullRequestUrlsFromDiscordMessage, + formatPullRequestLabel, + formatPullRequestLinksForDiscord, + mergePullRequestUrls, + sortPullRequestUrlsForDisplay, + normalizeGithubRepoSlug, + normalizePullRequestUrl, +} from "./prLinks.ts"; + +describe("normalizePullRequestUrl", () => { + it("canonicalizes GitHub PR URLs", () => { + expect(normalizePullRequestUrl("https://github.com/pingdotgg/t3code/pull/42")).toEqual({ + url: "https://github.com/pingdotgg/t3code/pull/42", + owner: "pingdotgg", + repo: "t3code", + number: 42, + repoSlug: "pingdotgg/t3code", + }); + }); + + it("strips subpaths, query, hash, and www; lowercases owner/repo", () => { + expect( + normalizePullRequestUrl( + "https://www.GitHub.com/PingDotGG/T3Code/pull/7/files?w=1#discussion_r1", + ), + ).toEqual({ + url: "https://github.com/pingdotgg/t3code/pull/7", + owner: "pingdotgg", + repo: "t3code", + number: 7, + repoSlug: "pingdotgg/t3code", + }); + }); + + it("rejects non-PR URLs", () => { + expect(normalizePullRequestUrl("https://github.com/pingdotgg/t3code/issues/1")).toBeNull(); + expect(normalizePullRequestUrl("https://gitlab.com/foo/bar/-/merge_requests/1")).toBeNull(); + expect(normalizePullRequestUrl("not a url")).toBeNull(); + }); +}); + +describe("normalizeGithubRepoSlug", () => { + it("accepts owner/repo and github URLs", () => { + expect(normalizeGithubRepoSlug("Example-Org/Configurator")).toBe("example-org/configurator"); + expect(normalizeGithubRepoSlug("https://github.com/example-org/scanner.git")).toBe( + "example-org/scanner", + ); + }); +}); + +describe("formatPullRequestLabel", () => { + const pr = { + owner: "example-org", + repo: "configurator", + number: 123, + repoSlug: "example-org/configurator", + }; + + it("uses PR #N when channel repo matches or is unknown", () => { + expect(formatPullRequestLabel(pr, "example-org/configurator")).toBe("PR #123"); + expect(formatPullRequestLabel(pr, null)).toBe("PR #123"); + expect(formatPullRequestLabel(pr, undefined)).toBe("PR #123"); + }); + + it("prefixes owner/repo when the PR is from another channel repo", () => { + expect(formatPullRequestLabel(pr, "example-org/scanner")).toBe( + "example-org/configurator PR #123", + ); + }); +}); + +describe("extractPullRequestUrls", () => { + it("extracts URLs in first-seen order without duplicates", () => { + const text = [ + "see https://github.com/acme/widgets/pull/42", + "and https://github.com/acme/widgets/pull/7/files", + "and https://github.com/acme/widgets/pull/42 again", + "plus **Draft PR:** https://github.com/example-org/scanner/pull/1950", + ].join(" "); + expect(extractPullRequestUrls(text)).toEqual([ + "https://github.com/acme/widgets/pull/42", + "https://github.com/acme/widgets/pull/7", + "https://github.com/example-org/scanner/pull/1950", + ]); + }); + + it("reads embeds as well as content", () => { + expect( + extractPullRequestUrlsFromDiscordMessage({ + content: "ping", + embeds: [ + { + url: "https://github.com/acme/widgets/pull/9", + title: "Fix packing", + }, + ], + }), + ).toEqual(["https://github.com/acme/widgets/pull/9"]); + }); +}); + +describe("mergePullRequestUrls", () => { + it("appends only new URLs in order", () => { + expect( + mergePullRequestUrls( + ["https://github.com/a/b/pull/1", "https://github.com/a/b/pull/2"], + [ + "https://github.com/a/b/pull/2/files", + "https://github.com/a/b/pull/3", + "https://github.com/A/B/pull/1", + ], + ), + ).toEqual([ + "https://github.com/a/b/pull/1", + "https://github.com/a/b/pull/2", + "https://github.com/a/b/pull/3", + ]); + }); +}); + +describe("formatPullRequestLinksForDiscord", () => { + it("renders PR #N for same-repo PRs and prefixes foreign repos", () => { + expect( + formatPullRequestLinksForDiscord( + [ + "https://github.com/example-org/scanner/pull/1950", + "https://github.com/example-org/configurator/pull/123", + ], + { channelRepoSlug: "example-org/scanner" }, + ), + ).toBe( + [ + "**PRs**", + "• [PR #1950](https://github.com/example-org/scanner/pull/1950)", + "• [example-org/configurator PR #123](https://github.com/example-org/configurator/pull/123)", + ].join("\n"), + ); + }); + + it("returns null for empty lists", () => { + expect(formatPullRequestLinksForDiscord([])).toBeNull(); + }); + + it("sorts current-project PRs above foreign repos while keeping first-seen order within groups", () => { + expect( + formatPullRequestLinksForDiscord( + [ + "https://github.com/example-org/configurator/pull/10", + "https://github.com/example-org/scanner/pull/2", + "https://github.com/other/repo/pull/99", + "https://github.com/example-org/scanner/pull/1", + "https://github.com/example-org/configurator/pull/11", + ], + { channelRepoSlug: "example-org/scanner" }, + ), + ).toBe( + [ + "**PRs**", + "• [PR #2](https://github.com/example-org/scanner/pull/2)", + "• [PR #1](https://github.com/example-org/scanner/pull/1)", + "• [example-org/configurator PR #10](https://github.com/example-org/configurator/pull/10)", + "• [other/repo PR #99](https://github.com/other/repo/pull/99)", + "• [example-org/configurator PR #11](https://github.com/example-org/configurator/pull/11)", + ].join("\n"), + ); + }); +}); + +describe("sortPullRequestUrlsForDisplay", () => { + it("leaves order unchanged when channel repo is unknown", () => { + const urls = ["https://github.com/a/b/pull/1", "https://github.com/c/d/pull/2"]; + expect(sortPullRequestUrlsForDisplay(urls, null)).toEqual(urls); + }); +}); diff --git a/apps/discord-bot/src/presentation/prLinks.ts b/apps/discord-bot/src/presentation/prLinks.ts new file mode 100644 index 000000000000..4d26f66c2284 --- /dev/null +++ b/apps/discord-bot/src/presentation/prLinks.ts @@ -0,0 +1,196 @@ +/** + * Extract and format GitHub pull request URLs from Discord message text. + * + * URLs are stored in first-seen order. Duplicates are ignored after normalization + * (strip query/hash, drop common subpaths like /files, case-fold host/owner/repo). + */ + +/** GitHub PR URL: https://github.com/owner/repo/pull/123[/optional-suffix] */ +const GITHUB_PR_URL_SOURCE = + "https?:\\/\\/(?:www\\.)?github\\.com\\/([A-Za-z0-9_.-]+)\\/([A-Za-z0-9_.-]+)\\/pull\\/(\\d+)(?:\\/[^\\s<>\"'#?]*)?(?:[?#][^\\s<>\"']*)?"; + +/** Non-global: safe for single-URL normalization. */ +const GITHUB_PR_URL_SINGLE = new RegExp(GITHUB_PR_URL_SOURCE, "i"); + +/** Global: for multi-match extraction only — never share lastIndex with single-match helpers. */ +const GITHUB_PR_URL_GLOBAL = new RegExp(GITHUB_PR_URL_SOURCE, "gi"); + +export type NormalizedPullRequestLink = { + /** Canonical browse URL: https://github.com/owner/repo/pull/N */ + readonly url: string; + readonly owner: string; + readonly repo: string; + readonly number: number; + /** `owner/repo` slug (lowercase). */ + readonly repoSlug: string; +}; + +/** + * Normalize `owner/repo` or a github.com repo URL to a lowercase `owner/repo` slug. + */ +export function normalizeGithubRepoSlug(raw: string | null | undefined): string | null { + if (raw === null || raw === undefined) return null; + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + + const urlMatch = + /^https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?(?:\/.*)?$/iu.exec( + trimmed, + ); + if (urlMatch?.[1] !== undefined && urlMatch[2] !== undefined) { + return `${urlMatch[1].toLowerCase()}/${urlMatch[2].toLowerCase().replace(/\.git$/iu, "")}`; + } + + const slugMatch = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/u.exec(trimmed); + if (slugMatch?.[1] !== undefined && slugMatch[2] !== undefined) { + return `${slugMatch[1].toLowerCase()}/${slugMatch[2].toLowerCase()}`; + } + return null; +} + +/** + * Discord label for a PR: + * - same repo as the channel (or unknown channel repo) → `PR #N` + * - different repo → `owner/repo PR #N` + */ +export function formatPullRequestLabel( + pr: Pick, + channelRepoSlug?: string | null, +): string { + const channel = normalizeGithubRepoSlug(channelRepoSlug); + if (channel === null || channel === pr.repoSlug) { + return `PR #${pr.number}`; + } + return `${pr.repoSlug} PR #${pr.number}`; +} + +/** + * Normalize a raw GitHub PR URL (or fragment containing one) to a canonical form. + * Returns null when the text does not contain a valid GitHub PR URL. + */ +export function normalizePullRequestUrl(raw: string): NormalizedPullRequestLink | null { + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + + const match = GITHUB_PR_URL_SINGLE.exec(trimmed); + if (match === null) return null; + + const owner = (match[1] ?? "").toLowerCase(); + const repo = (match[2] ?? "").replace(/\.git$/iu, "").toLowerCase(); + const number = Number.parseInt(match[3] ?? "", 10); + if (owner.length === 0 || repo.length === 0 || !Number.isFinite(number) || number <= 0) { + return null; + } + + const url = `https://github.com/${owner}/${repo}/pull/${number}`; + return { + url, + owner, + repo, + number, + repoSlug: `${owner}/${repo}`, + }; +} + +/** + * Extract PR URLs from free text in left-to-right first-seen order without duplicates. + */ +export function extractPullRequestUrls(text: string | null | undefined): ReadonlyArray { + if (text === null || text === undefined || text.length === 0) return []; + + const found: string[] = []; + const seen = new Set(); + + for (const match of text.matchAll(GITHUB_PR_URL_GLOBAL)) { + const normalized = normalizePullRequestUrl(match[0] ?? ""); + if (normalized === null || seen.has(normalized.url)) continue; + seen.add(normalized.url); + found.push(normalized.url); + } + return found; +} + +export function extractPullRequestUrlsFromDiscordMessage(input: { + readonly content?: string | null | undefined; + readonly embeds?: + | ReadonlyArray<{ + readonly url?: string | null | undefined; + readonly title?: string | null | undefined; + readonly description?: string | null | undefined; + readonly footer?: { readonly text?: string | null | undefined } | null | undefined; + }> + | null + | undefined; +}): ReadonlyArray { + const parts: string[] = []; + if (input.content) parts.push(input.content); + for (const embed of input.embeds ?? []) { + if (embed.url) parts.push(embed.url); + if (embed.title) parts.push(embed.title); + if (embed.description) parts.push(embed.description); + if (embed.footer?.text) parts.push(embed.footer.text); + } + return extractPullRequestUrls(parts.join("\n")); +} + +/** Append newly seen PR URLs preserving first-seen order; never duplicates. */ +export function mergePullRequestUrls( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, +): ReadonlyArray { + const result: string[] = []; + const seen = new Set(); + for (const raw of [...(existing ?? []), ...(incoming ?? [])]) { + const normalized = normalizePullRequestUrl(raw); + if (normalized === null || seen.has(normalized.url)) continue; + seen.add(normalized.url); + result.push(normalized.url); + } + return result; +} + +/** + * Order PR URLs for the pinned thread header: current project/repo first, + * then everything else. Within each group, preserve first-seen order. + */ +export function sortPullRequestUrlsForDisplay( + urls: ReadonlyArray, + channelRepoSlug?: string | null, +): ReadonlyArray { + const ordered = mergePullRequestUrls([], urls); + if (ordered.length === 0) return ordered; + + const channel = normalizeGithubRepoSlug(channelRepoSlug); + if (channel === null) return ordered; + + const current: string[] = []; + const other: string[] = []; + for (const url of ordered) { + const normalized = normalizePullRequestUrl(url); + if (normalized !== null && normalized.repoSlug === channel) { + current.push(normalized.url); + } else { + other.push(normalized?.url ?? url); + } + } + return [...current, ...other]; +} + +export function formatPullRequestLinksForDiscord( + urls: ReadonlyArray, + options?: { + /** Channel / project GitHub repo as `owner/repo` (or github URL). */ + readonly channelRepoSlug?: string | null; + }, +): string | null { + const ordered = sortPullRequestUrlsForDisplay(urls, options?.channelRepoSlug); + if (ordered.length === 0) return null; + + const lines = ordered.map((url) => { + const normalized = normalizePullRequestUrl(url); + if (normalized === null) return `• ${url}`; + const label = formatPullRequestLabel(normalized, options?.channelRepoSlug); + return `• [${label}](${normalized.url})`; + }); + return ["**PRs**", ...lines].join("\n"); +} diff --git a/apps/discord-bot/src/presentation/sentryLinks.test.ts b/apps/discord-bot/src/presentation/sentryLinks.test.ts new file mode 100644 index 000000000000..25ae92f6e783 --- /dev/null +++ b/apps/discord-bot/src/presentation/sentryLinks.test.ts @@ -0,0 +1,119 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + applySentryShortIdToIssueUrl, + discordMessageLooksLikeSentry, + extractSentryIssueUrls, + extractSentryIssueUrlsFromDiscordMessage, + formatLinkedSentryWorkItemsBlock, + formatSentryLinksForDiscord, + mergeSentryIssueUrls, + normalizeSentryIssueUrl, + sentryIssueLabelFromUrl, + sentryShortIdFromText, +} from "./sentryLinks.ts"; + +const SCANNER_SENTRY_URL = "https://macs-scanner.sentry.io/issues/SCANNER-313"; +const NUMERIC_SENTRY_URL = "https://macs-scanner.sentry.io/issues/7506163172"; + +describe("normalizeSentryIssueUrl", () => { + it("canonicalizes org subdomain issue URLs", () => { + expect(normalizeSentryIssueUrl(`${SCANNER_SENTRY_URL}/?project=1#events`)).toBe( + SCANNER_SENTRY_URL, + ); + expect(normalizeSentryIssueUrl("http://De.Sentry.io/issues/ABC-1/")).toBe( + "https://de.sentry.io/issues/ABC-1", + ); + }); + + it("rejects non-sentry hosts", () => { + expect(normalizeSentryIssueUrl("https://example.atlassian.net/browse/SCANNER-313")).toBeNull(); + expect(normalizeSentryIssueUrl("https://example.com/sentry.io/issues/1")).toBeNull(); + }); +}); + +describe("extractSentryIssueUrls", () => { + it("finds sentry.io links including short ids in the path", () => { + expect( + extractSentryIssueUrls(`see ${SCANNER_SENTRY_URL}/ and also ${NUMERIC_SENTRY_URL}/`), + ).toEqual([SCANNER_SENTRY_URL, NUMERIC_SENTRY_URL]); + }); +}); + +describe("discordMessageLooksLikeSentry / extract from Discord", () => { + it("detects Sentry bot embeds with a sentry.io url and short-id footer", () => { + const message = { + author: { username: "Sentry", bot: true }, + content: "", + embeds: [ + { + title: "T3 did not become ready after a server restart", + url: `${NUMERIC_SENTRY_URL}/`, + footer: { text: "SCANNER-313" }, + }, + ], + }; + expect(discordMessageLooksLikeSentry(message)).toBe(true); + expect(extractSentryIssueUrlsFromDiscordMessage(message)).toEqual([SCANNER_SENTRY_URL]); + }); + + it("detects a pasted sentry.io link from a human", () => { + expect( + discordMessageLooksLikeSentry({ + author: { username: "patroza" }, + content: `what happened here? ${SCANNER_SENTRY_URL}`, + }), + ).toBe(true); + }); + + it("does not treat ordinary messages as Sentry", () => { + expect( + discordMessageLooksLikeSentry({ + author: { username: "patroza" }, + content: "please look at PROJ-367", + }), + ).toBe(false); + }); +}); + +describe("formatSentryLinksForDiscord", () => { + it("renders markdown links labelled with the issue id", () => { + expect(sentryIssueLabelFromUrl(SCANNER_SENTRY_URL)).toBe("SCANNER-313"); + expect(formatSentryLinksForDiscord([`${NUMERIC_SENTRY_URL}/`, SCANNER_SENTRY_URL])).toBe( + [ + "**Sentry**", + `• [7506163172](${NUMERIC_SENTRY_URL})`, + `• [SCANNER-313](${SCANNER_SENTRY_URL})`, + ].join("\n"), + ); + }); + + it("returns null for empty lists", () => { + expect(formatSentryLinksForDiscord([])).toBeNull(); + expect(mergeSentryIssueUrls(["x"], [SCANNER_SENTRY_URL])).toEqual([SCANNER_SENTRY_URL]); + }); +}); + +describe("sentry short ids on numeric issue URLs", () => { + it("reads the qualified short id from a Sentry footer", () => { + expect(sentryShortIdFromText("SCANNER-313")).toBe("SCANNER-313"); + expect(sentryShortIdFromText("SCANNER-313 via Scanner API • Today at 12:55 PM")).toBe( + "SCANNER-313", + ); + expect(sentryShortIdFromText("please look at PROJ-367")).toBeNull(); + }); + + it("rewrites numeric /issues/N paths", () => { + expect(applySentryShortIdToIssueUrl(NUMERIC_SENTRY_URL, "SCANNER-313")).toBe( + SCANNER_SENTRY_URL, + ); + expect(applySentryShortIdToIssueUrl(SCANNER_SENTRY_URL, "OTHER-1")).toBe(SCANNER_SENTRY_URL); + }); + + it("formats durable agent-turn URLs", () => { + expect(formatLinkedSentryWorkItemsBlock([`${NUMERIC_SENTRY_URL}/`, SCANNER_SENTRY_URL])).toBe( + `sentry: ${NUMERIC_SENTRY_URL} ${SCANNER_SENTRY_URL}`, + ); + expect(formatLinkedSentryWorkItemsBlock([])).toBeNull(); + }); +}); diff --git a/apps/discord-bot/src/presentation/sentryLinks.ts b/apps/discord-bot/src/presentation/sentryLinks.ts new file mode 100644 index 000000000000..382be5f3396f --- /dev/null +++ b/apps/discord-bot/src/presentation/sentryLinks.ts @@ -0,0 +1,252 @@ +/** + * Detect Sentry issue URLs / Discord alert embeds so they are not treated as Jira. + * + * Sentry short ids (`SCANNER-313`) have the same shape as Jira keys (`PROJ-123`). + * Classification must use the surrounding URL / bot author, not the token alone. + */ + +/** Host is sentry.io or a subdomain (org.sentry.io, de.sentry.io, …). */ +const SENTRY_HOST = /(?:^|\.)sentry\.io$/iu; + +/** + * Absolute sentry.io issue/share URL. Trailing punctuation is left on the match + * and stripped during normalize so markdown `(url)` / `url.` still parse. + */ +const SENTRY_URL_PATTERN = /https?:\/\/(?:[a-z0-9-]+\.)*sentry\.io\/[^\s<>"'\])]*/gi; + +export type SentryDiscordMessageInput = { + readonly content?: string | null | undefined; + readonly author?: + | { + readonly username?: string | null | undefined; + readonly displayName?: string | null | undefined; + readonly global_name?: string | null | undefined; + readonly bot?: boolean | undefined; + } + | null + | undefined; + readonly embeds?: + | ReadonlyArray<{ + readonly url?: string | null | undefined; + readonly title?: string | null | undefined; + readonly description?: string | null | undefined; + readonly author?: { readonly name?: string | null | undefined } | null | undefined; + readonly footer?: { readonly text?: string | null | undefined } | null | undefined; + readonly fields?: + | ReadonlyArray<{ + readonly name?: string | null | undefined; + readonly value?: string | null | undefined; + }> + | null + | undefined; + }> + | null + | undefined; +}; + +export function isSentryHostname(hostname: string): boolean { + return SENTRY_HOST.test(hostname.trim()); +} + +export function sentryIssueUrlRanges( + text: string, +): ReadonlyArray<{ readonly start: number; readonly end: number }> { + const ranges: Array<{ start: number; end: number }> = []; + SENTRY_URL_PATTERN.lastIndex = 0; + let match: RegExpExecArray | null; + while ((match = SENTRY_URL_PATTERN.exec(text)) !== null) { + ranges.push({ start: match.index, end: match.index + match[0].length }); + } + return ranges; +} + +export function textHasSentryIssueUrl(text: string | null | undefined): boolean { + if (text === null || text === undefined || text.length === 0) return false; + return sentryIssueUrlRanges(text).length > 0; +} + +function authorLooksLikeSentryBot(name: string | null | undefined): boolean { + if (name === null || name === undefined) return false; + const trimmed = name.trim(); + if (trimmed.length === 0) return false; + return /^sentry(?:[\s._-]?bot)?$/iu.test(trimmed); +} + +/** True when this Discord message is a Sentry alert, unfurl, or pasted sentry.io link. */ +export function discordMessageLooksLikeSentry(input: SentryDiscordMessageInput): boolean { + if (authorLooksLikeSentryBot(input.author?.username)) return true; + if (authorLooksLikeSentryBot(input.author?.displayName)) return true; + if (authorLooksLikeSentryBot(input.author?.global_name)) return true; + if (textHasSentryIssueUrl(input.content)) return true; + for (const embed of input.embeds ?? []) { + if (authorLooksLikeSentryBot(embed.author?.name)) return true; + if (typeof embed.url === "string" && textHasSentryIssueUrl(embed.url)) return true; + if (typeof embed.title === "string" && textHasSentryIssueUrl(embed.title)) return true; + if (typeof embed.description === "string" && textHasSentryIssueUrl(embed.description)) { + return true; + } + if (typeof embed.footer?.text === "string" && textHasSentryIssueUrl(embed.footer.text)) { + return true; + } + for (const field of embed.fields ?? []) { + if (typeof field.value === "string" && textHasSentryIssueUrl(field.value)) return true; + } + } + return false; +} + +/** + * Canonical browse URL: https host, no query/hash, no trailing slash on the path. + * Returns null when the string is not a sentry.io http(s) URL. + */ +export function normalizeSentryIssueUrl(raw: string): string | null { + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + + const match = /https?:\/\/(?:[a-z0-9-]+\.)*sentry\.io\/[^\s<>"'\])]*/iu.exec(trimmed); + if (match === null) return null; + + let candidate = match[0] ?? ""; + candidate = candidate.replace(/[),.;]+$/u, ""); + try { + const url = new URL(candidate); + if (!isSentryHostname(url.hostname)) return null; + url.hash = ""; + url.search = ""; + url.protocol = "https:"; + if (url.pathname.length > 1) { + url.pathname = url.pathname.replace(/\/+$/u, ""); + } + return url.toString(); + } catch { + return null; + } +} + +export function mergeSentryIssueUrls( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, +): ReadonlyArray { + const result: string[] = []; + const seen = new Set(); + for (const raw of [...(existing ?? []), ...(incoming ?? [])]) { + const url = normalizeSentryIssueUrl(raw); + if (url === null || seen.has(url)) continue; + seen.add(url); + result.push(url); + } + return result; +} + +export function extractSentryIssueUrls(text: string | null | undefined): ReadonlyArray { + if (text === null || text === undefined || text.length === 0) return []; + const found: string[] = []; + const seen = new Set(); + for (const range of sentryIssueUrlRanges(text)) { + const url = normalizeSentryIssueUrl(text.slice(range.start, range.end)); + if (url === null || seen.has(url)) continue; + seen.add(url); + found.push(url); + } + return found; +} + +/** + * Sentry Discord footers start with the qualified short id (`SCANNER-313`, + * `EXAMPLE-PROJECT-API-JW`). Used to label numeric `/issues/123` URLs. + */ +export function sentryShortIdFromText(text: string | null | undefined): string | null { + if (text === null || text === undefined) return null; + const trimmed = text.trim(); + if (trimmed.length === 0) return null; + const match = /^([A-Z][A-Z0-9]+(?:-[A-Z0-9]+)+)\b/u.exec(trimmed); + const id = match?.[1]; + if (id === undefined || id.length < 3) return null; + return id; +} + +/** Replace a numeric `/issues/123` path with a Sentry short id when we have one. */ +export function applySentryShortIdToIssueUrl(url: string, shortId: string): string { + const normalized = normalizeSentryIssueUrl(url); + if (normalized === null) return url; + try { + const parsed = new URL(normalized); + if (/\/issues\/\d+$/u.test(parsed.pathname)) { + parsed.pathname = parsed.pathname.replace(/\/issues\/\d+$/u, `/issues/${shortId}`); + return parsed.toString(); + } + } catch { + return normalized; + } + return normalized; +} + +function joinSentryMessageText(input: SentryDiscordMessageInput): string { + const parts: string[] = []; + if (input.content) parts.push(input.content); + for (const embed of input.embeds ?? []) { + if (embed.url) parts.push(embed.url); + if (embed.title) parts.push(embed.title); + if (embed.description) parts.push(embed.description); + if (embed.footer?.text) parts.push(embed.footer.text); + for (const field of embed.fields ?? []) { + if (field.value) parts.push(field.value); + } + } + return parts.join("\n"); +} + +export function extractSentryIssueUrlsFromDiscordMessage( + input: SentryDiscordMessageInput, +): ReadonlyArray { + const urls = extractSentryIssueUrls(joinSentryMessageText(input)); + const shortId = + sentryShortIdFromText(input.embeds?.find((embed) => embed.footer?.text)?.footer?.text) ?? + sentryShortIdFromText(input.content); + if (shortId === null) return urls; + return mergeSentryIssueUrls( + [], + urls.map((url) => applySentryShortIdToIssueUrl(url, shortId)), + ); +} + +/** + * Durable per-thread Sentry issue URLs for agent turns (one line). + * Omitted when none are known so ordinary prompts stay compact. + */ +export function formatLinkedSentryWorkItemsBlock( + urls: ReadonlyArray | null | undefined, +): string | null { + const ordered = mergeSentryIssueUrls([], urls); + if (ordered.length === 0) return null; + return `sentry: ${ordered.join(" ")}`; +} + +/** Compact pin/prompt label: issue path id (`SCANNER-313` or numeric id). */ +export function sentryIssueLabelFromUrl(url: string): string { + const normalized = normalizeSentryIssueUrl(url) ?? url.trim(); + try { + const parsed = new URL(normalized); + const issueMatch = parsed.pathname.match(/\/issues\/([^/]+)/iu); + if (issueMatch?.[1] !== undefined && issueMatch[1].length > 0) { + return decodeURIComponent(issueMatch[1]); + } + const shareMatch = parsed.pathname.match(/\/share\/([^/]+)/iu); + if (shareMatch?.[1] !== undefined && shareMatch[1].length > 0) { + return decodeURIComponent(shareMatch[1]); + } + } catch { + // fall through + } + return normalized; +} + +export function formatSentryLinksForDiscord(urls: ReadonlyArray): string | null { + const ordered = mergeSentryIssueUrls([], urls); + if (ordered.length === 0) return null; + const lines = ordered.map((url) => { + const label = sentryIssueLabelFromUrl(url); + return `• [${label}](${url})`; + }); + return ["**Sentry**", ...lines].join("\n"); +} diff --git a/apps/discord-bot/src/presentation/slashCommands.test.ts b/apps/discord-bot/src/presentation/slashCommands.test.ts new file mode 100644 index 000000000000..9895a040cd7e --- /dev/null +++ b/apps/discord-bot/src/presentation/slashCommands.test.ts @@ -0,0 +1,131 @@ +import { Discord } from "dfx"; +import { describe, expect, it } from "vite-plus/test"; + +import { + formatAskSlashAck, + isThreadTalkSlashAction, + OMEGENT_SLASH_COMMAND, + OMEGENT_SLASH_COMMAND_ALIAS, + OMEGENT_SLASH_COMMAND_NAME, + slashDefer, + slashReply, + threadTalkSlashReply, +} from "./slashCommands.ts"; + +describe("Omegent slash command definition", () => { + it("registers /omegent (alias /agent) with the control-plane subcommands", () => { + expect(OMEGENT_SLASH_COMMAND_NAME).toBe("omegent"); + expect(OMEGENT_SLASH_COMMAND_ALIAS).toBe("agent"); + expect(OMEGENT_SLASH_COMMAND.name).toBe("omegent"); + const names = OMEGENT_SLASH_COMMAND.options.map((option) => option.name); + expect(names).toEqual([ + "ask", + "steer", + "queue", + "steernow", + "today-recap", + "help", + "stop", + "compact", + "thread-talk", + "link", + "refresh-indicators", + "assign", + ]); + }); + + it("registers optional github option on assign", () => { + const assign = OMEGENT_SLASH_COMMAND.options.find((option) => option.name === "assign"); + expect(assign?.options?.[0]?.name).toBe("github"); + expect(assign?.options?.[0]?.required).toBe(false); + }); + + it("uses Discord subcommand option types", () => { + for (const option of OMEGENT_SLASH_COMMAND.options) { + expect(option.type).toBe(Discord.ApplicationCommandOptionType.SUB_COMMAND); + } + const threadTalk = OMEGENT_SLASH_COMMAND.options.find( + (option) => option.name === "thread-talk", + ); + expect(threadTalk?.options?.[0]?.name).toBe("action"); + expect(threadTalk?.options?.[0]?.choices?.map((choice) => choice.value)).toEqual([ + "on", + "off", + "status", + ]); + }); +}); + +describe("slash reply helpers", () => { + it("builds public and ephemeral replies", () => { + const publicReply = slashReply("hello"); + expect(publicReply).toEqual({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "hello", + flags: Discord.MessageFlags.SuppressEmbeds, + }, + }); + + const ephemeralReply = slashReply("secret", { ephemeral: true }); + expect(ephemeralReply).toEqual({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: "secret", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + }); + + it("builds an ephemeral deferred ack for slow commands", () => { + expect(slashDefer({ ephemeral: true })).toEqual({ + type: Discord.InteractionCallbackTypes.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE, + data: { + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + }); + + it("formats a public ask ack with optional flags and truncation", () => { + expect( + formatAskSlashAck({ + displayName: "Example User", + prompt: "fix the flaky test", + plan: true, + local: false, + }), + ).toBe("**Example User** asked (`--plan`):\nfix the flaky test"); + + const long = "x".repeat(300); + const ack = formatAskSlashAck({ + displayName: "Example User", + prompt: long, + plan: false, + local: true, + }); + expect(ack).toContain("(`--local`)"); + expect(ack.endsWith("…")).toBe(true); + expect(ack.length).toBeLessThan(long.length + 40); + }); + + it("makes thread-talk status ephemeral and on/off public", () => { + expect(isThreadTalkSlashAction("on")).toBe(true); + expect(isThreadTalkSlashAction("nope")).toBe(false); + + const onReply = threadTalkSlashReply({ action: "on", enabled: true }); + expect(onReply).toMatchObject({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { content: expect.stringContaining("Thread-talk is **on**") }, + }); + expect(onReply).not.toMatchObject({ data: { flags: Discord.MessageFlags.Ephemeral } }); + + const statusReply = threadTalkSlashReply({ action: "status", enabled: false }); + expect(statusReply).toMatchObject({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content: expect.stringContaining("Thread-talk is **off**"), + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }, + }); + }); +}); diff --git a/apps/discord-bot/src/presentation/slashCommands.ts b/apps/discord-bot/src/presentation/slashCommands.ts new file mode 100644 index 000000000000..bddf1957808e --- /dev/null +++ b/apps/discord-bot/src/presentation/slashCommands.ts @@ -0,0 +1,290 @@ +import { Discord, Ix } from "dfx"; + +import { interactionMessageFlags } from "./suppressEmbeds.ts"; + +/** + * Guild-scoped `/omegent` control commands, with `/agent` as an alias, alongside + * existing `@Omegent` mentions. Guild registration propagates immediately for + * try-out; mentions stay the prompt path. + */ +export const OMEGENT_SLASH_COMMAND_NAME = "omegent" as const; + +/** + * Alias command name. Discord has no native command aliases, so `/agent` is + * registered as a second command that shares the `/omegent` handler. + */ +export const OMEGENT_SLASH_COMMAND_ALIAS = "agent" as const; + +export const OMEGENT_SLASH_COMMAND = { + name: OMEGENT_SLASH_COMMAND_NAME, + description: "Omegent bot commands (mentions still work for prompts)", + options: [ + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "ask", + description: "Start or continue a turn (public; same as @Omegent prompt)", + options: [ + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "prompt", + description: "What you want Omegent to do", + required: true, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "model", + description: "Model slug (e.g. gpt-5.4)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "provider", + description: "Provider instance id (e.g. codex)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "base", + description: "Base branch for a new worktree", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.BOOLEAN, + name: "local", + description: "Work without a worktree", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.BOOLEAN, + name: "plan", + description: "Run in plan mode", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.BOOLEAN, + name: "steer", + description: "Mid-turn: inject this prompt now (default is queue)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.BOOLEAN, + name: "queue", + description: "Mid-turn: park until the turn finishes (default)", + required: false, + }, + ], + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "steer", + description: "Continue work and inject mid-turn (steer into the active turn)", + options: [ + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "prompt", + description: "What you want Omegent to do", + required: true, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "model", + description: "Model slug (e.g. gpt-5.4)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "provider", + description: "Provider instance id (e.g. codex)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.BOOLEAN, + name: "plan", + description: "Run in plan mode", + required: false, + }, + ], + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "queue", + description: "Continue work and park mid-turn until the active turn finishes", + options: [ + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "prompt", + description: "What you want Omegent to do", + required: true, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "model", + description: "Model slug (e.g. gpt-5.4)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "provider", + description: "Provider instance id (e.g. codex)", + required: false, + }, + { + type: Discord.ApplicationCommandOptionType.BOOLEAN, + name: "plan", + description: "Run in plan mode", + required: false, + }, + ], + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "steernow", + description: "Inject every parked follow-up into the active turn (FIFO)", + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "today-recap", + description: "Daily PR recap for the repo bound to this channel", + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "help", + description: "Show the channel info / help pin", + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "stop", + description: "Stop the active turn in this linked thread", + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "compact", + description: "Compact provider context for this linked thread (posts token stats)", + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "thread-talk", + description: "Mention-free replies in this linked thread", + options: [ + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "action", + description: "Turn mention-free mode on/off, or report status", + required: true, + choices: [ + { name: "on", value: "on" }, + { name: "off", value: "off" }, + { name: "status", value: "status" }, + ], + }, + ], + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "link", + description: "Link this channel or unlinked thread to an existing Omegent thread", + options: [ + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "ref", + description: "Omegent thread id or web URL containing ?thread=", + required: true, + }, + ], + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "refresh-indicators", + description: "Refresh Discord thread title badges (PR/VCS indicators)", + }, + { + type: Discord.ApplicationCommandOptionType.SUB_COMMAND, + name: "assign", + description: "Assign linked PR(s) on this thread (default: you via identity map)", + options: [ + { + type: Discord.ApplicationCommandOptionType.STRING, + name: "github", + description: "GitHub login (default: you / @me from the identity map)", + required: false, + }, + ], + }, + ], +} as const; + +export type ThreadTalkSlashAction = "on" | "off" | "status"; + +export function isThreadTalkSlashAction(value: string): value is ThreadTalkSlashAction { + return value === "on" || value === "off" || value === "status"; +} + +/** Build a standard interaction message response. */ +export function slashReply( + content: string, + options?: { readonly ephemeral?: boolean }, +): ReturnType { + return Ix.response({ + type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE, + data: { + content, + flags: interactionMessageFlags({ ephemeral: options?.ephemeral === true }), + }, + }); +} + +/** + * Ack within Discord's ~3s interaction window when work continues in the background. + * Follow up with `updateOriginalWebhookMessage(application_id, token, …)`. + * + * Note: dfx's `Ix.response` typing omits `data` on deferred type 5, but Discord accepts + * ephemeral flags there — return the REST payload shape directly. + */ +export function slashDefer(options?: { + readonly ephemeral?: boolean; +}): Discord.CreateInteractionResponseRequest { + if (options?.ephemeral === true) { + return { + type: Discord.InteractionCallbackTypes.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE, + data: { flags: interactionMessageFlags({ ephemeral: true }) }, + }; + } + return { + type: Discord.InteractionCallbackTypes.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE, + data: { flags: interactionMessageFlags() }, + }; +} + +export function threadTalkSlashReply(input: { + readonly action: ThreadTalkSlashAction; + readonly enabled: boolean; +}): ReturnType { + const content = input.enabled + ? "Thread-talk is **on**. New human messages in this linked thread will be sent to Omegent without requiring a mention." + : "Thread-talk is **off**. Mention `@Omegent` or use `/omegent` to send a message to Omegent."; + // on/off change shared thread policy → public; status is personal + return slashReply(content, { ephemeral: input.action === "status" }); +} + +/** Preview used in public `/omegent ask` acks (keep Discord-message friendly). */ +export function formatAskSlashAck(input: { + readonly displayName: string; + readonly prompt: string; + readonly plan: boolean; + readonly local: boolean; + readonly followUpDelivery?: "steer" | "queue"; +}): string { + const flags = [ + input.plan ? "`--plan`" : null, + input.local ? "`--local`" : null, + input.followUpDelivery === "queue" + ? "`--queue`" + : input.followUpDelivery === "steer" + ? "`--steer`" + : null, + ].filter((value): value is string => value !== null); + const flagSuffix = flags.length > 0 ? ` (${flags.join(" ")})` : ""; + const preview = + input.prompt.length > 280 ? `${input.prompt.slice(0, 277).trimEnd()}…` : input.prompt; + return `**${input.displayName}** asked${flagSuffix}:\n${preview}`; +} diff --git a/apps/discord-bot/src/presentation/suppressEmbeds.test.ts b/apps/discord-bot/src/presentation/suppressEmbeds.test.ts new file mode 100644 index 000000000000..c890d4e796a6 --- /dev/null +++ b/apps/discord-bot/src/presentation/suppressEmbeds.test.ts @@ -0,0 +1,47 @@ +import { Discord } from "dfx"; +import { describe, expect, it } from "vite-plus/test"; + +import { + interactionMessageFlags, + SUPPRESS_EMBEDS_FLAG, + withSuppressEmbeds, +} from "./suppressEmbeds.ts"; + +describe("withSuppressEmbeds", () => { + it("sets SuppressEmbeds when no flags are present", () => { + expect(withSuppressEmbeds({ content: "hi" })).toEqual({ + content: "hi", + flags: Discord.MessageFlags.SuppressEmbeds, + }); + expect(SUPPRESS_EMBEDS_FLAG).toBe(Discord.MessageFlags.SuppressEmbeds); + }); + + it("ORs SuppressEmbeds onto existing flags (e.g. Ephemeral)", () => { + expect( + withSuppressEmbeds({ content: "secret", flags: Discord.MessageFlags.Ephemeral }), + ).toEqual({ + content: "secret", + flags: Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + }); + }); + + it("treats null/undefined flags as unset", () => { + expect(withSuppressEmbeds({ content: "x", flags: null as number | null }).flags).toBe( + Discord.MessageFlags.SuppressEmbeds, + ); + expect(withSuppressEmbeds({ content: "y" }).flags).toBe(Discord.MessageFlags.SuppressEmbeds); + }); +}); + +describe("interactionMessageFlags", () => { + it("always includes SuppressEmbeds", () => { + expect(interactionMessageFlags()).toBe(Discord.MessageFlags.SuppressEmbeds); + expect(interactionMessageFlags({ ephemeral: false })).toBe(Discord.MessageFlags.SuppressEmbeds); + }); + + it("combines Ephemeral with SuppressEmbeds", () => { + expect(interactionMessageFlags({ ephemeral: true })).toBe( + Discord.MessageFlags.Ephemeral | Discord.MessageFlags.SuppressEmbeds, + ); + }); +}); diff --git a/apps/discord-bot/src/presentation/suppressEmbeds.ts b/apps/discord-bot/src/presentation/suppressEmbeds.ts new file mode 100644 index 000000000000..2b40ccae70f3 --- /dev/null +++ b/apps/discord-bot/src/presentation/suppressEmbeds.ts @@ -0,0 +1,31 @@ +/** + * Discord MessageFlags.SuppressEmbeds (1 << 2). + * Blocks automatic link previews / URL embeds. Does **not** affect file attachments. + * + * Numeric constant (not dfx import) so pure helpers stay mock-friendly in tests. + * @see https://discord.com/developers/docs/resources/message#message-object-message-flags + */ +export const SUPPRESS_EMBEDS_FLAG = 4; + +/** Discord MessageFlags.Ephemeral (1 << 6) — for interaction replies only. */ +const EPHEMERAL_FLAG = 64; + +/** + * Merge SuppressEmbeds into create/edit message options (or interaction `data`). + * Preserves existing flags (e.g. Ephemeral). + */ +export function withSuppressEmbeds( + options: T, +): Omit & { flags: number } { + const existing = (options as { flags?: number | null | undefined }).flags; + const flags = + existing === null || existing === undefined + ? SUPPRESS_EMBEDS_FLAG + : Number(existing) | SUPPRESS_EMBEDS_FLAG; + return { ...options, flags }; +} + +/** Flag bits for interaction message replies: always suppress embeds; optional ephemeral. */ +export function interactionMessageFlags(options?: { readonly ephemeral?: boolean }): number { + return options?.ephemeral === true ? EPHEMERAL_FLAG | SUPPRESS_EMBEDS_FLAG : SUPPRESS_EMBEDS_FLAG; +} diff --git a/apps/discord-bot/src/presentation/t3ThreadRef.test.ts b/apps/discord-bot/src/presentation/t3ThreadRef.test.ts new file mode 100644 index 000000000000..6da96a11e56c --- /dev/null +++ b/apps/discord-bot/src/presentation/t3ThreadRef.test.ts @@ -0,0 +1,48 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { extractT3ThreadId, parseLinkThreadCommand } from "./t3ThreadRef.ts"; + +describe("extractT3ThreadId", () => { + it("returns bare ids", () => { + expect(extractT3ThreadId(" abc-123 ")).toBe("abc-123"); + expect(extractT3ThreadId("550e8400-e29b-41d4-a716-446655440000")).toBe( + "550e8400-e29b-41d4-a716-446655440000", + ); + }); + + it("extracts thread from query strings and full URLs", () => { + expect(extractT3ThreadId("https://t3.example.com/?thread=tid-1")).toBe("tid-1"); + expect(extractT3ThreadId("http://127.0.0.1:5173/?foo=1&thread=tid-2")).toBe("tid-2"); + expect(extractT3ThreadId("https://host/?thread=tid%2Fwith%2Fslash")).toBe("tid/with/slash"); + }); + + it("rejects empty or ambiguous values", () => { + expect(extractT3ThreadId("")).toBeNull(); + expect(extractT3ThreadId("https://example.com/path")).toBeNull(); + expect(extractT3ThreadId("not a single token")).toBeNull(); + }); +}); + +describe("parseLinkThreadCommand", () => { + it("parses link / pick-up / pickup with bare id or url", () => { + expect(parseLinkThreadCommand("link tid-1")).toEqual({ + kind: "link-thread", + t3ThreadId: "tid-1", + }); + expect(parseLinkThreadCommand(" Pick-Up https://x/?thread=tid-2 ")).toEqual({ + kind: "link-thread", + t3ThreadId: "tid-2", + }); + expect(parseLinkThreadCommand("pickup tid-3")).toEqual({ + kind: "link-thread", + t3ThreadId: "tid-3", + }); + }); + + it("requires exact command form", () => { + expect(parseLinkThreadCommand("link")).toBeNull(); + expect(parseLinkThreadCommand("link tid-1 please")).toBeNull(); + expect(parseLinkThreadCommand("please link tid-1")).toBeNull(); + expect(parseLinkThreadCommand("fix the flaky test")).toBeNull(); + }); +}); diff --git a/apps/discord-bot/src/presentation/t3ThreadRef.ts b/apps/discord-bot/src/presentation/t3ThreadRef.ts new file mode 100644 index 000000000000..e950301e5f21 --- /dev/null +++ b/apps/discord-bot/src/presentation/t3ThreadRef.ts @@ -0,0 +1,42 @@ +/** + * Parse a bare T3 thread id or a T3 web URL that embeds one (`?thread=` / `&thread=`). + */ +export function extractT3ThreadId(raw: string): string | null { + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + + const fromQuery = /(?:\?|&)thread=([^&\s#]+)/iu.exec(trimmed); + if (fromQuery?.[1] !== undefined) { + try { + const decoded = decodeURIComponent(fromQuery[1]).trim(); + return decoded.length > 0 ? decoded : null; + } catch { + const value = fromQuery[1].trim(); + return value.length > 0 ? value : null; + } + } + + // Bare id: single token, not a URL/path. + if (/^https?:\/\//iu.test(trimmed) || trimmed.includes("/") || /\s/u.test(trimmed)) { + return null; + } + return trimmed; +} + +export type LinkThreadCommand = { + readonly kind: "link-thread"; + readonly t3ThreadId: string; +}; + +/** + * `@bot link ` / `pick-up` / `pickup` — open or join an existing T3 thread. + * Exact command form only (no extra prompt text). + */ +export function parseLinkThreadCommand(raw: string): LinkThreadCommand | null { + const trimmed = raw.trim().replace(/\s+/gu, " "); + const match = /^(?:link|pick-up|pickup)\s+(\S+)\s*$/iu.exec(trimmed); + if (match?.[1] === undefined) return null; + const t3ThreadId = extractT3ThreadId(match[1]); + if (t3ThreadId === null) return null; + return { kind: "link-thread", t3ThreadId }; +} diff --git a/apps/discord-bot/src/presentation/tasks.test.ts b/apps/discord-bot/src/presentation/tasks.test.ts new file mode 100644 index 000000000000..f9827cce155f --- /dev/null +++ b/apps/discord-bot/src/presentation/tasks.test.ts @@ -0,0 +1,73 @@ +import { TurnId, type OrchestrationThreadActivity } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { formatTasksForDiscord, presentTasks } from "./tasks.ts"; + +function plan( + id: string, + turnId: string | null, + createdAt: string, + steps: ReadonlyArray>, + explanation?: string, +): OrchestrationThreadActivity { + return { + id, + kind: "turn.plan.updated", + tone: "info", + summary: "Plan updated", + payload: { + plan: steps, + ...(explanation === undefined ? {} : { explanation }), + }, + turnId, + createdAt, + } as OrchestrationThreadActivity; +} + +describe("presentTasks", () => { + it("uses the active turn id as the task context key", () => { + expect( + presentTasks( + [ + plan("old", "turn-1", "2026-07-16T00:00:00.000Z", [{ step: "Old task" }]), + plan("current", "turn-2", "2026-07-16T00:00:01.000Z", [{ step: "Ship task" }]), + ], + TurnId.make("turn-2"), + ), + ).toMatchObject({ + contextKey: "turn-2", + tasks: [{ step: "Ship task", status: "pending" }], + }); + }); + + it("falls back to the activity id when the plan is not attached to a turn", () => { + expect( + presentTasks( + [plan("evt-plan", null, "2026-07-16T00:00:00.000Z", [{ step: "Detached task" }])], + null, + ), + ).toMatchObject({ + contextKey: "evt-plan", + tasks: [{ step: "Detached task", status: "pending" }], + }); + }); +}); + +describe("formatTasksForDiscord", () => { + it("renders a compact progress summary", () => { + const rendered = formatTasksForDiscord({ + contextKey: "turn-2", + createdAt: "2026-07-16T00:00:01.000Z", + explanation: "Keep one task message updated", + tasks: [ + { step: "Ship task", status: "inProgress" }, + { step: "Verify", status: "completed" }, + ], + }); + + expect(rendered).toContain("**Tasks 1/2**"); + expect(rendered).toContain("_Keep one task message updated_"); + expect(rendered).toContain("◐ Ship task"); + expect(rendered).toContain("✅ Verify"); + }); +}); diff --git a/apps/discord-bot/src/presentation/tasks.ts b/apps/discord-bot/src/presentation/tasks.ts new file mode 100644 index 000000000000..aee757f82cd9 --- /dev/null +++ b/apps/discord-bot/src/presentation/tasks.ts @@ -0,0 +1,70 @@ +import type { OrchestrationThreadActivity, TurnId } from "@t3tools/contracts"; + +export interface PresentedTask { + readonly step: string; + readonly status: "pending" | "inProgress" | "completed"; +} + +export interface PresentedTasks { + readonly contextKey: string; + readonly explanation: string | null; + readonly createdAt: string; + readonly tasks: ReadonlyArray; +} + +function planFromActivity(activity: OrchestrationThreadActivity): PresentedTasks | null { + if (activity.kind !== "turn.plan.updated") return null; + const payload = + typeof activity.payload === "object" && activity.payload !== null + ? (activity.payload as Record) + : null; + if (!Array.isArray(payload?.plan)) return null; + const tasks: PresentedTask[] = []; + for (const entry of payload.plan) { + if (typeof entry !== "object" || entry === null) continue; + const task = entry as Record; + if (typeof task.step !== "string" || task.step.trim() === "") continue; + tasks.push({ + step: task.step.trim(), + status: task.status === "completed" || task.status === "inProgress" ? task.status : "pending", + }); + } + if (tasks.length === 0) return null; + return { + contextKey: activity.turnId ?? activity.id, + explanation: typeof payload.explanation === "string" ? payload.explanation : null, + createdAt: activity.createdAt, + tasks, + }; +} + +export function presentTasks( + activities: ReadonlyArray, + latestTurnId: TurnId | null, +): PresentedTasks | null { + const plans = activities + .filter((activity) => activity.kind === "turn.plan.updated") + .toSorted( + (left, right) => + (left.sequence ?? 0) - (right.sequence ?? 0) || + left.createdAt.localeCompare(right.createdAt), + ); + const preferred = + (latestTurnId === null + ? undefined + : plans.findLast((activity) => activity.turnId === latestTurnId)) ?? plans.at(-1); + return preferred === undefined ? null : planFromActivity(preferred); +} + +export function formatTasksForDiscord(tasks: PresentedTasks): string { + const completed = tasks.tasks.filter((task) => task.status === "completed").length; + const lines = [ + `**Tasks ${completed}/${tasks.tasks.length}**`, + ...(tasks.explanation ? [`_${tasks.explanation}_`] : []), + ...tasks.tasks.map((task) => { + const icon = task.status === "completed" ? "✅" : task.status === "inProgress" ? "◐" : "○"; + return `${icon} ${task.step}`; + }), + ]; + return lines.join("\n"); +} diff --git a/apps/discord-bot/src/presentation/threadContext.test.ts b/apps/discord-bot/src/presentation/threadContext.test.ts new file mode 100644 index 000000000000..d3bd0feb5b21 --- /dev/null +++ b/apps/discord-bot/src/presentation/threadContext.test.ts @@ -0,0 +1,422 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; + +import { describe, expect, it } from "vite-plus/test"; + +import { + buildFirstTurnPrompt, + buildDiscordTurnPrompt, + buildSentryBootstrapPrompt, + compactDiscordJumpRef, + extractSentryHints, + formatDiscordMessage, + formatEmbed, + formatLinkedJiraWorkItemsBlock, + formatReferencedMessageBlock, + formatRequesterLine, + looksLikeSentryContext, + resolveAgentTurnRulesPath, +} from "./threadContext.ts"; + +describe("formatEmbed", () => { + it("formats Sentry-like embeds", () => { + const text = formatEmbed({ + title: "CarrierErrorWrapped", + description: "SchenkerUnexpectedError: Unerwarteter Schenker-Fehler bei der Buchung", + fields: [ + { name: "company", value: "mako" }, + { name: "environment", value: "prod" }, + { name: "os", value: "Alpine Linux 3.24.1" }, + ], + footer: { text: "EXAMPLE-PROJECT-API-JW via Scanner API • Today at 12:55 PM" }, + }); + expect(text).toContain("CarrierErrorWrapped"); + expect(text).toContain("company: mako"); + expect(text).toContain("EXAMPLE-PROJECT-API-JW"); + }); +}); + +describe("extractSentryHints", () => { + it("finds issue ids and sentry urls", () => { + const hints = extractSentryHints( + "Issue EXAMPLE-PROJECT-API-JW see https://example.sentry.io/issues/123/", + ); + expect(hints.issueIds).toContain("EXAMPLE-PROJECT-API-JW"); + expect(hints.sentryUrls[0]).toContain("sentry.io"); + }); +}); + +describe("compactDiscordJumpRef / formatRequesterLine", () => { + it("compresses channel jumps to g/c/m", () => { + expect( + compactDiscordJumpRef( + "https://discord.com/channels/1083767712431480922/1531376362399465595/1531376362399465595", + ), + ).toBe("1083767712431480922/1531376362399465595/1531376362399465595"); + expect(compactDiscordJumpRef("https://example.com/x")).toBeNull(); + }); + + it("formats compact requester lines", () => { + expect( + formatRequesterLine({ + id: "m", + author: { id: "1", username: "patroza", displayName: "Patrick Roza" }, + }), + ).toBe("1@patroza Patrick Roza"); + expect( + formatRequesterLine({ + id: "m", + author: { id: "1", username: "patroza", displayName: "patroza" }, + }), + ).toBe("1@patroza"); + }); +}); + +describe("looksLikeSentryContext / buildFirstTurnPrompt", () => { + it("uses full Sentry bootstrap only when Sentry is present", () => { + const sentryStarter = { + id: "1", + author: { username: "Sentry", bot: true }, + content: "", + embeds: [ + { + title: "CarrierErrorWrapped", + description: "SchenkerUnexpectedError", + url: "https://example.sentry.io/issues/7506163172/", + fields: [{ name: "environment", value: "prod" }], + footer: { text: "EXAMPLE-PROJECT-API-JW via Scanner API" }, + }, + ], + }; + + expect( + looksLikeSentryContext({ + starter: sentryStarter, + mentionPrompt: "whats going on?", + }), + ).toBe(true); + + const sentryPrompt = buildFirstTurnPrompt({ + projectShortName: "example-project", + workspaceRoot: "/home/tester/projects/example", + mentionPrompt: "whats going on?", + mentionMessage: { + id: "mention-1", + author: { id: "42", username: "tester", displayName: "Example User" }, + }, + honeycombTraceUrlTemplate: + "https://ui.honeycomb.io/example/environments/{environment}/trace?trace_id={traceId}", + starter: sentryStarter, + }); + expect(sentryPrompt).toContain("Discord investigation bootstrap"); + expect(sentryPrompt).toContain("hc_tpl:"); + expect(sentryPrompt).toContain("CarrierErrorWrapped"); + expect(sentryPrompt).toContain("## Discord conversation context"); + expect(sentryPrompt).toContain(`rules: ${resolveAgentTurnRulesPath()}`); + expect(sentryPrompt).toContain("reply: this Discord thread only"); + expect(sentryPrompt).toContain("req: 42@tester Example User"); + expect(sentryPrompt).not.toContain("Lead with the essential answer"); + expect(sentryPrompt).not.toContain("Always open a GitHub PR"); + expect(sentryPrompt).not.toContain("https://discord.com/users/"); + }); + + it("does not use Sentry bootstrap for ordinary thread starters", () => { + const starter = { + id: "2", + author: { username: "Example User", bot: false }, + content: "Can you check the open PR?", + }; + + expect( + looksLikeSentryContext({ + starter, + mentionPrompt: "please review", + }), + ).toBe(false); + + const prompt = buildFirstTurnPrompt({ + projectShortName: "example-project", + workspaceRoot: "/tmp/x", + mentionPrompt: "please review", + honeycombTraceUrlTemplate: undefined, + starter, + }); + expect(prompt).not.toContain("Discord investigation bootstrap"); + expect(prompt).not.toContain("hc_tpl:"); + expect(prompt).toContain(`rules: ${resolveAgentTurnRulesPath()}`); + expect(prompt).toContain("Can you check the open PR?"); + expect(prompt).toContain("please review"); + }); + + it("returns bare mention when there is no useful starter", () => { + const prompt = buildFirstTurnPrompt({ + projectShortName: "example-project", + workspaceRoot: "/tmp/x", + mentionPrompt: "hello", + honeycombTraceUrlTemplate: undefined, + starter: null, + }); + expect(prompt).toContain(`rules: ${resolveAgentTurnRulesPath()}`); + expect(prompt).toContain("## User request"); + expect(prompt).toContain("hello"); + expect(buildSentryBootstrapPrompt).toBeTypeOf("function"); + expect(formatDiscordMessage({ id: "x", content: "hi", author: { username: "a" } })).toContain( + "hi", + ); + }); +}); + +describe("resolveAgentTurnRulesPath", () => { + it("points at the package static policy document", () => { + const path = resolveAgentTurnRulesPath(); + expect(path.endsWith("docs/agent-turn-rules.md")).toBe(true); + expect(NodeFS.existsSync(path)).toBe(true); + const body = NodeFS.readFileSync(path, "utf8"); + expect(body).not.toContain("cab"); + expect(body).toContain("PR footer"); + expect(body).toContain("Style:"); + expect(body).toContain("client overlay"); + expect(body).toContain("**sentry:**"); + expect(body).toContain("Do not comment on Jira"); + expect(body).toContain("not a request to comment"); + }); +}); + +describe("buildDiscordTurnPrompt", () => { + it("adds unified agent rules + Discord context and requester", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "Can you check your last reply?", + requester: { + id: "message-7", + author: { + id: "user-1", + username: "example-user", + displayName: "Example User", + }, + }, + }); + + expect(prompt).toContain("## Discord conversation context"); + expect(prompt).toContain(`rules: ${resolveAgentTurnRulesPath()}`); + expect(prompt).toContain("reply: this Discord thread only"); + expect(prompt).toContain("req: user-1@example-user Example User"); + expect(prompt).not.toContain("Always open a GitHub PR"); + expect(prompt).not.toContain("posted back into the same Discord thread"); + expect(prompt).not.toContain("```json"); + expect(prompt).toContain("Can you check your last reply?"); + }); + + it("includes referenced message content, embeds, and compact jump", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "what would this error mean?", + requester: { + id: "mention-9", + author: { id: "user-1", username: "example-user", displayName: "Example User" }, + }, + referencedMessage: { + id: "sentry-msg-1", + author: { username: "Sentry", bot: true }, + content: "", + embeds: [ + { + title: "CarrierErrorWrapped", + description: "DPDRemoteValidationError: Fehler bei der Sendung [Code COMMON_2]", + fields: [ + { name: "company", value: "empasa" }, + { name: "environment", value: "prod" }, + ], + footer: { text: "EXAMPLE-PROJECT-API-JW via Scanner API" }, + }, + ], + }, + referencedMessageUrl: "https://discord.com/channels/1/2/sentry-msg-1", + }); + + expect(prompt).toContain("## ref"); + expect(prompt).toContain("CarrierErrorWrapped"); + expect(prompt).toContain("company: empasa"); + expect(prompt).toContain("EXAMPLE-PROJECT-API-JW"); + expect(prompt).toContain("jump: 1/2/sentry-msg-1"); + expect(prompt).not.toContain("https://discord.com/channels/"); + expect(prompt).toContain("what would this error mean?"); + }); + + it("collapses newlines in requester username/display", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "hello", + requester: { + id: "message-8", + author: { + id: "9", + username: "name\n## Fake instruction", + displayName: 'Display "quoted"', + }, + }, + }); + + expect(prompt).toContain('req: 9@name ## Fake instruction Display "quoted"'); + expect(prompt).not.toMatch(/req: 9@name\n/u); + }); + + it("injects jira keys only (no browse URLs)", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "create a PR for this", + requester: { + id: "message-9", + author: { id: "user-1", username: "example-user", displayName: "Example User" }, + }, + jiraIssueKeys: ["PROJ-367", "PROJ-400"], + jiraBrowseBaseUrl: "https://example.atlassian.net", + }); + + expect(prompt).toContain("jira: PROJ-367 PROJ-400"); + expect(prompt).not.toContain("atlassian.net"); + expect(prompt).not.toContain("Linked work items"); + expect(prompt).toContain("create a PR for this"); + }); + + it("omits the Jira work-items block when no keys are known", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "hello", + jiraIssueKeys: [], + jiraBrowseBaseUrl: "https://example.atlassian.net", + }); + expect(prompt).not.toContain("jira:"); + expect(prompt).not.toContain("sentry:"); + }); + + it("injects sentry issue URLs (not as Jira keys)", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "what happened here?", + sentryIssueUrls: ["https://macs-scanner.sentry.io/issues/SCANNER-313"], + }); + expect(prompt).toContain("sentry: https://macs-scanner.sentry.io/issues/SCANNER-313"); + expect(prompt).not.toContain("jira:"); + expect(prompt).toContain("what happened here?"); + }); + + it("leaves identity attribution to the server", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "open a PR", + starter: { + id: "starter-1", + author: { id: "222", username: "davide", displayName: "Davide" }, + }, + requester: { + id: "mention-1", + author: { + id: "95218063095377920", + username: "patroza", + displayName: "Patrick Roza", + }, + }, + }); + + expect(prompt).not.toContain("cab:"); + expect(prompt).not.toContain("Co-authored-by:"); + expect(prompt).not.toContain("who:"); + expect(prompt).not.toContain("do not invent emails"); + expect(prompt).not.toContain("Always open a PR"); + expect(prompt).not.toContain("jiraAccountId"); + }); + + it("injects compact pr fields (ids, not full URLs)", () => { + const prompt = buildDiscordTurnPrompt({ + mentionPrompt: "make a pr", + requester: { + id: "m1", + author: { id: "593167616273809448", username: "joshuadima", displayName: "joshuadima" }, + }, + starter: { + id: "1531376362399465595", + author: { id: "593167616273809448", username: "joshuadima", displayName: "joshuadima" }, + }, + guildId: "1083767712431480922", + discordThreadId: "1531376362399465595", + discordThreadTitle: "Open Random PR Test", + t3ThreadId: "t3-thread-1", + webUiBaseUrl: "https://t3vm.tail86038f.ts.net", + }); + expect(prompt).toContain("pr:"); + expect(prompt).toContain("uid=593167616273809448"); + expect(prompt).toContain("g=1083767712431480922"); + expect(prompt).toContain("c=1531376362399465595"); + expect(prompt).toContain("m=1531376362399465595"); + expect(prompt).toContain("title=Open Random PR Test"); + expect(prompt).not.toContain("https://discord.com/"); + expect(prompt).toContain( + "t3: full=https://t3vm.tail86038f.ts.net/?thread=t3-thread-1 short=https://t3vm/?thread=t3-thread-1", + ); + }); + + it("falls back to bare keys when browse base is unset", () => { + const block = formatLinkedJiraWorkItemsBlock({ + jiraIssueKeys: ["proj-367"], + jiraBrowseBaseUrl: undefined, + }); + expect(block).toBe("jira: PROJ-367"); + expect(block).not.toContain("atlassian.net"); + }); +}); + +describe("referenced message + Sentry bootstrap", () => { + it("treats a Sentry referenced message as investigation context even without starter", () => { + const referenced = { + id: "sentry-ref", + author: { username: "Sentry", bot: true }, + embeds: [ + { + title: "CarrierErrorWrapped", + description: "DPDRemoteValidationError", + url: "https://example.sentry.io/issues/7506163172/", + fields: [{ name: "environment", value: "prod" }], + footer: { text: "EXAMPLE-PROJECT-API-JW via Scanner API" }, + }, + ], + }; + + expect( + looksLikeSentryContext({ + starter: null, + mentionPrompt: "what would this error mean?", + referencedMessage: referenced, + }), + ).toBe(true); + + const prompt = buildFirstTurnPrompt({ + projectShortName: "example-project", + workspaceRoot: "/tmp/scanner", + mentionPrompt: "what would this error mean?", + mentionMessage: { + id: "mention-10", + author: { id: "42", username: "example-user", displayName: "Example User" }, + }, + referencedMessage: referenced, + referencedMessageUrl: "https://discord.com/channels/g/c/sentry-ref", + honeycombTraceUrlTemplate: + "https://ui.eu1.honeycomb.io/example-project/environments/{environment}/trace?trace_id={traceId}", + starter: null, + }); + + expect(prompt).toContain("Discord investigation bootstrap"); + expect(prompt).toContain("## ref"); + expect(prompt).toContain("CarrierErrorWrapped"); + expect(prompt).toContain("EXAMPLE-PROJECT-API-JW"); + expect(prompt).toContain("jump: g/c/sentry-ref"); + expect(prompt).not.toContain("https://discord.com/channels/"); + }); + + it("formatReferencedMessageBlock labels the reply target", () => { + const block = formatReferencedMessageBlock({ + message: { + id: "m1", + author: { username: "alice" }, + content: "please look at this", + }, + url: "https://discord.com/channels/1/2/m1", + }); + expect(block).toContain("## ref"); + expect(block).toContain("please look at this"); + expect(block).toContain("jump: 1/2/m1"); + }); +}); diff --git a/apps/discord-bot/src/presentation/threadContext.ts b/apps/discord-bot/src/presentation/threadContext.ts new file mode 100644 index 000000000000..33609176fca2 --- /dev/null +++ b/apps/discord-bot/src/presentation/threadContext.ts @@ -0,0 +1,507 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Build initial T3 prompts when the bot is first pulled into a Discord thread. + * Combines the thread starter (e.g. Sentry alert embed) with the user @mention. + * + * Global product rules are injected by the T3 server on session start (and again + * after compaction). This builder only emits **dynamic** Discord fields + a + * pointer to the Discord-only overlay (`docs/agent-turn-rules.md`). + */ + +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; + +import { + buildT3WebThreadUrl, + starterDisplayName, + starterUserId, + toT3PublicShortThreadUrl, +} from "./discordPrAttribution.ts"; +import { mergeJiraIssueKeys } from "./jiraLinks.ts"; +import { formatLinkedSentryWorkItemsBlock } from "./sentryLinks.ts"; + +function discordBotPackageRoot(): string { + // presentation/ → src/ → package root + return NodePath.resolve(NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)), "../.."); +} + +/** Absolute path to the Discord-only overlay policy document. */ +export function resolveAgentTurnRulesPath(): string { + return NodePath.resolve(discordBotPackageRoot(), "docs/agent-turn-rules.md"); +} + +export interface DiscordEmbedLike { + readonly title?: string | undefined; + readonly description?: string | undefined; + readonly url?: string | undefined; + readonly timestamp?: string | undefined; + readonly author?: { readonly name?: string | undefined } | undefined; + readonly footer?: { readonly text?: string | undefined } | undefined; + readonly fields?: + | ReadonlyArray<{ + readonly name: string; + readonly value: string; + }> + | undefined; +} + +export interface DiscordMessageLike { + readonly id: string; + readonly content?: string | null | undefined; + readonly author?: + | { + readonly id?: string | undefined; + readonly username?: string | undefined; + readonly displayName?: string | undefined; + readonly bot?: boolean | undefined; + } + | undefined; + readonly embeds?: ReadonlyArray | undefined; + readonly timestamp?: string | undefined; + /** Channel that holds the message (for jump links). */ + readonly channelId?: string | undefined; +} + +export interface ThreadBootstrapContext { + readonly starter: DiscordMessageLike | null; + readonly mentionMessage?: DiscordMessageLike | undefined; + /** + * Message the user replied to / referenced when addressing the bot. + * Prefer this over inventing context from screenshots or partial text. + */ + readonly referencedMessage?: DiscordMessageLike | null | undefined; + /** Jump link for the referenced message when known. */ + readonly referencedMessageUrl?: string | undefined; + readonly mentionPrompt: string; + readonly projectShortName: string; + readonly workspaceRoot: string; + /** Optional template: use {traceId}, {environment}, {dataset} */ + readonly honeycombTraceUrlTemplate: string | undefined; + /** + * Durable Jira issue keys for this Discord thread (first-seen order). + * Re-injected every turn so later PR/work turns still see earlier ticket links. + */ + readonly jiraIssueKeys?: ReadonlyArray | undefined; + /** + * Durable Sentry issue URLs for this Discord thread (first-seen order). + * Re-injected every turn so later investigation turns still see them as Sentry, + * not Jira. + */ + readonly sentryIssueUrls?: ReadonlyArray | undefined; + /** Browse base for turning keys into links (e.g. https://org.atlassian.net). */ + readonly jiraBrowseBaseUrl?: string | undefined; + /** Guild snowflake — required to build a real Discord thread jump URL for PR footers. */ + readonly guildId?: string | null | undefined; + /** Discord thread (or channel) snowflake for the PR footer jump link. */ + readonly discordThreadId?: string | null | undefined; + /** Discord thread title (channel name) for the PR footer label. */ + readonly discordThreadTitle?: string | null | undefined; + /** T3 Code thread id for PR footer T3 link (when known). */ + readonly t3ThreadId?: string | null | undefined; + /** T3 web UI base (e.g. https://t3vm.tail….ts.net) for full private PR links. */ + readonly webUiBaseUrl?: string | null | undefined; +} + +/** Collapse whitespace so one-line turn fields cannot inject extra markdown headers. */ +function oneLine(value: string): string { + return value + .replace(/[\r\n\t]+/gu, " ") + .replace(/ {2,}/gu, " ") + .trim(); +} + +/** Compact requester line: `id@user name` (name omitted when same as user). */ +export function formatRequesterLine(message: DiscordMessageLike | undefined): string { + const id = oneLine(message?.author?.id?.trim() || "?") || "?"; + const user = oneLine(message?.author?.username?.trim() || "?") || "?"; + const name = oneLine((message?.author?.displayName ?? message?.author?.username ?? "").trim()); + if (name.length > 0 && name !== user) return `${id}@${user} ${name}`; + return `${id}@${user}`; +} + +/** + * Compress a discord.com/channels/... jump to `g/c` or `g/c/m` (no scheme/host). + * Returns null when the URL is missing or not a channel jump. + */ +export function compactDiscordJumpRef(url: string | undefined): string | null { + if (url === undefined) return null; + const trimmed = url.trim(); + if (trimmed.length === 0) return null; + const match = trimmed.match( + /^https:\/\/(?:ptb\.|canary\.)?discord(?:app)?\.com\/channels\/([^/\s]+)\/([^/\s]+)(?:\/([^/\s]+))?$/u, + ); + if (match === null) return null; + const guild = match[1]!; + const channel = match[2]!; + const message = match[3]; + return message !== undefined && message.length > 0 + ? `${guild}/${channel}/${message}` + : `${guild}/${channel}`; +} + +/** + * Format a referenced (reply-to) Discord message for agent context. + * Jump is `g/c/m` ids only (expand with rules doc URL forms when needed). + */ +export function formatReferencedMessageBlock(input: { + readonly message: DiscordMessageLike; + readonly url?: string | undefined; +}): string { + const parts = ["## ref", formatDiscordMessage(input.message)]; + const jump = compactDiscordJumpRef(input.url); + if (jump !== null) parts.push(`jump: ${jump}`); + return parts.join("\n"); +} + +/** + * Durable per-thread Jira keys for agent turns (keys only — no browse URLs). + * Omitted when no keys are known so ordinary prompts stay compact. + */ +export function formatLinkedJiraWorkItemsBlock(input: { + readonly jiraIssueKeys?: ReadonlyArray | undefined; + /** @deprecated Ignored; keys only in prompts (browse base unused). */ + readonly jiraBrowseBaseUrl?: string | undefined; +}): string | null { + const ordered = mergeJiraIssueKeys([], input.jiraIssueKeys); + if (ordered.length === 0) return null; + return `jira: ${ordered.join(" ")}`; +} + +/** + * Compact PR footer fields for agents (ids only — expand via rules doc). + * Returns null when starter user id is missing. + */ +export function formatDiscordPrFooterPromptBlock(input: { + readonly starter?: DiscordMessageLike | null | undefined; + readonly requester?: DiscordMessageLike | undefined; + readonly guildId?: string | null | undefined; + readonly discordThreadId?: string | null | undefined; + readonly discordThreadTitle?: string | null | undefined; +}): string | null { + const attributionPerson = input.starter ?? input.requester; + const userId = starterUserId(attributionPerson ?? null); + if (userId === null) return null; + + const name = starterDisplayName(attributionPerson ?? null); + const guildId = input.guildId?.trim() ?? ""; + const threadId = input.discordThreadId?.trim() ?? ""; + const messageId = + attributionPerson?.id?.trim() || + input.requester?.id?.trim() || + (threadId.length > 0 ? threadId : ""); + const title = input.discordThreadTitle?.trim() || "Discord"; + + const parts = [`name=${name}`, `uid=${userId}`]; + if (guildId.length > 0) parts.push(`g=${guildId}`); + if (threadId.length > 0) parts.push(`c=${threadId}`); + if (messageId.length > 0) parts.push(`m=${messageId}`); + parts.push(`title=${title}`); + return `pr: ${parts.join(" ")}`; +} + +/** + * Compact T3 thread link fields for PR footers. + * Agents pick full (private GH repo) vs short host `t3vm` (public). + */ +export function formatT3PrLinkPromptBlock(input: { + readonly t3ThreadId?: string | null | undefined; + readonly webUiBaseUrl?: string | null | undefined; +}): string | null { + const id = input.t3ThreadId?.trim(); + if (id === undefined || id.length === 0) return null; + + const full = buildT3WebThreadUrl(input.webUiBaseUrl, id); + const short = full !== null ? toT3PublicShortThreadUrl(full) : `https://t3vm/?thread=${id}`; + + if (full !== null) return `t3: full=${full} short=${short}`; + return `t3: short=${short}`; +} + +export function buildDiscordTurnPrompt(input: { + readonly mentionPrompt: string; + readonly requester?: DiscordMessageLike | undefined; + readonly starter?: DiscordMessageLike | null | undefined; + readonly referencedMessage?: DiscordMessageLike | null | undefined; + readonly referencedMessageUrl?: string | undefined; + readonly jiraIssueKeys?: ReadonlyArray | undefined; + readonly sentryIssueUrls?: ReadonlyArray | undefined; + readonly jiraBrowseBaseUrl?: string | undefined; + readonly guildId?: string | null | undefined; + readonly discordThreadId?: string | null | undefined; + readonly discordThreadTitle?: string | null | undefined; + readonly t3ThreadId?: string | null | undefined; + readonly webUiBaseUrl?: string | null | undefined; + /** Override Discord overlay rules path (tests). Defaults to package docs path. */ + readonly agentTurnRulesPath?: string | undefined; +}): string { + const overlayRulesPath = input.agentTurnRulesPath ?? resolveAgentTurnRulesPath(); + + const referencedBlock = + input.referencedMessage !== null && input.referencedMessage !== undefined + ? `\n\n${formatReferencedMessageBlock({ + message: input.referencedMessage, + url: input.referencedMessageUrl, + })}` + : ""; + + const sentryBlock = formatLinkedSentryWorkItemsBlock(input.sentryIssueUrls); + const sentrySection = sentryBlock !== null ? `\n${sentryBlock}` : ""; + + const jiraBlock = formatLinkedJiraWorkItemsBlock({ + jiraIssueKeys: input.jiraIssueKeys, + jiraBrowseBaseUrl: input.jiraBrowseBaseUrl, + }); + const jiraSection = jiraBlock !== null ? `\n${jiraBlock}` : ""; + + const prFooterBlock = formatDiscordPrFooterPromptBlock({ + starter: input.starter, + requester: input.requester, + guildId: input.guildId, + discordThreadId: input.discordThreadId, + discordThreadTitle: input.discordThreadTitle, + }); + const prFooterSection = prFooterBlock !== null ? `\n${prFooterBlock}` : ""; + + const t3Block = formatT3PrLinkPromptBlock({ + t3ThreadId: input.t3ThreadId, + webUiBaseUrl: input.webUiBaseUrl, + }); + const t3Section = t3Block !== null ? `\n${t3Block}` : ""; + + // Header kept for ResponseBridge echo-suppression (isDiscordOriginatedUserPrompt). + // Global product rules: server session inject + post-compaction re-inject. + // Discord overlay path is surface-specific static policy for this turn. + return `## Discord conversation context +rules: ${overlayRulesPath} +reply: this Discord thread only +req: ${formatRequesterLine(input.requester)}${sentrySection}${jiraSection}${prFooterSection}${t3Section} + +## User request +${input.mentionPrompt.trim()}${referencedBlock}`; +} + +const SENTRY_ISSUE_ID = /\b([A-Z][A-Z0-9]+(?:-[A-Z0-9]+)+)\b/g; +const SENTRY_URL = /https?:\/\/[^\s)]*sentry\.io\/[^\s)]+/gi; +const TRACE_ID = /\b(?:trace[_-]?id|trace)\s*[:=]\s*([a-f0-9]{16,32})\b/i; +const HEX_TRACE = /\b([a-f0-9]{32})\b/i; + +export function formatEmbed(embed: DiscordEmbedLike): string { + const lines: string[] = []; + if (embed.author?.name) lines.push(`Author: ${embed.author.name}`); + if (embed.title) lines.push(`Title: ${embed.title}`); + if (embed.description) lines.push(embed.description.trim()); + if (embed.url) lines.push(`URL: ${embed.url}`); + if (embed.fields) { + for (const field of embed.fields) { + lines.push(`${field.name}: ${field.value}`); + } + } + if (embed.footer?.text) lines.push(`Footer: ${embed.footer.text}`); + if (embed.timestamp) lines.push(`Timestamp: ${embed.timestamp}`); + return lines.join("\n"); +} + +export function formatDiscordMessage(message: DiscordMessageLike): string { + const who = + message.author?.username !== undefined + ? `${message.author.username}${message.author.bot === true ? " [bot]" : ""}` + : "?"; + const parts = [`from=${who} id=${message.id}`]; + const content = (message.content ?? "").trim(); + if (content.length > 0) parts.push(content); + if (message.embeds && message.embeds.length > 0) { + message.embeds.forEach((embed, index) => { + parts.push(`embed${index + 1}:`, formatEmbed(embed)); + }); + } + return parts.join("\n"); +} + +export function extractSentryHints(text: string): { + readonly issueIds: ReadonlyArray; + readonly sentryUrls: ReadonlyArray; + readonly possibleTraceIds: ReadonlyArray; +} { + const issueIds = new Set(); + for (const match of text.matchAll(SENTRY_ISSUE_ID)) { + const id = match[1]; + if (id === undefined || !id.includes("-") || id.length < 8) continue; + // Sentry short ids are typically PROJECT-CODE (letters + hyphens, sometimes digits). + // Skip pure hex-ish tokens (trace/event ids). + if (/^[a-f0-9-]+$/i.test(id) && !/[g-zG-Z]/.test(id)) continue; + if (!/[A-Z]/.test(id)) continue; + issueIds.add(id); + } + const sentryUrls = [...text.matchAll(SENTRY_URL)].map((m) => m[0]!); + const possibleTraceIds: string[] = []; + const labeled = TRACE_ID.exec(text); + if (labeled?.[1]) possibleTraceIds.push(labeled[1]); + const hex = HEX_TRACE.exec(text); + if (hex?.[1] && !possibleTraceIds.includes(hex[1])) possibleTraceIds.push(hex[1]); + return { + issueIds: [...issueIds], + sentryUrls: [...new Set(sentryUrls)], + possibleTraceIds, + }; +} + +function collectMessageText(message: DiscordMessageLike | null | undefined): string { + if (message === null || message === undefined) return ""; + const parts: string[] = [message.content ?? "", message.author?.username ?? ""]; + for (const embed of message.embeds ?? []) { + parts.push(formatEmbed(embed)); + if (embed.url) parts.push(embed.url); + } + return parts.join("\n"); +} + +/** True when starter/mention/referenced message clearly references Sentry (avoid burning tokens otherwise). */ +export function looksLikeSentryContext(input: { + readonly starter: DiscordMessageLike | null; + readonly mentionPrompt: string; + readonly referencedMessage?: DiscordMessageLike | null | undefined; +}): boolean { + const parts: string[] = [ + input.mentionPrompt, + collectMessageText(input.starter), + collectMessageText(input.referencedMessage), + ]; + const text = parts.join("\n"); + if (/sentry/i.test(text)) return true; + if (/sentry\.io/i.test(text)) return true; + const hints = extractSentryHints(text); + return hints.sentryUrls.length > 0; +} + +/** + * Choose first-turn prompt: + * - Sentry-like context → full investigation bootstrap (Sentry + Honeycomb instructions) + * - Non-Sentry with a distinct starter and/or referenced message → short context + user request + * - Otherwise → user request only (still includes referenced message when present) + */ +export function buildFirstTurnPrompt(input: ThreadBootstrapContext): string { + if (looksLikeSentryContext(input)) { + return buildSentryBootstrapPrompt(input); + } + + const turnPrompt = buildDiscordTurnPrompt({ + mentionPrompt: input.mentionPrompt, + requester: input.mentionMessage, + starter: input.starter, + referencedMessage: input.referencedMessage, + referencedMessageUrl: input.referencedMessageUrl, + jiraIssueKeys: input.jiraIssueKeys, + sentryIssueUrls: input.sentryIssueUrls, + jiraBrowseBaseUrl: input.jiraBrowseBaseUrl, + guildId: input.guildId, + discordThreadId: input.discordThreadId, + discordThreadTitle: input.discordThreadTitle, + t3ThreadId: input.t3ThreadId, + webUiBaseUrl: input.webUiBaseUrl, + }); + + if (input.starter !== null) { + const starterText = formatDiscordMessage(input.starter).trim(); + const mention = input.mentionPrompt.trim(); + // Avoid doubling the same text when the mention is the starter. + if (starterText.length > 0 && !starterText.includes(mention)) { + // Skip starter block when it is the same message the user referenced. + const starterIsReferenced = + input.referencedMessage !== null && + input.referencedMessage !== undefined && + input.referencedMessage.id === input.starter.id; + if (!starterIsReferenced) { + return `${turnPrompt} + +## Discord thread starter +${starterText} +`; + } + } + } + + return turnPrompt; +} + +export function buildSentryBootstrapPrompt(input: ThreadBootstrapContext): string { + const starterText = + input.starter === null ? "(no starter message available)" : formatDiscordMessage(input.starter); + const referencedText = + input.referencedMessage === null || input.referencedMessage === undefined + ? null + : formatDiscordMessage(input.referencedMessage); + const referencedIsDistinctStarter = + referencedText !== null && + input.referencedMessage !== null && + input.referencedMessage !== undefined && + (input.starter === null || input.referencedMessage.id !== input.starter.id); + + const combinedForHints = [ + starterText, + referencedText ?? "", + input.mentionPrompt, + input.starter?.embeds?.map(formatEmbed).join("\n") ?? "", + input.referencedMessage?.embeds?.map(formatEmbed).join("\n") ?? "", + ].join("\n"); + const hints = extractSentryHints(combinedForHints); + + const honeycombTpl = + input.honeycombTraceUrlTemplate !== undefined && input.honeycombTraceUrlTemplate.trim() !== "" + ? input.honeycombTraceUrlTemplate.trim() + : null; + + const hintBits: string[] = []; + if (hints.issueIds.length > 0) hintBits.push(`issues=${hints.issueIds.join(",")}`); + if (hints.sentryUrls.length > 0) { + // Prefer issue path/id over full URL when possible. + const compact = hints.sentryUrls.map((u) => { + const m = u.match(/sentry\.io(\/issues\/\d+)/iu); + return m?.[1] ?? u; + }); + hintBits.push(`sentry=${compact.join(",")}`); + } + if (hints.possibleTraceIds.length > 0) { + hintBits.push(`traces=${hints.possibleTraceIds.join(",")}`); + } + + const primary = referencedIsDistinctStarter ? "primary=ref" : "primary=starter"; + + const jump = compactDiscordJumpRef(input.referencedMessageUrl); + const referencedSection = + referencedIsDistinctStarter && referencedText !== null + ? ` +## ref +${referencedText}${jump !== null ? `\njump: ${jump}` : ""} +` + : ""; + + return `## Discord investigation bootstrap + +${buildDiscordTurnPrompt({ + mentionPrompt: input.mentionPrompt, + requester: input.mentionMessage, + starter: input.starter, + // Referenced / starter bodies are rendered in dedicated bootstrap sections below. + jiraIssueKeys: input.jiraIssueKeys, + sentryIssueUrls: input.sentryIssueUrls, + jiraBrowseBaseUrl: input.jiraBrowseBaseUrl, + guildId: input.guildId, + discordThreadId: input.discordThreadId, + discordThreadTitle: input.discordThreadTitle, + t3ThreadId: input.t3ThreadId, + webUiBaseUrl: input.webUiBaseUrl, +})} + +project: ${input.projectShortName} root: ${input.workspaceRoot} +${primary} +${referencedSection} +## starter +${starterText} + +hints: ${hintBits.length > 0 ? hintBits.join(" ") : "none"} +hc_tpl: ${honeycombTpl ?? "(none — use team UI)"} +`; +} + +/** @deprecated Use buildFirstTurnPrompt / buildSentryBootstrapPrompt */ +export const buildThreadBootstrapPrompt = buildSentryBootstrapPrompt; diff --git a/apps/discord-bot/src/presentation/threadInfoPin.test.ts b/apps/discord-bot/src/presentation/threadInfoPin.test.ts new file mode 100644 index 000000000000..b7cd69108fef --- /dev/null +++ b/apps/discord-bot/src/presentation/threadInfoPin.test.ts @@ -0,0 +1,134 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + applyModelHistoryUpdate, + formatModelSinceLabel, + formatThreadInfoModelLine, + isThreadInfoPinContent, + renderThreadInfoPin, + THREAD_INFO_PIN_MARKER, +} from "./threadInfoPin.ts"; + +describe("renderThreadInfoPin", () => { + it("renders model, worktree, open link, ordered jira keys, and PR links", () => { + const rendered = renderThreadInfoPin({ + modelLine: "grok/grok-4.5", + worktreeLine: "Worktree off `main`", + webLink: "http://198.18.83.2:3773/?thread=abc", + sentryIssueUrls: ["https://macs-scanner.sentry.io/issues/SCANNER-313"], + jiraIssueKeys: ["PROJ-367", "PROJ-400"], + jiraBrowseBaseUrl: "https://example.atlassian.net", + channelGithubRepoSlug: "example-org/scanner", + prUrls: [ + "https://github.com/example-org/scanner/pull/1950", + "https://github.com/example-org/configurator/pull/123", + ], + }); + + expect(rendered).toContain(`**${THREAD_INFO_PIN_MARKER}**`); + expect(rendered).toContain("Model: `grok/grok-4.5`"); + expect(rendered).toContain("Worktree off `main`"); + expect(rendered).toContain("Open in Omegent: http://198.18.83.2:3773/?thread=abc"); + expect(rendered).toContain("**Sentry**"); + expect(rendered).toContain("[SCANNER-313](https://macs-scanner.sentry.io/issues/SCANNER-313)"); + expect(rendered).toContain("**Jira**"); + expect(rendered).toContain("[PROJ-367](https://example.atlassian.net/browse/PROJ-367)"); + expect(rendered).toContain("[PROJ-400](https://example.atlassian.net/browse/PROJ-400)"); + expect(rendered.indexOf("PROJ-367")).toBeLessThan(rendered.indexOf("PROJ-400")); + expect(rendered).toContain("**PRs**"); + expect(rendered).toContain("[PR #1950](https://github.com/example-org/scanner/pull/1950)"); + expect(rendered).toContain( + "[example-org/configurator PR #123](https://github.com/example-org/configurator/pull/123)", + ); + expect(rendered.indexOf("**Sentry**")).toBeLessThan(rendered.indexOf("**Jira**")); + expect(rendered.indexOf("**Jira**")).toBeLessThan(rendered.indexOf("**PRs**")); + }); + + it("omits jira and PR sections when empty", () => { + const rendered = renderThreadInfoPin({ + modelLine: "codex/gpt-5.4", + worktreeLine: "Mode: local (no worktree)", + webLink: null, + jiraIssueKeys: [], + prUrls: [], + }); + expect(rendered).not.toContain("**Sentry**"); + expect(rendered).not.toContain("**Jira**"); + expect(rendered).not.toContain("**PRs**"); + expect(rendered).toContain("Mode: local (no worktree)"); + }); + + it("renders model change note when provided as a full Model: line", () => { + const rendered = renderThreadInfoPin({ + modelLine: "Model: `grok/grok-4.5` (since 2026-07-20 at 10:05, started with `codex/gpt-5.4`)", + worktreeLine: "Worktree off `main`", + webLink: null, + }); + expect(rendered).toContain("started with `codex/gpt-5.4`"); + }); +}); + +describe("model history", () => { + it("records initial model without a since stamp", () => { + const history = applyModelHistoryUpdate(null, "codex/gpt-5.4", "2026-07-20T08:00:00.000Z"); + expect(history).toEqual({ + initialModelLine: "codex/gpt-5.4", + currentModelLine: "codex/gpt-5.4", + modelSinceAt: null, + }); + expect(formatThreadInfoModelLine(history)).toBe("Model: `codex/gpt-5.4`"); + }); + + it("stamps since when the model changes and keeps the original", () => { + const initial = applyModelHistoryUpdate(null, "codex/gpt-5.4", "2026-07-20T08:00:00.000Z"); + const changed = applyModelHistoryUpdate(initial, "grok/grok-4.5", "2026-07-20T08:05:00.000Z"); + expect(changed).toEqual({ + initialModelLine: "codex/gpt-5.4", + currentModelLine: "grok/grok-4.5", + modelSinceAt: "2026-07-20T08:05:00.000Z", + }); + // 08:05 UTC → 10:05 Europe/Berlin (CEST in July) + expect(formatThreadInfoModelLine(changed)).toBe( + "Model: `grok/grok-4.5` (since 2026-07-20 at 10:05, started with `codex/gpt-5.4`)", + ); + }); + + it("does not re-stamp when the same model is observed again", () => { + const changed = applyModelHistoryUpdate( + { + initialModelLine: "codex/gpt-5.4", + currentModelLine: "grok/grok-4.5", + modelSinceAt: "2026-07-20T08:05:00.000Z", + }, + "grok/grok-4.5", + "2026-07-20T09:00:00.000Z", + ); + expect(changed.modelSinceAt).toBe("2026-07-20T08:05:00.000Z"); + }); + + it("formats Germany local since labels without a timezone suffix", () => { + // Summer (CEST, UTC+2) + expect(formatModelSinceLabel("2026-07-20T08:05:30.000Z")).toBe("2026-07-20 at 10:05"); + // Winter (CET, UTC+1) + expect(formatModelSinceLabel("2026-01-15T08:05:30.000Z")).toBe("2026-01-15 at 09:05"); + }); +}); + +describe("isThreadInfoPinContent", () => { + it("detects marked and legacy bot messages", () => { + expect(isThreadInfoPinContent(`**${THREAD_INFO_PIN_MARKER}**\nModel: \`x\``)).toBe(true); + // Legacy pre-rebrand marker is still recognized so old pins are upgraded in place. + expect(isThreadInfoPinContent("**T3 Thread Info**\nModel: `x`")).toBe(true); + // Legacy pre-marker message (no marker line, "Open in T3:" label). + expect( + isThreadInfoPinContent("Model: `grok/grok-4.5`\nWorktree off `main`\nOpen in T3: http://x"), + ).toBe(true); + // New pre-marker-equivalent (no marker line, "Open in Omegent:" label). + expect( + isThreadInfoPinContent( + "Model: `grok/grok-4.5`\nWorktree off `main`\nOpen in Omegent: http://x", + ), + ).toBe(true); + expect(isThreadInfoPinContent("hello world")).toBe(false); + }); +}); diff --git a/apps/discord-bot/src/presentation/threadInfoPin.ts b/apps/discord-bot/src/presentation/threadInfoPin.ts new file mode 100644 index 000000000000..8e033ed545fc --- /dev/null +++ b/apps/discord-bot/src/presentation/threadInfoPin.ts @@ -0,0 +1,203 @@ +// @effect-diagnostics globalDate:off +import { formatJiraLinksForDiscord } from "./jiraLinks.ts"; +import { formatPullRequestLinksForDiscord } from "./prLinks.ts"; +import { formatSentryLinksForDiscord } from "./sentryLinks.ts"; + +/** Stable marker so we can find/update the pinned thread-info message after restarts. */ +export const THREAD_INFO_PIN_MARKER = "Omegent Info"; + +/** + * Markers the bot used before the Omegent rebrand. Detection matches these too so an + * existing pre-rebrand pin is found and rewritten in place instead of orphaned. + */ +export const LEGACY_THREAD_INFO_PIN_MARKERS = ["T3 Thread Info"] as const; + +export type ThreadInfoPinRenderInput = { + readonly modelLine: string | null; + readonly worktreeLine: string | null; + readonly webLink: string | null; + readonly extraLines?: ReadonlyArray; + readonly sentryIssueUrls?: ReadonlyArray; + readonly jiraIssueKeys?: ReadonlyArray; + readonly jiraBrowseBaseUrl?: string | undefined; + readonly prUrls?: ReadonlyArray; + /** Channel / project GitHub repo (`owner/repo`) for PR label disambiguation. */ + readonly channelGithubRepoSlug?: string | null | undefined; +}; + +/** Durable model history for the pinned thread-info message. */ +export type ThreadModelHistory = { + readonly initialModelLine: string | null; + readonly currentModelLine: string | null; + /** ISO timestamp when `currentModelLine` became active (if different from initial). */ + readonly modelSinceAt: string | null; +}; + +export function formatModelSelectionLine(input: { + readonly instanceId: string; + readonly model: string; +}): string { + return `${input.instanceId}/${input.model}`; +} + +/** Germany local time for pin text: `2026-07-20 at 10:05` (no timezone label). */ +const GERMANY_TIME_ZONE = "Europe/Berlin"; + +export function formatModelSinceLabel(iso: string): string { + const date = new Date(iso); + if (Number.isNaN(date.getTime())) return iso; + + const parts = new Intl.DateTimeFormat("en-GB", { + timeZone: GERMANY_TIME_ZONE, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit", + hourCycle: "h23", + }).formatToParts(date); + + const get = (type: Intl.DateTimeFormatPartTypes): string => + parts.find((part) => part.type === type)?.value ?? ""; + + const yyyy = get("year"); + const mm = get("month"); + const dd = get("day"); + const hh = get("hour"); + const min = get("minute"); + return `${yyyy}-${mm}-${dd} at ${hh}:${min}`; +} + +/** + * Merge an observed model into durable history. + * - First observation sets initial + current. + * - Later changes update current and stamp modelSinceAt. + */ +export function applyModelHistoryUpdate( + existing: ThreadModelHistory | null | undefined, + nextModelLine: string | null | undefined, + nowIso: string = new Date().toISOString(), +): ThreadModelHistory { + const next = + nextModelLine === null || nextModelLine === undefined || nextModelLine.trim() === "" + ? null + : nextModelLine.trim(); + + if (next === null) { + return { + initialModelLine: existing?.initialModelLine ?? null, + currentModelLine: existing?.currentModelLine ?? null, + modelSinceAt: existing?.modelSinceAt ?? null, + }; + } + + const initial = existing?.initialModelLine ?? next; + const previousCurrent = existing?.currentModelLine ?? null; + + if (previousCurrent === null) { + return { + initialModelLine: initial, + currentModelLine: next, + modelSinceAt: next === initial ? null : (existing?.modelSinceAt ?? nowIso), + }; + } + + if (previousCurrent === next) { + return { + initialModelLine: initial, + currentModelLine: next, + modelSinceAt: next === initial ? null : (existing?.modelSinceAt ?? null), + }; + } + + // Model changed relative to last known current. + return { + initialModelLine: initial, + currentModelLine: next, + modelSinceAt: next === initial ? null : nowIso, + }; +} + +/** + * `Model: \`current\`` or + * `Model: \`current\` (since YYYY-MM-DD at HH:MM, started with \`initial\`)` + * when the current model differs from the original (time is Europe/Berlin, no zone label). + */ +export function formatThreadInfoModelLine(history: ThreadModelHistory): string | null { + const current = history.currentModelLine?.trim() || null; + if (current === null) return null; + + const initial = history.initialModelLine?.trim() || null; + if ( + initial === null || + initial === current || + history.modelSinceAt === null || + history.modelSinceAt === undefined + ) { + return `Model: \`${current}\``; + } + + return `Model: \`${current}\` (since ${formatModelSinceLabel(history.modelSinceAt)}, started with \`${initial}\`)`; +} + +/** + * Render the per-thread status message (Model / worktree / Open in Omegent / Jira / PRs). + * Always includes the marker as the first line for pin discovery. + */ +export function renderThreadInfoPin(input: ThreadInfoPinRenderInput): string { + const lines: string[] = [`**${THREAD_INFO_PIN_MARKER}**`]; + + if (input.modelLine !== null && input.modelLine.trim() !== "") { + lines.push( + input.modelLine.startsWith("Model:") ? input.modelLine : `Model: \`${input.modelLine}\``, + ); + } + + for (const extra of input.extraLines ?? []) { + if (extra !== null && extra !== undefined && extra.trim() !== "") { + lines.push(extra); + } + } + + if (input.worktreeLine !== null && input.worktreeLine.trim() !== "") { + lines.push(input.worktreeLine); + } + + if (input.webLink !== null && input.webLink.trim() !== "") { + // Accept either prefix (callers pass the pre-labelled form; legacy used "Open in T3:") + // so re-rendering an old value never double-prefixes; emit the Omegent label otherwise. + const alreadyLabelled = + input.webLink.startsWith("Open in Omegent:") || input.webLink.startsWith("Open in T3:"); + lines.push(alreadyLabelled ? input.webLink : `Open in Omegent: ${input.webLink}`); + } + + const sentrySection = formatSentryLinksForDiscord(input.sentryIssueUrls ?? []); + if (sentrySection !== null) { + lines.push(""); + lines.push(sentrySection); + } + + const jiraSection = formatJiraLinksForDiscord(input.jiraIssueKeys ?? [], input.jiraBrowseBaseUrl); + if (jiraSection !== null) { + lines.push(""); + lines.push(jiraSection); + } + + const prSection = formatPullRequestLinksForDiscord(input.prUrls ?? [], { + channelRepoSlug: input.channelGithubRepoSlug ?? null, + }); + if (prSection !== null) { + lines.push(""); + lines.push(prSection); + } + + return lines.join("\n"); +} + +export function isThreadInfoPinContent(content: string | null | undefined): boolean { + if (content === null || content === undefined || content.length === 0) return false; + if (content.includes(THREAD_INFO_PIN_MARKER)) return true; + if (LEGACY_THREAD_INFO_PIN_MARKERS.some((marker) => content.includes(marker))) return true; + // Legacy pre-marker messages from the bot (Model: `…` first line + Open-in link). + return /^Model:\s*`[^`]+`/mu.test(content.trim()) && /Open in (?:T3|Omegent):/u.test(content); +} diff --git a/apps/discord-bot/src/presentation/todayRecap.test.ts b/apps/discord-bot/src/presentation/todayRecap.test.ts new file mode 100644 index 000000000000..ffb4d33b3c9e --- /dev/null +++ b/apps/discord-bot/src/presentation/todayRecap.test.ts @@ -0,0 +1,92 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + buildTodayRecapPrompt, + chunkTodayRecapContent, + extractLatestAssistantText, + formatTodayRecapThreadTitle, + formatTodayRecapWorking, + TODAY_RECAP_SUBCOMMAND, + utcDateStamp, +} from "./todayRecap.ts"; + +describe("today recap helpers", () => { + it("keeps the slash subcommand name Discord-safe", () => { + expect(TODAY_RECAP_SUBCOMMAND).toBe("today-recap"); + expect(TODAY_RECAP_SUBCOMMAND.length).toBeLessThanOrEqual(32); + }); + + it("stamps UTC dates from ISO timestamps", () => { + expect(utcDateStamp("2026-08-18T14:21:46.000Z")).toBe("2026-08-18"); + expect(utcDateStamp("2026-08-18")).toBe("2026-08-18"); + }); + + it("names the recap thread after the channel's project", () => { + expect(formatTodayRecapThreadTitle({ shortName: "scanner", date: "2026-08-18" })).toBe( + "today recap scanner 2026-08-18", + ); + }); + + it("replaces Discord's deferred thinking spinner with a working status", () => { + expect(formatTodayRecapWorking({ shortName: "scanner", date: "2026-08-26" })).toBe( + "Writing today's recap of `scanner` (2026-08-26 UTC)…", + ); + }); + + it("scopes the prompt to the calling channel's repo and the recap format", () => { + const prompt = buildTodayRecapPrompt({ + shortName: "scanner", + date: "2026-08-18", + parentChannelId: "1176897071815610458", + }); + + expect(prompt).toContain("`scanner`"); + expect(prompt).toContain("<#1176897071815610458>"); + expect(prompt).toContain("2026-08-18"); + expect(prompt).toContain("GitHub's UTC calendar day 2026-08-18"); + expect(prompt).toContain("Read-only"); + expect(prompt).toContain("do not open a PR"); + expect(prompt).toContain("opened that day and still open"); + expect(prompt).toContain("not the rest of the open backlog"); + expect(prompt).toContain("no change"); + expect(prompt).toContain("[PR #N](github-url) (fix)"); + expect(prompt).toContain("(feat)"); + expect(prompt).toContain("## 🟢 MERGED"); + expect(prompt).toContain("## 🔴 CLOSED"); + expect(prompt).toContain("## 🟠 OPEN"); + expect(prompt).toContain("Related PRs"); + expect(prompt).toContain("heading PR's description"); + expect(prompt).toContain('Do not write "landed today"'); + expect(prompt).toContain("closed PR with no connection"); + expect(prompt).toContain("Do not use ### type headings"); + expect(prompt).not.toContain("landed today`"); + expect(prompt).not.toContain("### fix"); + expect(prompt).not.toContain("### feat"); + expect(prompt).not.toContain("configurator"); + }); + + it("splits long recaps on blank lines so a PR block stays in one message", () => { + const prA = `[PR #1880](https://github.com/macs-holding/scanner/pull/1880) (feat)\nBauhaus packing materials were hardcoded.`; + const prB = `[PR #2273](https://github.com/macs-holding/scanner/pull/2273) (fix)\n${"x".repeat(1700)}`; + const recap = `## 🟢 MERGED\n\n${prA}\n\n## 🟠 OPEN\n\n${prB}`; + const chunks = chunkTodayRecapContent(recap, 1800); + expect(chunks.length).toBe(2); + expect(chunks[0]).toContain("PR #1880"); + expect(chunks[0]).not.toContain("PR #2273"); + expect(chunks[1]).toContain("PR #2273"); + expect(chunks[1]).not.toContain("PR #1880"); + expect(chunks.every((chunk) => chunk.length <= 1800)).toBe(true); + }); + + it("takes the last non-empty assistant message as the recap body", () => { + expect( + extractLatestAssistantText([ + { role: "user", text: "recap" }, + { role: "assistant", text: "draft" }, + { role: "assistant", text: "no change" }, + ]), + ).toBe("no change"); + expect(extractLatestAssistantText([{ role: "user", text: "recap" }])).toBeNull(); + expect(extractLatestAssistantText([{ role: "assistant", text: " " }])).toBeNull(); + }); +}); diff --git a/apps/discord-bot/src/presentation/todayRecap.ts b/apps/discord-bot/src/presentation/todayRecap.ts new file mode 100644 index 000000000000..005abbb68bc2 --- /dev/null +++ b/apps/discord-bot/src/presentation/todayRecap.ts @@ -0,0 +1,121 @@ +/** Channel topic `t3-` picks the repo. No schedule. */ + +export const TODAY_RECAP_SUBCOMMAND = "today-recap" as const; + +/** Interaction tokens last 15 minutes; leave headroom after GitHub lookups. */ +export const TODAY_RECAP_TURN_TIMEOUT_MS = 10 * 60 * 1000; +export const TODAY_RECAP_TURN_POLL_MS = 1500; + +export function extractLatestAssistantText( + messages: ReadonlyArray<{ readonly role: string; readonly text?: string | null }>, +): string | null { + for (let index = messages.length - 1; index >= 0; index -= 1) { + const message = messages[index]; + if (message?.role !== "assistant") continue; + const text = message.text?.trim() ?? ""; + if (text.length > 0) return text; + } + return null; +} + +/** YYYY-MM-DD from an ISO timestamp (`DateTime.formatIso`). */ +export function utcDateStamp(isoNow: string): string { + const stamp = isoNow.slice(0, 10); + return /^\d{4}-\d{2}-\d{2}$/.test(stamp) ? stamp : isoNow; +} + +/** Replaces Discord's deferred "thinking" spinner so the slash does not look stuck. */ +export function formatTodayRecapWorking(input: { + readonly shortName: string; + readonly date: string; +}): string { + return `Writing today's recap of \`${input.shortName}\` (${input.date} UTC)…`; +} + +export function formatTodayRecapThreadTitle(input: { + readonly shortName: string; + readonly date: string; +}): string { + return `today recap ${input.shortName} ${input.date}`; +} + +const DISCORD_RECAP_CHUNK_LIMIT = 2000; + +/** Split a recap on blank lines so a Discord follow-up never cuts a PR block in half. */ +export function chunkTodayRecapContent( + content: string, + limit = DISCORD_RECAP_CHUNK_LIMIT, +): string[] { + const trimmed = content.trimEnd(); + if (trimmed.length === 0) return [""]; + if (trimmed.length <= limit) return [trimmed]; + + const blocks = trimmed.split(/\n{2,}(?=\[PR #\d|## )/); + const chunks: string[] = []; + let current = ""; + const flush = () => { + if (current.length === 0) return; + chunks.push(current); + current = ""; + }; + for (const block of blocks) { + if (block.length > limit) { + flush(); + let remaining = block; + while (remaining.length > limit) { + let splitAt = remaining.lastIndexOf("\n", limit); + if (splitAt < Math.floor(limit * 0.5)) { + splitAt = remaining.lastIndexOf(" ", limit); + } + if (splitAt < Math.floor(limit * 0.5)) splitAt = limit; + chunks.push(remaining.slice(0, splitAt).trimEnd()); + remaining = remaining.slice(splitAt).trimStart(); + } + if (remaining.length > 0) current = remaining; + continue; + } + const next = current.length === 0 ? block : `${current}\n\n${block}`; + if (next.length > limit) { + flush(); + current = block; + } else { + current = next; + } + } + flush(); + return chunks; +} + +export function buildTodayRecapPrompt(input: { + readonly shortName: string; + readonly date: string; + readonly parentChannelId: string; +}): string { + return [ + `Write a small daily recap of GitHub PRs for the \`${input.shortName}\` repo bound to this Discord channel (<#${input.parentChannelId}>).`, + `Use GitHub's UTC calendar day ${input.date}. Query this workspace's GitHub origin — not other repos.`, + "", + "Read-only: do not edit files, do not checkout/commit/push, do not open a PR. The recap is the Discord message.", + "", + "Include only PRs that moved on that UTC day:", + "- MERGED: merged that day", + "- CLOSED: closed without merge that day", + "- OPEN: opened that day and still open — not the rest of the open backlog", + "", + "Use PR descriptions for what happened and why — not the code. Discord thread links are in PR descriptions.", + "", + "Format strictly:", + "- Status headings (omit empty sections):", + "## 🟢 MERGED", + "## 🔴 CLOSED", + "## 🟠 OPEN", + '- Related PRs (same change, follow-up, or a first try closed because a later PR handled it) are ONE block headed by the latest PR: OPEN if any is still open, else MERGED, else CLOSED. Weave earlier related PRs into that heading PR\'s description as [PR #N](url) (feat) plus a short what/why. Do not give them their own blocks. Do not write "landed today".', + "- Unrelated PRs: one block each. A closed PR with no connection to another PR that moved today goes only under CLOSED.", + "- Heading line: [PR #N](github-url) (fix). Visible text is exactly `PR #` plus the number. Types: (fix) (feat) (docs) (chore) (test) (refactor) from the branch or the squashed / first conventional commit (prefer the commit).", + "- Bare Discord thread URL on its own line. Do not wrap thread URLs in markdown. Do not use ### type headings.", + "- Plain language: what the user sees now and why. Spell out shop-floor terms on first use (Kein Versand = the app will not ship this order; Packmittel = packing materials; Lieferschein = delivery note). No jargon-only lines.", + "- A few sentences. Not verbose. Blank line between blocks.", + "", + "No code dumps. No process status. If nothing merged, closed, or opened that day, reply with exactly: no change", + ].join("\n"); +} diff --git a/apps/discord-bot/src/presentation/toolCalls.test.ts b/apps/discord-bot/src/presentation/toolCalls.test.ts new file mode 100644 index 000000000000..b736be998ec3 --- /dev/null +++ b/apps/discord-bot/src/presentation/toolCalls.test.ts @@ -0,0 +1,280 @@ +import type { OrchestrationThreadActivity } from "@t3tools/contracts"; +import { TurnId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { countTurnToolCalls } from "./toolCalls.ts"; + +function activity( + input: Omit, "id" | "kind"> & { + readonly id: string; + readonly kind: string; + }, +): OrchestrationThreadActivity { + return { + tone: "tool", + summary: "Tool call", + payload: {}, + turnId: null, + createdAt: "2026-07-10T00:00:00.000Z", + ...input, + } as OrchestrationThreadActivity; +} + +describe("countTurnToolCalls", () => { + it("returns 0 when there are no tool activities", () => { + expect( + countTurnToolCalls([activity({ id: "m1", kind: "message.created", tone: "info" })], null), + ).toBe(0); + }); + + it("collapses lifecycle updates for the same toolCallId even when not consecutive", () => { + expect( + countTurnToolCalls( + [ + activity({ + id: "a-start", + kind: "tool.updated", + sequence: 1, + createdAt: "2026-07-10T00:00:01.000Z", + payload: { itemType: "command_execution", data: { toolCallId: "call-a" } }, + }), + activity({ + id: "b", + kind: "tool.completed", + sequence: 2, + createdAt: "2026-07-10T00:00:02.000Z", + payload: { itemType: "command_execution", data: { toolCallId: "call-b" } }, + }), + activity({ + id: "a-done", + kind: "tool.completed", + sequence: 3, + createdAt: "2026-07-10T00:00:03.000Z", + payload: { + itemType: "command_execution", + title: "Ran command", + data: { toolCallId: "call-a" }, + }, + }), + ], + null, + ), + ).toBe(2); + }); + + it("counts distinct tool calls", () => { + expect( + countTurnToolCalls( + [ + activity({ + id: "a", + kind: "tool.completed", + sequence: 1, + payload: { itemType: "dynamic_tool_call", data: { toolCallId: "t1" } }, + }), + activity({ + id: "b", + kind: "tool.completed", + sequence: 2, + payload: { itemType: "dynamic_tool_call", data: { toolCallId: "t2" } }, + }), + activity({ + id: "c", + kind: "tool.updated", + sequence: 3, + payload: { itemType: "mcp_tool_call", data: { toolCallId: "t3" } }, + }), + ], + null, + ), + ).toBe(3); + }); + + it("scopes strictly to the latest turn (ignores null-turn noise)", () => { + const turnA = TurnId.make("turn-a"); + const turnB = TurnId.make("turn-b"); + expect( + countTurnToolCalls( + [ + activity({ + id: "orphan", + kind: "tool.completed", + turnId: null, + sequence: 0, + payload: { data: { toolCallId: "orphan-1" } }, + }), + activity({ + id: "old", + kind: "tool.completed", + turnId: turnA, + sequence: 1, + payload: { data: { toolCallId: "old-1" } }, + }), + activity({ + id: "new-1", + kind: "tool.completed", + turnId: turnB, + sequence: 2, + payload: { data: { toolCallId: "new-1" } }, + }), + activity({ + id: "new-2", + kind: "tool.updated", + turnId: turnB, + sequence: 3, + payload: { data: { toolCallId: "new-2" } }, + }), + ], + turnB, + ), + ).toBe(2); + }); + + it("counts only tools after the last settled assistant (latest in-progress segment)", () => { + const turn = TurnId.make("turn-1"); + expect( + countTurnToolCalls( + [ + activity({ + id: "early-1", + kind: "tool.completed", + turnId: turn, + sequence: 10, + createdAt: "2026-07-10T00:00:10.000Z", + payload: { data: { toolCallId: "early-1" } }, + }), + activity({ + id: "early-2", + kind: "tool.completed", + turnId: turn, + sequence: 11, + createdAt: "2026-07-10T00:00:11.000Z", + payload: { data: { toolCallId: "early-2" } }, + }), + // Settled intermediate assistant lands at seq 20 + activity({ + id: "late-1", + kind: "tool.completed", + turnId: turn, + sequence: 30, + createdAt: "2026-07-10T00:00:30.000Z", + payload: { data: { toolCallId: "late-1" } }, + }), + activity({ + id: "late-2", + kind: "tool.updated", + turnId: turn, + sequence: 31, + createdAt: "2026-07-10T00:00:31.000Z", + payload: { data: { toolCallId: "late-2" } }, + }), + activity({ + id: "late-2-done", + kind: "tool.completed", + turnId: turn, + sequence: 32, + createdAt: "2026-07-10T00:00:32.000Z", + payload: { data: { toolCallId: "late-2" } }, + }), + ], + turn, + [ + { + role: "user", + turnId: turn, + createdAt: "2026-07-10T00:00:01.000Z", + sequence: 1, + }, + { + role: "assistant", + turnId: turn, + streaming: false, + createdAt: "2026-07-10T00:00:20.000Z", + sequence: 20, + }, + { + role: "assistant", + turnId: turn, + streaming: true, + createdAt: "2026-07-10T00:00:25.000Z", + sequence: 25, + }, + ], + ), + ).toBe(2); + }); + + it("counts the whole turn when no settled assistant exists yet", () => { + const turn = TurnId.make("turn-1"); + expect( + countTurnToolCalls( + [ + activity({ + id: "t1", + kind: "tool.completed", + turnId: turn, + sequence: 2, + payload: { data: { toolCallId: "t1" } }, + }), + activity({ + id: "t2", + kind: "tool.updated", + turnId: turn, + sequence: 3, + payload: { data: { toolCallId: "t2" } }, + }), + ], + turn, + [{ role: "user", turnId: turn, createdAt: "2026-07-10T00:00:01.000Z", sequence: 1 }], + ), + ).toBe(2); + }); + + it("ignores older segments after multiple settled assistants (never whole-turn accumulation)", () => { + // Regression: completed answers re-synced as Working showed inflated counts like + // "81 tool calls" by counting every tool before the latest work segment. + const turn = TurnId.make("turn-1"); + const manyEarly = Array.from({ length: 80 }, (_, index) => + activity({ + id: `early-${index}`, + kind: "tool.completed", + turnId: turn, + sequence: index + 1, + createdAt: `2026-07-10T00:00:${String(index + 1).padStart(2, "0")}.000Z`, + payload: { data: { toolCallId: `early-${index}` } }, + }), + ); + expect( + countTurnToolCalls( + [ + ...manyEarly, + activity({ + id: "late-only", + kind: "tool.updated", + turnId: turn, + sequence: 200, + createdAt: "2026-07-10T00:03:00.000Z", + payload: { data: { toolCallId: "late-only" } }, + }), + ], + turn, + [ + { + role: "assistant", + turnId: turn, + streaming: false, + createdAt: "2026-07-10T00:02:00.000Z", + sequence: 100, + }, + { + role: "assistant", + turnId: turn, + streaming: true, + createdAt: "2026-07-10T00:02:30.000Z", + sequence: 150, + }, + ], + ), + ).toBe(1); + }); +}); diff --git a/apps/discord-bot/src/presentation/toolCalls.ts b/apps/discord-bot/src/presentation/toolCalls.ts new file mode 100644 index 000000000000..30609c8dd7f4 --- /dev/null +++ b/apps/discord-bot/src/presentation/toolCalls.ts @@ -0,0 +1,118 @@ +import type { OrchestrationThreadActivity, TurnId } from "@t3tools/contracts"; + +function asRecord(value: unknown): Record | null { + return typeof value === "object" && value !== null && !Array.isArray(value) + ? (value as Record) + : null; +} + +function text(value: unknown): string | null { + return typeof value === "string" && value.trim() !== "" ? value.trim() : null; +} + +function toolCallIdFromPayload(payload: Record): string | null { + // Match web client: payload.data.toolCallId is the stable id. + return text(asRecord(payload.data)?.toolCallId) ?? text(payload.toolCallId); +} + +function normalizeToolLabel(value: string): string { + return value.replace(/\s+(?:complete|completed)\s*$/iu, "").trim(); +} + +function collapseKeyForToolActivity(activity: OrchestrationThreadActivity): string | null { + if (activity.kind !== "tool.updated" && activity.kind !== "tool.completed") return null; + // Plan-boundary markers are not real tools (client skips them in the work log). + const payload = asRecord(activity.payload) ?? {}; + if (typeof payload.detail === "string" && payload.detail.startsWith("ExitPlanMode:")) { + return null; + } + if (activity.tone !== "tool" && activity.tone !== "error") return null; + + const id = toolCallIdFromPayload(payload); + if (id !== null) return `id:${id}`; + + const itemType = text(payload.itemType) ?? ""; + const title = normalizeToolLabel( + text(payload.title) ?? activity.summary.replace(/\s+complete(?:d)?$/iu, "").trim(), + ); + const detail = text(payload.detail) ?? ""; + if (itemType === "" && title === "" && detail === "") return null; + // No stable id — fall back to a content key (same idea as the web work-log collapse key). + return `meta:${itemType}\u001f${title}\u001f${detail}`; +} + +export type ToolCountMessage = { + readonly role: string; + readonly turnId?: string | null; + readonly streaming?: boolean; + readonly createdAt?: string; + readonly sequence?: number; +}; + +/** + * Count distinct tool calls in the **latest in-progress work segment** for the active turn. + * + * - Strictly scopes to `latestTurnId` when known (does not pull older turns / null-turn noise). + * - Collapses lifecycle updates by stable toolCallId (Set, not only consecutive). + * - Only tools after the last **settled** (non-streaming) assistant message of that turn, + * so intermediate prose does not keep accumulating the whole turn’s historical tools. + * - If there is no settled assistant yet, counts tools for the whole turn (first work batch). + * + * Discord only shows this count on Working — never individual tool rows. + */ +export function countTurnToolCalls( + activities: ReadonlyArray, + latestTurnId: TurnId | string | null, + messages: ReadonlyArray = [], +): number { + const turnId = latestTurnId?.trim() ?? ""; + + // Start of the current in-progress segment: right after the last settled assistant + // for this turn (so we don't keep counting tools from earlier intermediate bubbles). + let segmentAfterCreatedAt: string | null = null; + let segmentAfterSequence: number | null = null; + if (turnId !== "" && messages.length > 0) { + for (let i = messages.length - 1; i >= 0; i -= 1) { + const message = messages[i]; + if (message === undefined) continue; + if (message.role !== "assistant") continue; + if (message.streaming === true) continue; + const messageTurn = message.turnId?.trim() ?? ""; + if (messageTurn !== "" && messageTurn !== turnId) continue; + segmentAfterCreatedAt = message.createdAt ?? null; + segmentAfterSequence = + typeof message.sequence === "number" && Number.isFinite(message.sequence) + ? message.sequence + : null; + break; + } + } + + const ordered = [...activities].toSorted((left, right) => { + if (left.sequence !== undefined && right.sequence !== undefined) { + return left.sequence - right.sequence; + } + return left.createdAt.localeCompare(right.createdAt); + }); + + const seen = new Set(); + for (const activity of ordered) { + // Strict turn scope: when we know the active turn, require matching turnId. + if (turnId !== "") { + if (activity.turnId === null || activity.turnId !== turnId) continue; + } + + if (segmentAfterSequence !== null && activity.sequence !== undefined) { + if (activity.sequence <= segmentAfterSequence) continue; + } else if (segmentAfterCreatedAt !== null) { + // Inclusive guard: tool created at the same instant as the settled assistant still + // belongs to the prior segment if sequence is unavailable. + if (activity.createdAt.localeCompare(segmentAfterCreatedAt) <= 0) continue; + } + + const key = collapseKeyForToolActivity(activity); + if (key === null) continue; + seen.add(key); + } + return seen.size; +} diff --git a/apps/discord-bot/src/projectAliases.test.ts b/apps/discord-bot/src/projectAliases.test.ts new file mode 100644 index 000000000000..a2e312943b4e --- /dev/null +++ b/apps/discord-bot/src/projectAliases.test.ts @@ -0,0 +1,74 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { describe, expect, it } from "vite-plus/test"; + +import { + loadProjectAliasesFromFileSync, + normalizeProjectAliasShortName, + parseProjectAliasesDocument, +} from "./projectAliases.ts"; + +describe("normalizeProjectAliasShortName", () => { + it("normalizes valid short names", () => { + expect(normalizeProjectAliasShortName("Example-Project")).toBe("example-project"); + expect(normalizeProjectAliasShortName(" t3-code ")).toBe("t3-code"); + }); + + it("rejects invalid short names", () => { + expect(normalizeProjectAliasShortName("")).toBeNull(); + expect(normalizeProjectAliasShortName("Macs_Scanner")).toBeNull(); + }); +}); + +describe("parseProjectAliasesDocument", () => { + it("parses flat path map", () => { + const aliases = parseProjectAliasesDocument({ + "example-project": "/home/user/projects/example-project", + "t3-code": "~/pj/t3code", + }); + expect(aliases.map((entry) => entry.shortName)).toEqual(["example-project", "t3-code"]); + expect(aliases[0]?.workspaceRoot).toBe("/home/user/projects/example-project"); + expect(aliases[1]?.workspaceRoot.endsWith("/pj/t3code")).toBe(true); + }); + + it("parses structured aliases map", () => { + const aliases = parseProjectAliasesDocument({ + aliases: { + "example-project": { workspaceRoot: "/tmp/scanner" }, + }, + }); + expect(aliases).toEqual([{ shortName: "example-project", workspaceRoot: "/tmp/scanner" }]); + }); + + it("parses a Discord mirror channel for GitHub-created threads", () => { + const aliases = parseProjectAliasesDocument({ + aliases: { + "t3-code": { + workspaceRoot: "/tmp/t3code", + discordChannelId: "123456789", + }, + }, + }); + expect(aliases).toEqual([ + { + shortName: "t3-code", + workspaceRoot: "/tmp/t3code", + discordChannelId: "123456789", + }, + ]); + }); +}); + +describe("loadProjectAliasesFromFileSync", () => { + it("loads yaml files", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-bot-aliases-")); + const yamlPath = NodePath.join(dir, "aliases.yaml"); + await NodeFSP.writeFile(yamlPath, "example-project: /tmp/example-project\n", "utf8"); + const aliases = loadProjectAliasesFromFileSync(yamlPath); + expect(aliases).toEqual([ + { shortName: "example-project", workspaceRoot: "/tmp/example-project" }, + ]); + }); +}); diff --git a/apps/discord-bot/src/projectAliases.ts b/apps/discord-bot/src/projectAliases.ts new file mode 100644 index 000000000000..b4d2d6c54caa --- /dev/null +++ b/apps/discord-bot/src/projectAliases.ts @@ -0,0 +1,283 @@ +// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off tryCatchInEffectGen:off +/** + * Bot-local shortName → workspaceRoot mapping. + * The T3 server does not know about these aliases. + */ +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; + +const SHORT_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/; + +export interface ProjectAlias { + readonly shortName: string; + readonly workspaceRoot: string; + /** Parent Discord text channel where GitHub-created T3 threads should be mirrored. */ + readonly discordChannelId?: string; +} + +export class ProjectAliasesLoadError extends Schema.TaggedError()( + "ProjectAliasesLoadError", + { + path: Schema.String, + message: Schema.String, + }, +) {} + +const isProjectAliasesLoadError = Schema.is(ProjectAliasesLoadError); + +export function expandHomePath(value: string): string { + if (!value) return value; + if (value === "~") return NodeOS.homedir(); + if (value.startsWith("~/") || value.startsWith("~\\")) { + return NodePath.join(NodeOS.homedir(), value.slice(2)); + } + return value; +} + +export function normalizeProjectAliasShortName(raw: string): string | null { + const shortName = raw.trim().toLowerCase(); + if (shortName.length === 0) return null; + if (!SHORT_NAME_PATTERN.test(shortName)) return null; + return shortName; +} + +export function normalizeWorkspaceRootPath(raw: string): string { + const expanded = expandHomePath(raw.trim()); + return expanded.replaceAll("\\", "/").replace(/\/+$/u, "") || expanded; +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +/** + * Minimal YAML subset for flat maps and nested workspaceRoot form. + * Prefer JSON when possible; full YAML is not required. + */ +export function parseSimpleAliasesYaml(raw: string): unknown { + const lines = raw.split(/\r?\n/); + const flat: Record = {}; + const nested: Record = {}; + let inAliasesBlock = false; + let currentKey: string | null = null; + + for (const line of lines) { + const trimmed = line.trim(); + if (trimmed.length === 0 || trimmed.startsWith("#")) continue; + + if (/^aliases:\s*$/.test(trimmed)) { + inAliasesBlock = true; + continue; + } + + const nestedValueMatch = /^\s+(workspaceRoot|discordChannelId):\s*(.+)\s*$/.exec(line); + if (nestedValueMatch && currentKey !== null) { + const field = nestedValueMatch[1]! as "workspaceRoot" | "discordChannelId"; + const value = stripYamlScalar(nestedValueMatch[2]!); + nested[currentKey] = { ...nested[currentKey], [field]: value }; + continue; + } + + const nestedKeyMatch = /^\s{2,}([A-Za-z0-9][A-Za-z0-9_-]*):\s*$/.exec(line); + if (nestedKeyMatch && inAliasesBlock) { + currentKey = nestedKeyMatch[1]!; + continue; + } + + const flatMatch = /^([A-Za-z0-9][A-Za-z0-9_-]*):\s*(.+)\s*$/.exec(trimmed); + if (flatMatch) { + const key = flatMatch[1]!; + const value = stripYamlScalar(flatMatch[2]!); + if (key === "aliases") continue; + flat[key] = value; + currentKey = null; + continue; + } + } + + if (Object.keys(nested).length > 0) { + return { aliases: nested }; + } + return flat; +} + +function stripYamlScalar(value: string): string { + const trimmed = value.trim(); + if ( + (trimmed.startsWith('"') && trimmed.endsWith('"')) || + (trimmed.startsWith("'") && trimmed.endsWith("'")) + ) { + return trimmed.slice(1, -1); + } + return trimmed; +} + +/** + * Accept either: + * example-project: ~/projects/example-project + * or: + * aliases: + * example-project: + * workspaceRoot: ~/projects/example-project + * or array of { shortName, workspaceRoot }. + */ +export function parseProjectAliasesDocument( + document: unknown, + options?: { readonly resolveRelativeTo?: string }, +): ReadonlyArray { + const resolveRoot = (raw: string): string => { + const expanded = expandHomePath(raw.trim()); + const absolute = + options?.resolveRelativeTo !== undefined && !NodePath.isAbsolute(expanded) + ? NodePath.resolve(options.resolveRelativeTo, expanded) + : expanded; + return normalizeWorkspaceRootPath(absolute); + }; + + const entries = new Map(); + + const add = (shortNameRaw: string, workspaceRootRaw: string, discordChannelIdRaw?: string) => { + const shortName = normalizeProjectAliasShortName(shortNameRaw); + if (shortName === null) { + throw new Error( + `Invalid project alias shortName '${shortNameRaw}'. Use lowercase letters, digits, and hyphens (e.g. example-project).`, + ); + } + const workspaceRoot = resolveRoot(workspaceRootRaw); + if (workspaceRoot.trim().length === 0) { + throw new Error(`Project alias '${shortName}' has an empty workspaceRoot.`); + } + if (entries.has(shortName)) { + throw new Error(`Duplicate project alias shortName '${shortName}'.`); + } + entries.set(shortName, workspaceRoot); + if (discordChannelIdRaw?.trim()) discordChannels.set(shortName, discordChannelIdRaw.trim()); + }; + + const discordChannels = new Map(); + + if (Array.isArray(document)) { + for (const item of document) { + if (!isRecord(item)) { + throw new Error("Project aliases array entries must be objects."); + } + const shortName = item.shortName; + const workspaceRoot = item.workspaceRoot; + if (typeof shortName !== "string" || typeof workspaceRoot !== "string") { + throw new Error("Each project alias must include string shortName and workspaceRoot."); + } + add( + shortName, + workspaceRoot, + typeof item.discordChannelId === "string" ? item.discordChannelId : undefined, + ); + } + } else if (isRecord(document)) { + const aliasesNode = document.aliases; + const source = isRecord(aliasesNode) ? aliasesNode : document; + for (const [key, value] of Object.entries(source)) { + if (key === "aliases" && source === document) continue; + if (typeof value === "string") { + add(key, value); + continue; + } + if (isRecord(value) && typeof value.workspaceRoot === "string") { + add( + key, + value.workspaceRoot, + typeof value.discordChannelId === "string" ? value.discordChannelId : undefined, + ); + continue; + } + throw new Error( + `Project alias '${key}' must be a path string or an object with workspaceRoot.`, + ); + } + } else { + throw new Error("Project aliases file must be a mapping, aliases object, or array."); + } + + return [...entries.entries()] + .map(([shortName, workspaceRoot]) => ({ + shortName, + workspaceRoot, + ...(discordChannels.has(shortName) + ? { discordChannelId: discordChannels.get(shortName)! } + : {}), + })) + .toSorted((left, right) => left.shortName.localeCompare(right.shortName)); +} + +export function loadProjectAliasesFromFileSync(filePath: string): ReadonlyArray { + const resolvedPath = NodePath.resolve(expandHomePath(filePath.trim())); + if (!NodeFS.existsSync(resolvedPath)) { + throw new ProjectAliasesLoadError({ + path: resolvedPath, + message: `Project aliases file not found: ${resolvedPath}`, + }); + } + + const raw = NodeFS.readFileSync(resolvedPath, "utf8"); + const trimmed = raw.trim(); + if (trimmed.length === 0) return []; + + let document: unknown; + if (resolvedPath.endsWith(".json")) { + document = JSON.parse(trimmed) as unknown; + } else { + document = parseSimpleAliasesYaml(trimmed); + } + + return parseProjectAliasesDocument(document, { + resolveRelativeTo: NodePath.dirname(resolvedPath), + }); +} + +export interface ProjectAliasStoreService { + readonly list: () => ReadonlyArray; + readonly resolve: (shortName: string) => ProjectAlias | null; +} + +export class ProjectAliasStore extends Context.Service< + ProjectAliasStore, + ProjectAliasStoreService +>()("@t3tools/discord-bot/projectAliases/ProjectAliasStore") {} + +export const makeProjectAliasStore = (aliases: ReadonlyArray) => + ProjectAliasStore.of({ + list: () => aliases, + resolve: (shortName) => { + const normalized = shortName.trim().toLowerCase(); + return aliases.find((entry) => entry.shortName === normalized) ?? null; + }, + }); + +export const layerFromOptionalPath = (filePath: string | undefined) => + Layer.effect( + ProjectAliasStore, + Effect.gen(function* () { + if (filePath === undefined || filePath.trim().length === 0) { + yield* Effect.logWarning( + "T3_PROJECT_ALIASES_PATH is unset; channel topics will not resolve to projects until configured.", + ); + return makeProjectAliasStore([]); + } + const aliases = yield* Effect.try({ + try: () => loadProjectAliasesFromFileSync(filePath), + catch: (cause) => { + if (isProjectAliasesLoadError(cause)) return cause; + return new ProjectAliasesLoadError({ + path: filePath, + message: cause instanceof Error ? cause.message : String(cause), + }); + }, + }); + yield* Effect.logInfo(`Loaded ${aliases.length} project alias(es) from ${filePath}`); + return makeProjectAliasStore(aliases); + }), + ); diff --git a/apps/discord-bot/src/store/ServerWorkItemJoin.test.ts b/apps/discord-bot/src/store/ServerWorkItemJoin.test.ts new file mode 100644 index 000000000000..37743d0ce83a --- /dev/null +++ b/apps/discord-bot/src/store/ServerWorkItemJoin.test.ts @@ -0,0 +1,121 @@ +// @effect-diagnostics nodeBuiltinImport:off +import type { ProjectId, ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "@effect/vitest"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { normalizeThreadLinkInput, type ThreadLink } from "./ThreadLinkStore.ts"; +import { + normalizeGitHubPullRequestRef, + normalizeJiraIssueKey, + resolveUniqueT3ThreadIdForWorkItems, + serverWorkItemsPathFromStateSqlite, +} from "./ServerWorkItemJoin.ts"; + +function discordLink(t3ThreadId: string, status: "active" | "tombstone" = "active"): ThreadLink { + return normalizeThreadLinkInput({ + discordThreadId: `discord-${t3ThreadId}`, + t3ThreadId: t3ThreadId as ThreadId, + projectId: "project-1" as ProjectId, + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-30T00:00:00.000Z", + status, + }); +} + +describe("ServerWorkItemJoin", () => { + it("normalizes keys and PR refs", () => { + expect(normalizeJiraIssueKey("sa-401")).toBe("SA-401"); + expect(normalizeJiraIssueKey("UTF-8")).toBeNull(); + expect(normalizeGitHubPullRequestRef("https://github.com/Acme/Repo/pull/9")).toBe( + "github.com/acme/repo/pull/9", + ); + }); + + it("joins unique server store hits and fails closed on ambiguity", () => { + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "work-item-join-")); + const filePath = NodePath.join(dir, "thread-work-items.json"); + NodeFS.writeFileSync( + filePath, + JSON.stringify({ + version: 1, + records: [ + { + threadId: "t-jira", + jiraIssueKeys: ["SA-401"], + githubPullRequests: [], + sources: ["jira-webhook"], + updatedAt: "2026-07-30T00:00:00.000Z", + }, + { + threadId: "t-other", + jiraIssueKeys: ["SA-402"], + githubPullRequests: ["github.com/acme/repo/pull/1"], + sources: ["github-webhook"], + updatedAt: "2026-07-30T00:00:00.000Z", + }, + ], + }), + ); + + expect( + resolveUniqueT3ThreadIdForWorkItems({ + jiraIssueKeys: ["SA-401"], + prUrls: [], + discordLinks: [], + serverWorkItemsPath: filePath, + }), + ).toBe("t-jira"); + + expect( + resolveUniqueT3ThreadIdForWorkItems({ + jiraIssueKeys: ["SA-401", "SA-402"], + prUrls: [], + discordLinks: [], + serverWorkItemsPath: filePath, + }), + ).toBeNull(); + + expect(serverWorkItemsPathFromStateSqlite("/var/lib/t3/userdata/state.sqlite")).toBe( + "/var/lib/t3/userdata/thread-work-items.json", + ); + }); + + it("never joins a server work-item thread that already has an active Discord link", () => { + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "work-item-join-")); + const filePath = NodePath.join(dir, "thread-work-items.json"); + NodeFS.writeFileSync( + filePath, + JSON.stringify({ + version: 1, + records: [ + { + threadId: "t-pr", + jiraIssueKeys: [], + githubPullRequests: ["https://github.com/acme/repo/pull/9"], + }, + ], + }), + ); + + expect( + resolveUniqueT3ThreadIdForWorkItems({ + jiraIssueKeys: [], + prUrls: ["https://github.com/acme/repo/pull/9"], + discordLinks: [discordLink("t-pr")], + serverWorkItemsPath: filePath, + }), + ).toBeNull(); + + expect( + resolveUniqueT3ThreadIdForWorkItems({ + jiraIssueKeys: [], + prUrls: ["https://github.com/acme/repo/pull/9"], + discordLinks: [discordLink("t-pr", "tombstone")], + serverWorkItemsPath: filePath, + }), + ).toBe("t-pr"); + }); +}); diff --git a/apps/discord-bot/src/store/ServerWorkItemJoin.ts b/apps/discord-bot/src/store/ServerWorkItemJoin.ts new file mode 100644 index 000000000000..14598133aad2 --- /dev/null +++ b/apps/discord-bot/src/store/ServerWorkItemJoin.ts @@ -0,0 +1,134 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Join an existing T3 thread by shared work-item identity (Jira key / GitHub PR) + * before Discord creates a new session. + * + * Sources: + * - Server `thread-work-items.json` next to state.sqlite (Jira/GitHub bridges) + * + * Active Discord links are exclusions: one T3 thread must never be implicitly + * joined from more than one Discord thread. + */ +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; + +import type { ThreadId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; + +import type { ThreadLink } from "./ThreadLinkStore.ts"; + +const FALSE_POSITIVE_JIRA_KEYS = new Set(["UTF-8", "ISO-8601", "HTTP-1", "HTTP-2", "TLS-1"]); + +export function normalizeJiraIssueKey(raw: string): string | null { + const key = raw.trim().toUpperCase(); + if (!/^[A-Z][A-Z0-9]{1,9}-\d{1,7}$/u.test(key)) return null; + if (FALSE_POSITIVE_JIRA_KEYS.has(key)) return null; + return key; +} + +export function normalizeGitHubPullRequestRef(raw: string): string | null { + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + const urlMatch = trimmed.match( + /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:\/[^?\s]*)?(?:[?#]\S*)?$/iu, + ); + if (urlMatch) { + return `github.com/${urlMatch[1]!.toLowerCase()}/${urlMatch[2]!.toLowerCase()}/pull/${urlMatch[3]!}`; + } + const shortMatch = trimmed.match(/^([^/\s]+)\/([^#\s]+)#(\d+)$/u); + if (shortMatch) { + return `github.com/${shortMatch[1]!.toLowerCase()}/${shortMatch[2]!.toLowerCase()}/pull/${shortMatch[3]!}`; + } + return null; +} + +type ServerWorkItemRecord = { + readonly threadId: string; + readonly jiraIssueKeys?: ReadonlyArray; + readonly githubPullRequests?: ReadonlyArray; +}; + +function readServerWorkItemRecords(filePath: string): ReadonlyArray { + try { + const raw = NodeFS.readFileSync(filePath, "utf8"); + const parsed: unknown = JSON.parse(raw); + if (parsed === null || typeof parsed !== "object") return []; + const records = (parsed as { records?: unknown }).records; + if (!Array.isArray(records)) return []; + return records.filter( + (row): row is ServerWorkItemRecord => + row !== null && + typeof row === "object" && + typeof (row as ServerWorkItemRecord).threadId === "string", + ); + } catch { + return []; + } +} + +/** + * Return a unique T3 thread id if the given Jira keys / PR URLs map to exactly one thread. + * Fail closed on zero or many matches. + */ +export function resolveUniqueT3ThreadIdForWorkItems(input: { + readonly jiraIssueKeys: ReadonlyArray; + readonly prUrls: ReadonlyArray; + readonly discordLinks: ReadonlyArray; + readonly serverWorkItemsPath: string; +}): ThreadId | null { + const jiraKeys = [ + ...new Set( + input.jiraIssueKeys + .map((key) => normalizeJiraIssueKey(key)) + .filter((key): key is string => key !== null), + ), + ]; + const prRefs = [ + ...new Set( + input.prUrls + .map((url) => normalizeGitHubPullRequestRef(url)) + .filter((ref): ref is string => ref !== null), + ), + ]; + if (jiraKeys.length === 0 && prRefs.length === 0) return null; + + const threadIds = new Set(); + const discordLinkedThreadIds = new Set( + input.discordLinks + .filter((link) => link.status === "active" && (link.sourceKind ?? "discord") === "discord") + .map((link) => link.t3ThreadId), + ); + + const serverRecords = readServerWorkItemRecords(input.serverWorkItemsPath); + for (const record of serverRecords) { + if (discordLinkedThreadIds.has(record.threadId)) continue; + const recordKeys = new Set( + (record.jiraIssueKeys ?? []) + .map((key) => normalizeJiraIssueKey(key)) + .filter((key): key is string => key !== null), + ); + const recordPrs = new Set( + (record.githubPullRequests ?? []) + .map((url) => normalizeGitHubPullRequestRef(url)) + .filter((ref): ref is string => ref !== null), + ); + const jiraHit = jiraKeys.some((key) => recordKeys.has(key)); + const prHit = prRefs.some((ref) => recordPrs.has(ref)); + if (jiraHit || prHit) threadIds.add(record.threadId); + } + + if (threadIds.size !== 1) return null; + const [only] = threadIds; + return only as ThreadId; +} + +export function serverWorkItemsPathFromStateSqlite(stateSqlitePath: string): string { + return NodePath.join(NodePath.dirname(stateSqlitePath), "thread-work-items.json"); +} + +export const resolveUniqueT3ThreadIdForWorkItemsEffect = (input: { + readonly jiraIssueKeys: ReadonlyArray; + readonly prUrls: ReadonlyArray; + readonly discordLinks: ReadonlyArray; + readonly serverWorkItemsPath: string; +}) => Effect.sync(() => resolveUniqueT3ThreadIdForWorkItems(input)); diff --git a/apps/discord-bot/src/store/TeamsSeenStore.ts b/apps/discord-bot/src/store/TeamsSeenStore.ts new file mode 100644 index 000000000000..3b5fcf1ec10f --- /dev/null +++ b/apps/discord-bot/src/store/TeamsSeenStore.ts @@ -0,0 +1,87 @@ +// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off tryCatchInEffectGen:off missingEffectError:off +import * as NodeFSP from "node:fs/promises"; +import * as NodePath from "node:path"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; + +import { expandHomePath } from "../projectAliases.ts"; + +export interface TeamsSeenStoreService { + readonly hasSeen: (channelKey: string, messageId: string) => Effect.Effect; + readonly listSeenIds: (channelKey: string) => Effect.Effect>; + readonly markSeen: (channelKey: string, messageId: string) => Effect.Effect; +} + +export class TeamsSeenStore extends Context.Service()( + "@t3tools/discord-bot/store/TeamsSeenStore", +) {} + +const MAX_MESSAGE_IDS_PER_CHANNEL = 500; + +export const layer = (dataDirRaw: string) => + Layer.effect( + TeamsSeenStore, + Effect.gen(function* () { + const dataDir = expandHomePath(dataDirRaw); + const filePath = NodePath.join(dataDir, "teams-seen.json"); + yield* Effect.promise(() => NodeFSP.mkdir(dataDir, { recursive: true, mode: 0o700 })); + + const initial = yield* Effect.tryPromise({ + try: () => NodeFSP.readFile(filePath, "utf8"), + catch: () => null, + }).pipe( + Effect.map((raw) => { + if (raw === null) return {} as Record>; + const parsed = JSON.parse(raw) as unknown; + if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) { + return {} as Record>; + } + const entries = Object.entries(parsed as Record).flatMap( + ([channelKey, value]) => + Array.isArray(value) && value.every((item) => typeof item === "string") + ? [[channelKey, value] as const] + : [], + ); + return Object.fromEntries(entries); + }), + Effect.orElseSucceed(() => ({}) as Record>), + ); + + const state = yield* Ref.make( + new Map( + Object.entries(initial).map(([channelKey, messageIds]) => [channelKey, [...messageIds]]), + ), + ); + + const persist = (value: Map) => + Effect.promise(() => + NodeFSP.writeFile( + filePath, + `${JSON.stringify(Object.fromEntries(value.entries()), null, 2)}\n`, + { mode: 0o600 }, + ), + ); + + return TeamsSeenStore.of({ + hasSeen: (channelKey, messageId) => + Ref.get(state).pipe(Effect.map((map) => (map.get(channelKey) ?? []).includes(messageId))), + listSeenIds: (channelKey) => + Ref.get(state).pipe(Effect.map((map) => [...(map.get(channelKey) ?? [])])), + markSeen: (channelKey, messageId) => + Effect.gen(function* () { + const next = yield* Ref.updateAndGet(state, (current) => { + const copy = new Map(current); + const existing = copy.get(channelKey) ?? []; + if (existing.includes(messageId)) { + return copy; + } + copy.set(channelKey, [...existing, messageId].slice(-MAX_MESSAGE_IDS_PER_CHANNEL)); + return copy; + }); + yield* persist(next); + }), + }); + }), + ); diff --git a/apps/discord-bot/src/store/ThreadLinkStore.test.ts b/apps/discord-bot/src/store/ThreadLinkStore.test.ts new file mode 100644 index 000000000000..fe6b5878ce22 --- /dev/null +++ b/apps/discord-bot/src/store/ThreadLinkStore.test.ts @@ -0,0 +1,502 @@ +// @effect-diagnostics nodeBuiltinImport:off anyUnknownInErrorContext:off missingEffectError:off missingEffectContext:off +/* oxlint-disable t3code/no-manual-effect-runtime-in-tests -- Legacy filesystem fixture uses a manually scoped runtime. */ +import type { ProjectId, ThreadId } from "@t3tools/contracts"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { ProjectId as ProjectIdBrand, ThreadId as ThreadIdBrand } from "@t3tools/contracts"; +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import { describe, expect, it as vitestIt } from "vite-plus/test"; + +import { + LINKS_DOCUMENT_VERSION, + makeThreadLinkStore, + migrateV1Link, + normalizeThreadLinkInput, + parseLinksDocument, + type ThreadLinkInput, + type ThreadLinkStoreService, +} from "./ThreadLinkStore.ts"; + +const makeTempDir = Effect.acquireRelease( + Effect.tryPromise(() => NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "thread-link-store-"))), + (dir) => Effect.promise(() => NodeFSP.rm(dir, { recursive: true, force: true })), +); + +const sampleV1 = { + discordThreadId: "d-1", + t3ThreadId: "t-1", + projectId: "p-1", + channelId: "c-1", + guildId: "g-1", + createdAt: "2026-01-01T00:00:00.000Z", +}; + +function input(overrides: Partial = {}): ThreadLinkInput { + return { + discordThreadId: "d-1", + t3ThreadId: "t-1" as ThreadId, + projectId: "p-1" as ProjectId, + channelId: "c-1", + guildId: "g-1", + createdAt: "2026-01-01T00:00:00.000Z", + ...overrides, + }; +} + +async function withStore( + body: (store: ThreadLinkStoreService) => Effect.Effect, +): Promise { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-bot-links-")); + try { + return await Effect.runPromise( + Effect.gen(function* () { + const store = yield* makeThreadLinkStore(dir); + return yield* body(store); + }) as Effect.Effect, + ); + } finally { + await NodeFSP.rm(dir, { recursive: true, force: true }); + } +} + +describe("migrateV1Link / parseLinksDocument", () => { + vitestIt("migrates v1 fields to v2 defaults", () => { + const migrated = migrateV1Link(sampleV1); + expect(migrated).toEqual({ + ...sampleV1, + t3ThreadId: "t-1", + projectId: "p-1", + updatedAt: sampleV1.createdAt, + lastActivityAt: sampleV1.createdAt, + status: "active", + lastSeenTurnId: null, + lastFinalizedAssistantId: null, + lastThreadSnapshotSequence: null, + lastDeliveredSequence: null, + threadTalkMode: undefined, + taskDiscordMessageId: undefined, + streamDiscordMessageIds: undefined, + sentDiscordUserMessageIds: undefined, + jiraIssueKeys: undefined, + sentryIssueUrls: undefined, + prUrls: undefined, + infoDiscordMessageId: undefined, + initialModelLine: undefined, + currentModelLine: undefined, + modelSinceAt: undefined, + }); + }); + + vitestIt("parses bare v1 array as migrated v2", () => { + const parsed = parseLinksDocument([sampleV1]); + expect(parsed.migratedFromV1).toBe(true); + expect(parsed.version).toBe(LINKS_DOCUMENT_VERSION); + expect(parsed.links).toHaveLength(1); + expect(parsed.links[0]?.lastActivityAt).toBe(sampleV1.createdAt); + expect(parsed.links[0]?.status).toBe("active"); + expect(parsed.links[0]?.streamDiscordMessageIds).toBeUndefined(); + }); + + vitestIt("parses versioned v2 document", () => { + const link = normalizeThreadLinkInput(input()); + const parsed = parseLinksDocument({ version: 2, links: [link] }); + expect(parsed.migratedFromV1).toBe(false); + expect(parsed.links[0]).toEqual(link); + }); + + vitestIt("returns empty list for corrupt payload", () => { + expect(parseLinksDocument(null).links).toEqual([]); + expect(parseLinksDocument("nope").links).toEqual([]); + expect(parseLinksDocument({ version: 2, links: "bad" }).links).toEqual([]); + }); + + vitestIt("preserves stream tip ids when migrating v1 with extras", () => { + const parsed = parseLinksDocument([ + { + ...sampleV1, + streamDiscordMessageIds: ["s1", "s2"], + taskDiscordMessageId: "task-1", + }, + ]); + expect(parsed.links[0]?.streamDiscordMessageIds).toEqual(["s1", "s2"]); + expect(parsed.links[0]?.taskDiscordMessageId).toBe("task-1"); + }); +}); + +describe("normalizeThreadLinkInput", () => { + vitestIt("fills durable defaults for optional bridge fields", () => { + const link = normalizeThreadLinkInput(input()); + expect(link.updatedAt).toBe(link.createdAt); + expect(link.lastActivityAt).toBe(link.createdAt); + expect(link.status).toBe("active"); + expect(link.lastSeenTurnId).toBeNull(); + expect(link.lastFinalizedAssistantId).toBeNull(); + }); +}); + +describe("makeThreadLinkStore", () => { + vitestIt("put / getByDiscordThreadId / getByT3ThreadId / list", async () => { + await withStore((store) => + Effect.gen(function* () { + yield* store.put(input()); + const byDiscord = yield* store.getByDiscordThreadId("d-1"); + const byT3 = yield* store.getByT3ThreadId("t-1"); + const missing = yield* store.getByDiscordThreadId("missing"); + const all = yield* store.list(); + + expect(byDiscord?.t3ThreadId).toBe("t-1"); + expect(byT3?.discordThreadId).toBe("d-1"); + expect(missing).toBeNull(); + expect(all).toHaveLength(1); + }), + ); + }); + + vitestIt("touch updates lastActivityAt and updatedAt", async () => { + await withStore((store) => + Effect.gen(function* () { + yield* store.put(input()); + const touched = yield* store.touch("d-1", "2026-06-01T12:00:00.000Z"); + expect(touched?.lastActivityAt).toBe("2026-06-01T12:00:00.000Z"); + expect(touched?.updatedAt).toBe("2026-06-01T12:00:00.000Z"); + }), + ); + }); + + vitestIt("tombstone marks link inactive", async () => { + await withStore((store) => + Effect.gen(function* () { + yield* store.put(input()); + const tombstoned = yield* store.tombstone("d-1"); + expect(tombstoned?.status).toBe("tombstone"); + }), + ); + }); + + vitestIt("updateBridgeHints persists finalize + stream tip ids", async () => { + await withStore((store) => + Effect.gen(function* () { + yield* store.put(input()); + yield* store.updateBridgeHints("d-1", { + lastFinalizedAssistantId: "asst-1", + streamDiscordMessageIds: ["s1", "s1", ""], + }); + const link = yield* store.getByDiscordThreadId("d-1"); + expect(link?.lastFinalizedAssistantId).toBe("asst-1"); + expect(link?.streamDiscordMessageIds).toEqual(["s1"]); + + yield* store.updateBridgeHints("d-1", { streamDiscordMessageIds: [] }); + const cleared = yield* store.getByDiscordThreadId("d-1"); + expect(cleared?.streamDiscordMessageIds).toBeUndefined(); + expect(cleared?.lastFinalizedAssistantId).toBe("asst-1"); + }), + ); + }); + + vitestIt("partial bridge hint writes do not wipe sequence or stream markers", async () => { + await withStore((store) => + Effect.gen(function* () { + yield* store.put(input()); + yield* store.updateBridgeHints("d-1", { + lastThreadSnapshotSequence: 42, + lastDeliveredSequence: 40, + streamDiscordMessageIds: ["tip-1"], + }); + // Sequence-only update must keep stream tip ids + delivery cursor. + yield* store.updateBridgeHints("d-1", { lastThreadSnapshotSequence: 99 }); + const afterSeq = yield* store.getByDiscordThreadId("d-1"); + expect(afterSeq?.lastThreadSnapshotSequence).toBe(99); + expect(afterSeq?.lastDeliveredSequence).toBe(40); + expect(afterSeq?.streamDiscordMessageIds).toEqual(["tip-1"]); + + // Delivery cursor-only update must keep orchestration sequence. + yield* store.updateBridgeHints("d-1", { lastDeliveredSequence: 99 }); + const afterDelivered = yield* store.getByDiscordThreadId("d-1"); + expect(afterDelivered?.lastDeliveredSequence).toBe(99); + expect(afterDelivered?.lastThreadSnapshotSequence).toBe(99); + + // Stream-only update must keep both sequence cursors. + yield* store.setStreamDiscordMessageIds("d-1", ["tip-2"]); + const afterStream = yield* store.getByDiscordThreadId("d-1"); + expect(afterStream?.streamDiscordMessageIds).toEqual(["tip-2"]); + expect(afterStream?.lastThreadSnapshotSequence).toBe(99); + expect(afterStream?.lastDeliveredSequence).toBe(99); + + // Minimal put must preserve durable dual-cursor + tip hints. + yield* store.put(input()); + const afterPut = yield* store.getByDiscordThreadId("d-1"); + expect(afterPut?.lastThreadSnapshotSequence).toBe(99); + expect(afterPut?.lastDeliveredSequence).toBe(99); + expect(afterPut?.streamDiscordMessageIds).toEqual(["tip-2"]); + }), + ); + }); +}); + +it.effect("persists the task message id for later bridge restarts", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.setTaskDiscordMessageId("discord-thread-1", "task-message-1"); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + + assert.strictEqual(link?.taskDiscordMessageId, "task-message-1"); + assert.strictEqual(link?.status, "active"); + assert.strictEqual(link?.lastActivityAt, "2026-07-18T00:00:00.000Z"); + }), +); + +it.effect("persists jira keys in first-seen order and info message id", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.appendJiraIssueKeys("discord-thread-1", ["PROJ-2", "PROJ-1"]); + yield* store.appendJiraIssueKeys("discord-thread-1", ["PROJ-1", "PROJ-3"]); + yield* store.setInfoDiscordMessageId("discord-thread-1", "info-msg-1"); + + // Minimal put must preserve durable jira + info hints. + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + assert.deepStrictEqual(link?.jiraIssueKeys, ["PROJ-2", "PROJ-1", "PROJ-3"]); + assert.strictEqual(link?.infoDiscordMessageId, "info-msg-1"); + }), +); + +it.effect("persists sentry issue urls in first-seen order across reloads and minimal puts", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.appendSentryIssueUrls("discord-thread-1", [ + "https://macs-scanner.sentry.io/issues/SCANNER-313/?project=1", + "https://macs-scanner.sentry.io/issues/7506163172/", + ]); + yield* store.appendSentryIssueUrls("discord-thread-1", [ + "https://macs-scanner.sentry.io/issues/SCANNER-313", + ]); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + assert.deepStrictEqual(link?.sentryIssueUrls, [ + "https://macs-scanner.sentry.io/issues/SCANNER-313", + "https://macs-scanner.sentry.io/issues/7506163172", + ]); + }), +); + +it.effect("persists PR urls in first-seen order across reloads and minimal puts", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.appendPrUrls("discord-thread-1", [ + "https://github.com/acme/widgets/pull/42", + "https://github.com/acme/widgets/pull/7/files", + ]); + yield* store.appendPrUrls("discord-thread-1", [ + "https://github.com/acme/widgets/pull/42", + "https://github.com/example-org/scanner/pull/1950", + ]); + + // Minimal put must preserve durable PR urls. + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + assert.deepStrictEqual(link?.prUrls, [ + "https://github.com/acme/widgets/pull/42", + "https://github.com/acme/widgets/pull/7", + "https://github.com/example-org/scanner/pull/1950", + ]); + }), +); + +it.effect("persists model history for thread info pin", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.setModelHistory("discord-thread-1", { + initialModelLine: "codex/gpt-5.4", + currentModelLine: "grok/grok-4.5", + modelSinceAt: "2026-07-20T08:05:00.000Z", + }); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + assert.strictEqual(link?.initialModelLine, "codex/gpt-5.4"); + assert.strictEqual(link?.currentModelLine, "grok/grok-4.5"); + assert.strictEqual(link?.modelSinceAt, "2026-07-20T08:05:00.000Z"); + }), +); + +it.effect("persists and clears stream message ids for bridge restart cleanup", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.setStreamDiscordMessageIds("discord-thread-1", [ + "stream-1", + "stream-2", + "stream-1", + "", + ]); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + + assert.deepStrictEqual(link?.streamDiscordMessageIds, ["stream-1", "stream-2"]); + + yield* reloaded.setStreamDiscordMessageIds("discord-thread-1", []); + const cleared = yield* (yield* makeThreadLinkStore(dataDir)).getByDiscordThreadId( + "discord-thread-1", + ); + + assert.strictEqual(cleared?.streamDiscordMessageIds, undefined); + }), +); + +it.effect( + "persists and clears Discord-originated user message ids for external echo suppression", + () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.setSentDiscordUserMessageIds("discord-thread-1", [ + "user-1", + "user-2", + "user-1", + "", + ]); + + const reloaded = yield* makeThreadLinkStore(dataDir); + const link = yield* reloaded.getByDiscordThreadId("discord-thread-1"); + + assert.deepStrictEqual(link?.sentDiscordUserMessageIds, ["user-1", "user-2"]); + + yield* reloaded.setSentDiscordUserMessageIds("discord-thread-1", []); + const cleared = yield* (yield* makeThreadLinkStore(dataDir)).getByDiscordThreadId( + "discord-thread-1", + ); + + assert.strictEqual(cleared?.sentDiscordUserMessageIds, undefined); + }), +); + +it.effect("persists and disables thread-talk mode", () => + Effect.gen(function* () { + const dataDir = yield* makeTempDir; + const store = yield* makeThreadLinkStore(dataDir); + + yield* store.put({ + discordThreadId: "discord-thread-1", + t3ThreadId: ThreadIdBrand.make("thread-1"), + projectId: ProjectIdBrand.make("project-1"), + channelId: "channel-1", + guildId: "guild-1", + createdAt: "2026-07-18T00:00:00.000Z", + }); + yield* store.setThreadTalkMode("discord-thread-1", "all-messages"); + + const enabled = yield* (yield* makeThreadLinkStore(dataDir)).getByDiscordThreadId( + "discord-thread-1", + ); + assert.strictEqual(enabled?.threadTalkMode, "all-messages"); + assert.strictEqual(enabled?.sentDiscordUserMessageIds, undefined); + + yield* store.setThreadTalkMode("discord-thread-1", null); + const disabled = yield* (yield* makeThreadLinkStore(dataDir)).getByDiscordThreadId( + "discord-thread-1", + ); + assert.strictEqual(disabled?.threadTalkMode, undefined); + assert.strictEqual(disabled?.sentDiscordUserMessageIds, undefined); + }), +); diff --git a/apps/discord-bot/src/store/ThreadLinkStore.ts b/apps/discord-bot/src/store/ThreadLinkStore.ts new file mode 100644 index 000000000000..b750fd3d3fdc --- /dev/null +++ b/apps/discord-bot/src/store/ThreadLinkStore.ts @@ -0,0 +1,904 @@ +// @effect-diagnostics globalErrorInEffectCatch:off globalErrorInEffectFailure:off preferSchemaOverJson:off tryCatchInEffectGen:off missingEffectError:off nodeBuiltinImport:off globalDate:off +import type { ProjectId, ThreadId } from "@t3tools/contracts"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; + +import { mergeSentryIssueUrls } from "../presentation/sentryLinks.ts"; + +export const LINKS_DOCUMENT_VERSION = 2 as const; + +export const ThreadLinkStatus = Schema.Literals(["active", "tombstone"]); +export type ThreadLinkStatus = typeof ThreadLinkStatus.Type; + +/** + * Durable Discord ↔ T3 link (links.json v2). + * + * Keeps existing Discord-bot fields (threadTalkMode, task/stream/sent message ids) + * and adds restore hints (activity, tombstone, last finalized assistant). + */ +export const ThreadLink = Schema.Struct({ + /** Originating chat platform; defaults to discord when omitted (older links.json). */ + sourceKind: Schema.optional(Schema.Literals(["discord", "teams"])), + /** Stable external conversation key (Teams root message id, or Discord thread id). */ + sourceThreadId: Schema.optional(Schema.String), + discordThreadId: Schema.String, + t3ThreadId: Schema.String, + projectId: Schema.String, + channelId: Schema.String, + guildId: Schema.String, + createdAt: Schema.String, + updatedAt: Schema.String, + lastActivityAt: Schema.String, + status: ThreadLinkStatus, + lastSeenTurnId: Schema.NullOr(Schema.String), + lastFinalizedAssistantId: Schema.NullOr(Schema.String), + /** + * Last applied orchestration event/snapshot sequence for this linked T3 thread. + * Scalar marker only — we never persist pre-sync event history. Used with + * `lastDeliveredSequence` to resume `subscribeThread({ afterSequence })` without + * re-walking the whole event log. Advances when T3 state is observed (WS/HTTP), not + * when Discord I/O finishes. Partial bridge hint writes must not clear this. + * Optional in schema so older links.json rows still decode (default null). + */ + lastThreadSnapshotSequence: Schema.optional(Schema.NullOr(Schema.Number)), + /** + * Last orchestration sequence that was successfully applied to Discord + * (stream tip and/or finalize path finished without fatal process failure). + * Scalar marker only (not message/event history). Resume prefers this cursor + * (minus a small buffer) so already-synced sequences are not re-read. + * May lag `lastThreadSnapshotSequence` when Discord I/O is slow/hung or the + * process dies mid-delivery. Used for HTTP reconcile + rehydrate catch-up. + * Optional for older links.json rows (default null = unknown). + */ + lastDeliveredSequence: Schema.optional(Schema.NullOr(Schema.Number)), + threadTalkMode: Schema.optional(Schema.Literal("all-messages")), + taskDiscordMessageId: Schema.optional(Schema.String), + /** In-progress Discord stream tip ids (+ stale tips). Deleted on finalize / restart cleanup. */ + streamDiscordMessageIds: Schema.optional(Schema.Array(Schema.String)), + sentDiscordUserMessageIds: Schema.optional(Schema.Array(Schema.String)), + /** + * Jira issue keys observed for this Discord thread, in first-seen order (no duplicates). + * Surfaced on the pinned thread-info message. + */ + jiraIssueKeys: Schema.optional(Schema.Array(Schema.String)), + /** + * Sentry issue URLs observed for this Discord thread, in first-seen order + * (canonical https://*.sentry.io/issues/…, no duplicates). + * Surfaced on the pinned thread-info message next to Jira — Sentry short ids + * look like Jira keys and must not be stored as jiraIssueKeys. + */ + sentryIssueUrls: Schema.optional(Schema.Array(Schema.String)), + /** + * GitHub pull request URLs observed for this Discord thread, in first-seen order + * (canonical https://github.com/owner/repo/pull/N, no duplicates). + * Surfaced on the pinned thread-info message next to Jira. + */ + prUrls: Schema.optional(Schema.Array(Schema.String)), + /** Discord message id of the pinned Model / worktree / Open in Omegent / Jira / PRs info message. */ + infoDiscordMessageId: Schema.optional(Schema.String), + /** First model used when this Discord↔T3 link was created (`instanceId/model`). */ + initialModelLine: Schema.optional(Schema.String), + /** Last known model on the linked T3 thread (`instanceId/model`). */ + currentModelLine: Schema.optional(Schema.String), + /** + * When `currentModelLine` became active if it differs from `initialModelLine` + * (ISO timestamp). Cleared when current matches initial. + */ + modelSinceAt: Schema.optional(Schema.String), +}); +export type ThreadLink = { + readonly sourceKind?: "discord" | "teams" | undefined; + readonly sourceThreadId?: string | undefined; + readonly discordThreadId: string; + readonly t3ThreadId: ThreadId; + readonly projectId: ProjectId; + readonly channelId: string; + readonly guildId: string; + readonly createdAt: string; + readonly updatedAt: string; + readonly lastActivityAt: string; + readonly status: ThreadLinkStatus; + readonly lastSeenTurnId: string | null; + readonly lastFinalizedAssistantId: string | null; + readonly lastThreadSnapshotSequence: number | null; + readonly lastDeliveredSequence: number | null; + readonly threadTalkMode?: "all-messages" | undefined; + readonly taskDiscordMessageId?: string | undefined; + readonly streamDiscordMessageIds?: ReadonlyArray | undefined; + readonly sentDiscordUserMessageIds?: ReadonlyArray | undefined; + readonly jiraIssueKeys?: ReadonlyArray | undefined; + readonly sentryIssueUrls?: ReadonlyArray | undefined; + readonly prUrls?: ReadonlyArray | undefined; + readonly infoDiscordMessageId?: string | undefined; + readonly initialModelLine?: string | undefined; + readonly currentModelLine?: string | undefined; + readonly modelSinceAt?: string | undefined; +}; + +/** Fields callers may omit on put — filled with durable defaults. */ +export type ThreadLinkInput = { + readonly sourceKind?: "discord" | "teams" | undefined; + readonly sourceThreadId?: string | undefined; + readonly discordThreadId: string; + readonly t3ThreadId: ThreadId; + readonly projectId: ProjectId; + readonly channelId: string; + readonly guildId: string; + readonly createdAt: string; + readonly updatedAt?: string; + readonly lastActivityAt?: string; + readonly status?: ThreadLinkStatus; + readonly lastSeenTurnId?: string | null; + readonly lastFinalizedAssistantId?: string | null; + readonly lastThreadSnapshotSequence?: number | null; + readonly lastDeliveredSequence?: number | null; + readonly threadTalkMode?: "all-messages" | undefined; + readonly taskDiscordMessageId?: string | undefined; + readonly streamDiscordMessageIds?: ReadonlyArray | undefined; + readonly sentDiscordUserMessageIds?: ReadonlyArray | undefined; + readonly jiraIssueKeys?: ReadonlyArray | undefined; + readonly sentryIssueUrls?: ReadonlyArray | undefined; + readonly prUrls?: ReadonlyArray | undefined; + readonly infoDiscordMessageId?: string | undefined; + readonly initialModelLine?: string | undefined; + readonly currentModelLine?: string | undefined; + readonly modelSinceAt?: string | undefined; +}; + +/** Partial durable bridge hints written while streaming / finalizing. */ +export type ThreadLinkBridgeHints = { + readonly lastSeenTurnId?: string | null; + readonly lastFinalizedAssistantId?: string | null; + readonly lastThreadSnapshotSequence?: number | null; + readonly lastDeliveredSequence?: number | null; + readonly streamDiscordMessageIds?: ReadonlyArray; +}; + +export type ThreadLinkModelHistory = { + readonly initialModelLine?: string | null | undefined; + readonly currentModelLine?: string | null | undefined; + readonly modelSinceAt?: string | null | undefined; +}; + +const LinksDocumentV2 = Schema.Struct({ + version: Schema.Literal(LINKS_DOCUMENT_VERSION), + links: Schema.Array(ThreadLink), +}); + +const decodeLinksArray = Schema.decodeUnknownSync(Schema.Array(ThreadLink)); +const decodeLinksDocumentV2 = Schema.decodeUnknownSync(LinksDocumentV2); + +/** Legacy v1 link (pre-restore fields). Extra keys are ignored by the decoder. */ +const ThreadLinkV1 = Schema.Struct({ + discordThreadId: Schema.String, + t3ThreadId: Schema.String, + projectId: Schema.String, + channelId: Schema.String, + guildId: Schema.String, + createdAt: Schema.String, + threadTalkMode: Schema.optional(Schema.Literal("all-messages")), + taskDiscordMessageId: Schema.optional(Schema.String), + streamDiscordMessageIds: Schema.optional(Schema.Array(Schema.String)), + sentDiscordUserMessageIds: Schema.optional(Schema.Array(Schema.String)), + jiraIssueKeys: Schema.optional(Schema.Array(Schema.String)), + sentryIssueUrls: Schema.optional(Schema.Array(Schema.String)), + prUrls: Schema.optional(Schema.Array(Schema.String)), + infoDiscordMessageId: Schema.optional(Schema.String), +}); +const decodeLinksV1 = Schema.decodeUnknownSync(Schema.Array(ThreadLinkV1)); + +function nowIso(): string { + return new Date().toISOString(); +} + +/** First-seen order, case-normalized uppercase, no duplicates. */ +function mergeJiraKeysOrdered( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, +): ReadonlyArray { + const result: string[] = []; + const seen = new Set(); + for (const raw of [...(existing ?? []), ...(incoming ?? [])]) { + const key = raw.trim().toUpperCase(); + if (key.length === 0 || seen.has(key)) continue; + seen.add(key); + result.push(key); + } + return result; +} + +/** + * First-seen order for GitHub PR URLs. Light normalize: trim, strip query/hash/subpaths, + * lowercase host path for dedup key. Full URL validation lives in presentation/prLinks. + */ +function mergePrUrlsOrdered( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, +): ReadonlyArray { + const result: string[] = []; + const seen = new Set(); + for (const raw of [...(existing ?? []), ...(incoming ?? [])]) { + const normalized = normalizeStoredPrUrl(raw); + if (normalized === null || seen.has(normalized)) continue; + seen.add(normalized); + result.push(normalized); + } + return result; +} + +function normalizeStoredPrUrl(raw: string): string | null { + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + const match = + /^https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/(\d+)(?:\/[^?#]*)?(?:[?#].*)?$/iu.exec( + trimmed, + ); + if (match === null) return null; + const owner = (match[1] ?? "").toLowerCase(); + const repo = (match[2] ?? "").replace(/\.git$/iu, "").toLowerCase(); + const number = match[3] ?? ""; + if (owner.length === 0 || repo.length === 0 || number.length === 0) return null; + return `https://github.com/${owner}/${repo}/pull/${number}`; +} + +function asThreadLink(link: { + readonly sourceKind?: "discord" | "teams" | undefined; + readonly sourceThreadId?: string | undefined; + readonly discordThreadId: string; + readonly t3ThreadId: string; + readonly projectId: string; + readonly channelId: string; + readonly guildId: string; + readonly createdAt: string; + readonly updatedAt: string; + readonly lastActivityAt: string; + readonly status: ThreadLinkStatus; + readonly lastSeenTurnId: string | null; + readonly lastFinalizedAssistantId: string | null; + readonly lastThreadSnapshotSequence?: number | null | undefined; + readonly lastDeliveredSequence?: number | null | undefined; + readonly threadTalkMode?: "all-messages" | undefined; + readonly taskDiscordMessageId?: string | undefined; + readonly streamDiscordMessageIds?: ReadonlyArray | undefined; + readonly sentDiscordUserMessageIds?: ReadonlyArray | undefined; + readonly jiraIssueKeys?: ReadonlyArray | undefined; + readonly sentryIssueUrls?: ReadonlyArray | undefined; + readonly prUrls?: ReadonlyArray | undefined; + readonly infoDiscordMessageId?: string | undefined; + readonly initialModelLine?: string | undefined; + readonly currentModelLine?: string | undefined; + readonly modelSinceAt?: string | undefined; +}): ThreadLink { + return { + sourceKind: link.sourceKind, + sourceThreadId: link.sourceThreadId, + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId as ThreadId, + projectId: link.projectId as ProjectId, + channelId: link.channelId, + guildId: link.guildId, + createdAt: link.createdAt, + updatedAt: link.updatedAt, + lastActivityAt: link.lastActivityAt, + status: link.status, + lastSeenTurnId: link.lastSeenTurnId, + lastFinalizedAssistantId: link.lastFinalizedAssistantId, + lastThreadSnapshotSequence: link.lastThreadSnapshotSequence ?? null, + lastDeliveredSequence: link.lastDeliveredSequence ?? null, + threadTalkMode: link.threadTalkMode, + taskDiscordMessageId: link.taskDiscordMessageId, + streamDiscordMessageIds: link.streamDiscordMessageIds, + sentDiscordUserMessageIds: link.sentDiscordUserMessageIds, + jiraIssueKeys: link.jiraIssueKeys, + sentryIssueUrls: link.sentryIssueUrls, + prUrls: link.prUrls, + infoDiscordMessageId: link.infoDiscordMessageId, + initialModelLine: link.initialModelLine, + currentModelLine: link.currentModelLine, + modelSinceAt: link.modelSinceAt, + }; +} + +/** Migrate a bare v1 array entry to full v2 shape. */ +export function migrateV1Link(link: { + readonly discordThreadId: string; + readonly t3ThreadId: string; + readonly projectId: string; + readonly channelId: string; + readonly guildId: string; + readonly createdAt: string; + readonly threadTalkMode?: "all-messages" | undefined; + readonly taskDiscordMessageId?: string | undefined; + readonly streamDiscordMessageIds?: ReadonlyArray | undefined; + readonly sentDiscordUserMessageIds?: ReadonlyArray | undefined; + readonly jiraIssueKeys?: ReadonlyArray | undefined; + readonly sentryIssueUrls?: ReadonlyArray | undefined; + readonly prUrls?: ReadonlyArray | undefined; + readonly infoDiscordMessageId?: string | undefined; + readonly initialModelLine?: string | undefined; + readonly currentModelLine?: string | undefined; + readonly modelSinceAt?: string | undefined; +}): ThreadLink { + return asThreadLink({ + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + projectId: link.projectId, + channelId: link.channelId, + guildId: link.guildId, + createdAt: link.createdAt, + updatedAt: link.createdAt, + lastActivityAt: link.createdAt, + status: "active", + lastSeenTurnId: null, + lastFinalizedAssistantId: null, + lastThreadSnapshotSequence: null, + lastDeliveredSequence: null, + threadTalkMode: link.threadTalkMode, + taskDiscordMessageId: link.taskDiscordMessageId, + streamDiscordMessageIds: link.streamDiscordMessageIds, + sentDiscordUserMessageIds: link.sentDiscordUserMessageIds, + jiraIssueKeys: link.jiraIssueKeys, + sentryIssueUrls: link.sentryIssueUrls, + prUrls: link.prUrls, + infoDiscordMessageId: link.infoDiscordMessageId, + initialModelLine: link.initialModelLine, + currentModelLine: link.currentModelLine, + modelSinceAt: link.modelSinceAt, + }); +} + +export function normalizeThreadLinkInput(link: ThreadLinkInput): ThreadLink { + const createdAt = link.createdAt; + return asThreadLink({ + sourceKind: link.sourceKind, + sourceThreadId: link.sourceThreadId, + discordThreadId: link.discordThreadId, + t3ThreadId: link.t3ThreadId, + projectId: link.projectId, + channelId: link.channelId, + guildId: link.guildId, + createdAt, + updatedAt: link.updatedAt ?? createdAt, + lastActivityAt: link.lastActivityAt ?? createdAt, + status: link.status ?? "active", + lastSeenTurnId: link.lastSeenTurnId ?? null, + lastFinalizedAssistantId: link.lastFinalizedAssistantId ?? null, + lastThreadSnapshotSequence: link.lastThreadSnapshotSequence ?? null, + lastDeliveredSequence: link.lastDeliveredSequence ?? null, + threadTalkMode: link.threadTalkMode, + taskDiscordMessageId: link.taskDiscordMessageId, + streamDiscordMessageIds: link.streamDiscordMessageIds, + sentDiscordUserMessageIds: link.sentDiscordUserMessageIds, + jiraIssueKeys: link.jiraIssueKeys, + sentryIssueUrls: link.sentryIssueUrls, + prUrls: link.prUrls, + infoDiscordMessageId: link.infoDiscordMessageId, + initialModelLine: link.initialModelLine, + currentModelLine: link.currentModelLine, + modelSinceAt: link.modelSinceAt, + }); +} + +/** + * Parse links.json (v1 bare array or v2 document). Corrupt / unknown → empty list. + * Exported for unit tests. + */ +export function parseLinksDocument(raw: unknown): { + readonly version: typeof LINKS_DOCUMENT_VERSION; + readonly links: ReadonlyArray; + readonly migratedFromV1: boolean; +} { + if (Array.isArray(raw)) { + try { + // Prefer strict v2 array decode (if someone wrote plain array of v2 objects). + try { + const v2Array = decodeLinksArray(raw); + return { + version: LINKS_DOCUMENT_VERSION, + links: v2Array.map((link) => asThreadLink(link)), + migratedFromV1: false, + }; + } catch { + const v1 = decodeLinksV1(raw); + return { + version: LINKS_DOCUMENT_VERSION, + links: v1.map(migrateV1Link), + migratedFromV1: true, + }; + } + } catch { + return { version: LINKS_DOCUMENT_VERSION, links: [], migratedFromV1: false }; + } + } + + if (raw !== null && typeof raw === "object") { + try { + const doc = decodeLinksDocumentV2(raw); + return { + version: LINKS_DOCUMENT_VERSION, + links: doc.links.map((link) => asThreadLink(link)), + migratedFromV1: false, + }; + } catch { + return { version: LINKS_DOCUMENT_VERSION, links: [], migratedFromV1: false }; + } + } + + return { version: LINKS_DOCUMENT_VERSION, links: [], migratedFromV1: false }; +} + +function serializeLinksDocument(links: ReadonlyArray): string { + return `${JSON.stringify( + { + version: LINKS_DOCUMENT_VERSION, + links: [...links], + }, + null, + 2, + )}\n`; +} + +export interface ThreadLinkStoreService { + readonly getByDiscordThreadId: (discordThreadId: string) => Effect.Effect; + readonly getByT3ThreadId: (t3ThreadId: string) => Effect.Effect; + readonly getBySourceThread: ( + sourceKind: "discord" | "teams", + sourceThreadId: string, + ) => Effect.Effect; + readonly put: (link: ThreadLinkInput) => Effect.Effect; + readonly touch: (discordThreadId: string, at?: string) => Effect.Effect; + readonly tombstone: (discordThreadId: string) => Effect.Effect; + readonly updateBridgeHints: ( + discordThreadId: string, + partial: ThreadLinkBridgeHints, + ) => Effect.Effect; + readonly setThreadTalkMode: ( + discordThreadId: string, + mode: "all-messages" | null, + ) => Effect.Effect; + readonly setTaskDiscordMessageId: ( + discordThreadId: string, + taskDiscordMessageId: string | null, + ) => Effect.Effect; + readonly setStreamDiscordMessageIds: ( + discordThreadId: string, + streamDiscordMessageIds: ReadonlyArray, + ) => Effect.Effect; + readonly setSentDiscordUserMessageIds: ( + discordThreadId: string, + sentDiscordUserMessageIds: ReadonlyArray, + ) => Effect.Effect; + /** Merge newly observed Jira keys in first-seen order (no duplicates). */ + readonly appendJiraIssueKeys: ( + discordThreadId: string, + jiraIssueKeys: ReadonlyArray, + ) => Effect.Effect; + readonly setJiraIssueKeys: ( + discordThreadId: string, + jiraIssueKeys: ReadonlyArray, + ) => Effect.Effect; + /** Merge newly observed Sentry issue URLs in first-seen order (no duplicates). */ + readonly appendSentryIssueUrls: ( + discordThreadId: string, + sentryIssueUrls: ReadonlyArray, + ) => Effect.Effect; + readonly setSentryIssueUrls: ( + discordThreadId: string, + sentryIssueUrls: ReadonlyArray, + ) => Effect.Effect; + /** Merge newly observed GitHub PR URLs in first-seen order (no duplicates). */ + readonly appendPrUrls: ( + discordThreadId: string, + prUrls: ReadonlyArray, + ) => Effect.Effect; + readonly setPrUrls: ( + discordThreadId: string, + prUrls: ReadonlyArray, + ) => Effect.Effect; + readonly setInfoDiscordMessageId: ( + discordThreadId: string, + infoDiscordMessageId: string | null, + ) => Effect.Effect; + readonly setModelHistory: ( + discordThreadId: string, + history: ThreadLinkModelHistory, + ) => Effect.Effect; + readonly list: () => Effect.Effect>; +} + +export class ThreadLinkStore extends Context.Service()( + "@t3tools/discord-bot/store/ThreadLinkStore", +) {} + +function expandHome(path: string): string { + if (path === "~") return NodeOS.homedir(); + if (path.startsWith("~/") || path.startsWith("~\\")) { + return NodePath.join(NodeOS.homedir(), path.slice(2)); + } + return path; +} + +async function atomicWriteFile(filePath: string, contents: string): Promise { + const dir = NodePath.dirname(filePath); + const tempPath = NodePath.join( + dir, + `.${NodePath.basename(filePath)}.${process.pid}.${Date.now()}.tmp`, + ); + await NodeFSP.writeFile(tempPath, contents, { mode: 0o600 }); + await NodeFSP.rename(tempPath, filePath); +} + +export const makeThreadLinkStore = (dataDirRaw: string) => + Effect.gen(function* () { + const dataDir = expandHome(dataDirRaw); + const filePath = NodePath.join(dataDir, "links.json"); + yield* Effect.promise(() => NodeFSP.mkdir(dataDir, { recursive: true, mode: 0o700 })); + + // Missing/unreadable file is fine (first run). Effect async failures are not JS throwables, + // so recover with orElseSucceed rather than try/catch around yield*. + const loaded = yield* Effect.tryPromise({ + try: () => NodeFSP.readFile(filePath, "utf8"), + catch: () => "unreadable" as const, + }).pipe( + Effect.map((raw) => { + try { + return parseLinksDocument(JSON.parse(raw) as unknown); + } catch { + return parseLinksDocument(null); + } + }), + Effect.orElseSucceed(() => parseLinksDocument(null)), + ); + + const state = yield* Ref.make( + new Map(loaded.links.map((link) => [link.discordThreadId, link] as const)), + ); + + // Persist migrated v1 → v2 so the next boot does not re-migrate. + if (loaded.migratedFromV1 && loaded.links.length > 0) { + yield* Effect.promise(() => atomicWriteFile(filePath, serializeLinksDocument(loaded.links))); + } + + const persist = (map: Map) => + Effect.promise(() => atomicWriteFile(filePath, serializeLinksDocument([...map.values()]))); + + // Serialize mutate+persist so concurrent hint writers cannot flush a stale map + // over a newer in-memory state (stream ids vs sequence marker, etc.). + const writeLock = yield* Semaphore.make(1); + + const updateLink = ( + discordThreadId: string, + mutate: (current: ThreadLink) => ThreadLink, + ): Effect.Effect => + writeLock.withPermit( + Effect.gen(function* () { + let updated: ThreadLink | null = null; + const next = yield* Ref.updateAndGet(state, (map) => { + const current = map.get(discordThreadId); + if (current === undefined) return map; + updated = mutate(current); + const copy = new Map(map); + copy.set(discordThreadId, updated); + return copy; + }); + if (updated === null) return null; + yield* persist(next); + return updated; + }), + ); + + return ThreadLinkStore.of({ + getByDiscordThreadId: (discordThreadId) => + Ref.get(state).pipe(Effect.map((map) => map.get(discordThreadId) ?? null)), + + getByT3ThreadId: (t3ThreadId) => + Ref.get(state).pipe( + Effect.map((map) => { + for (const link of map.values()) { + if (link.t3ThreadId === t3ThreadId) return link; + } + return null; + }), + ), + + getBySourceThread: (sourceKind, sourceThreadId) => + Ref.get(state).pipe( + Effect.map((map) => { + for (const link of map.values()) { + const linkSourceKind = link.sourceKind ?? "discord"; + const linkSourceThreadId = link.sourceThreadId ?? link.discordThreadId; + if (linkSourceKind === sourceKind && linkSourceThreadId === sourceThreadId) { + return link; + } + } + return null; + }), + ), + + put: (link) => + writeLock.withPermit( + Effect.gen(function* () { + const normalized = normalizeThreadLinkInput(link); + const next = yield* Ref.updateAndGet(state, (map) => { + const existing = map.get(normalized.discordThreadId); + // Preserve durable bridge hints when callers re-put a minimal link. + const merged = + existing === undefined + ? normalized + : asThreadLink({ + ...normalized, + // Never wipe durable hints on a minimal re-put (overlapping writers). + sourceKind: + link.sourceKind !== undefined ? normalized.sourceKind : existing.sourceKind, + sourceThreadId: + link.sourceThreadId !== undefined + ? normalized.sourceThreadId + : existing.sourceThreadId, + lastFinalizedAssistantId: + link.lastFinalizedAssistantId !== undefined + ? normalized.lastFinalizedAssistantId + : existing.lastFinalizedAssistantId, + lastSeenTurnId: + link.lastSeenTurnId !== undefined + ? normalized.lastSeenTurnId + : existing.lastSeenTurnId, + lastThreadSnapshotSequence: + link.lastThreadSnapshotSequence !== undefined + ? normalized.lastThreadSnapshotSequence + : existing.lastThreadSnapshotSequence, + lastDeliveredSequence: + link.lastDeliveredSequence !== undefined + ? normalized.lastDeliveredSequence + : existing.lastDeliveredSequence, + streamDiscordMessageIds: + link.streamDiscordMessageIds !== undefined + ? normalized.streamDiscordMessageIds + : existing.streamDiscordMessageIds, + taskDiscordMessageId: + link.taskDiscordMessageId !== undefined + ? normalized.taskDiscordMessageId + : existing.taskDiscordMessageId, + threadTalkMode: + link.threadTalkMode !== undefined + ? normalized.threadTalkMode + : existing.threadTalkMode, + sentDiscordUserMessageIds: + link.sentDiscordUserMessageIds !== undefined + ? normalized.sentDiscordUserMessageIds + : existing.sentDiscordUserMessageIds, + jiraIssueKeys: + link.jiraIssueKeys !== undefined + ? normalized.jiraIssueKeys + : existing.jiraIssueKeys, + sentryIssueUrls: + link.sentryIssueUrls !== undefined + ? normalized.sentryIssueUrls + : existing.sentryIssueUrls, + prUrls: link.prUrls !== undefined ? normalized.prUrls : existing.prUrls, + infoDiscordMessageId: + link.infoDiscordMessageId !== undefined + ? normalized.infoDiscordMessageId + : existing.infoDiscordMessageId, + initialModelLine: + link.initialModelLine !== undefined + ? normalized.initialModelLine + : existing.initialModelLine, + currentModelLine: + link.currentModelLine !== undefined + ? normalized.currentModelLine + : existing.currentModelLine, + modelSinceAt: + link.modelSinceAt !== undefined + ? normalized.modelSinceAt + : existing.modelSinceAt, + lastActivityAt: normalized.lastActivityAt, + updatedAt: nowIso(), + }); + const copy = new Map(map); + copy.set(merged.discordThreadId, merged); + return copy; + }); + yield* persist(next); + }), + ), + + touch: (discordThreadId, at) => { + const when = at ?? nowIso(); + return updateLink(discordThreadId, (current) => ({ + ...current, + lastActivityAt: when, + updatedAt: when, + })); + }, + + tombstone: (discordThreadId) => { + const when = nowIso(); + return updateLink(discordThreadId, (current) => ({ + ...current, + status: "tombstone", + updatedAt: when, + })); + }, + + updateBridgeHints: (discordThreadId, partial) => { + const when = nowIso(); + return updateLink(discordThreadId, (current) => ({ + ...current, + updatedAt: when, + lastActivityAt: when, + ...(partial.lastSeenTurnId !== undefined + ? { lastSeenTurnId: partial.lastSeenTurnId } + : {}), + ...(partial.lastFinalizedAssistantId !== undefined + ? { lastFinalizedAssistantId: partial.lastFinalizedAssistantId } + : {}), + ...(partial.lastThreadSnapshotSequence !== undefined + ? { lastThreadSnapshotSequence: partial.lastThreadSnapshotSequence } + : {}), + ...(partial.lastDeliveredSequence !== undefined + ? { lastDeliveredSequence: partial.lastDeliveredSequence } + : {}), + ...(partial.streamDiscordMessageIds !== undefined + ? { + streamDiscordMessageIds: + partial.streamDiscordMessageIds.length > 0 + ? [...new Set(partial.streamDiscordMessageIds.filter((id) => id.trim() !== ""))] + : undefined, + } + : {}), + })); + }, + + setThreadTalkMode: (discordThreadId, mode) => + updateLink(discordThreadId, (existing) => ({ + ...existing, + threadTalkMode: mode ?? undefined, + updatedAt: nowIso(), + })).pipe(Effect.asVoid), + + setTaskDiscordMessageId: (discordThreadId, taskDiscordMessageId) => + updateLink(discordThreadId, (existing) => ({ + ...existing, + taskDiscordMessageId: taskDiscordMessageId ?? undefined, + updatedAt: nowIso(), + })).pipe(Effect.asVoid), + + setStreamDiscordMessageIds: (discordThreadId, streamDiscordMessageIds) => { + const normalizedIds = [ + ...new Set(streamDiscordMessageIds.filter((id) => id.trim() !== "")), + ]; + return updateLink(discordThreadId, (existing) => ({ + ...existing, + streamDiscordMessageIds: normalizedIds.length > 0 ? normalizedIds : undefined, + updatedAt: nowIso(), + lastActivityAt: nowIso(), + })).pipe(Effect.asVoid); + }, + + setSentDiscordUserMessageIds: (discordThreadId, sentDiscordUserMessageIds) => { + const normalizedIds = [ + ...new Set(sentDiscordUserMessageIds.filter((id) => id.trim() !== "")), + ]; + return updateLink(discordThreadId, (existing) => ({ + ...existing, + sentDiscordUserMessageIds: normalizedIds.length > 0 ? normalizedIds : undefined, + updatedAt: nowIso(), + })).pipe(Effect.asVoid); + }, + + appendJiraIssueKeys: (discordThreadId, jiraIssueKeys) => + updateLink(discordThreadId, (existing) => { + const merged = mergeJiraKeysOrdered(existing.jiraIssueKeys, jiraIssueKeys); + if ( + merged.length === (existing.jiraIssueKeys?.length ?? 0) && + merged.every((key, index) => key === existing.jiraIssueKeys?.[index]) + ) { + return existing; + } + return { + ...existing, + jiraIssueKeys: merged.length > 0 ? merged : undefined, + updatedAt: nowIso(), + }; + }), + + setJiraIssueKeys: (discordThreadId, jiraIssueKeys) => + updateLink(discordThreadId, (existing) => { + const merged = mergeJiraKeysOrdered([], jiraIssueKeys); + return { + ...existing, + jiraIssueKeys: merged.length > 0 ? merged : undefined, + updatedAt: nowIso(), + }; + }), + + appendSentryIssueUrls: (discordThreadId, sentryIssueUrls) => + updateLink(discordThreadId, (existing) => { + const merged = mergeSentryIssueUrls(existing.sentryIssueUrls, sentryIssueUrls); + if ( + merged.length === (existing.sentryIssueUrls?.length ?? 0) && + merged.every((url, index) => url === existing.sentryIssueUrls?.[index]) + ) { + return existing; + } + return { + ...existing, + sentryIssueUrls: merged.length > 0 ? merged : undefined, + updatedAt: nowIso(), + }; + }), + + setSentryIssueUrls: (discordThreadId, sentryIssueUrls) => + updateLink(discordThreadId, (existing) => { + const merged = mergeSentryIssueUrls([], sentryIssueUrls); + return { + ...existing, + sentryIssueUrls: merged.length > 0 ? merged : undefined, + updatedAt: nowIso(), + }; + }), + + appendPrUrls: (discordThreadId, prUrls) => + updateLink(discordThreadId, (existing) => { + const merged = mergePrUrlsOrdered(existing.prUrls, prUrls); + if ( + merged.length === (existing.prUrls?.length ?? 0) && + merged.every((url, index) => url === existing.prUrls?.[index]) + ) { + return existing; + } + return { + ...existing, + prUrls: merged.length > 0 ? merged : undefined, + updatedAt: nowIso(), + }; + }), + + setPrUrls: (discordThreadId, prUrls) => + updateLink(discordThreadId, (existing) => { + const merged = mergePrUrlsOrdered([], prUrls); + return { + ...existing, + prUrls: merged.length > 0 ? merged : undefined, + updatedAt: nowIso(), + }; + }), + + setInfoDiscordMessageId: (discordThreadId, infoDiscordMessageId) => + updateLink(discordThreadId, (existing) => ({ + ...existing, + infoDiscordMessageId: infoDiscordMessageId ?? undefined, + updatedAt: nowIso(), + })).pipe(Effect.asVoid), + + setModelHistory: (discordThreadId, history) => + updateLink(discordThreadId, (existing) => ({ + ...existing, + initialModelLine: + history.initialModelLine === undefined + ? existing.initialModelLine + : (history.initialModelLine ?? undefined), + currentModelLine: + history.currentModelLine === undefined + ? existing.currentModelLine + : (history.currentModelLine ?? undefined), + modelSinceAt: + history.modelSinceAt === undefined + ? existing.modelSinceAt + : (history.modelSinceAt ?? undefined), + updatedAt: nowIso(), + })), + + list: () => Ref.get(state).pipe(Effect.map((map) => [...map.values()])), + }); + }); + +export const layer = (dataDir: string) => + Layer.effect(ThreadLinkStore, makeThreadLinkStore(dataDir)); diff --git a/apps/discord-bot/src/store/ThreadWarmCacheStore.test.ts b/apps/discord-bot/src/store/ThreadWarmCacheStore.test.ts new file mode 100644 index 000000000000..e481e335e7df --- /dev/null +++ b/apps/discord-bot/src/store/ThreadWarmCacheStore.test.ts @@ -0,0 +1,94 @@ +// @effect-diagnostics nodeBuiltinImport:off +/* oxlint-disable t3code/no-manual-effect-runtime-in-tests -- Legacy filesystem fixture uses a manually scoped runtime. */ +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as Effect from "effect/Effect"; +import { describe, expect, it as vitestIt } from "vite-plus/test"; + +import { + canResumeFromWarmThreadCache, + makeThreadWarmCacheStore, + parseWarmThreadCacheDocument, +} from "./ThreadWarmCacheStore.ts"; + +const sampleThread = { + id: "thread-1", + projectId: "project-1", + title: "Warm cache", + modelSelection: { instanceId: "grok", model: "grok-4.5" }, + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: null, + latestTurn: null, + createdAt: "2026-07-21T00:00:00.000Z", + updatedAt: "2026-07-21T00:00:00.000Z", + archivedAt: null, + deletedAt: null, + messages: [ + { + id: "a1", + role: "assistant", + text: "hello", + turnId: null, + streaming: false, + createdAt: "2026-07-21T00:00:00.000Z", + updatedAt: "2026-07-21T00:00:00.000Z", + }, + ], + proposedPlans: [], + activities: [], + checkpoints: [], + session: null, +}; + +describe("parseWarmThreadCacheDocument / canResumeFromWarmThreadCache", () => { + vitestIt("parses a valid document", () => { + const entry = parseWarmThreadCacheDocument({ + version: 1, + threadId: "thread-1", + snapshotSequence: 42, + lastFinalizedAssistantId: "a1", + updatedAt: "2026-07-21T00:00:00.000Z", + thread: sampleThread, + }); + expect(entry?.snapshotSequence).toBe(42); + expect(entry?.thread.messages).toHaveLength(1); + expect(canResumeFromWarmThreadCache(entry)).toBe(true); + }); + + vitestIt("rejects corrupt payloads", () => { + expect(parseWarmThreadCacheDocument(null)).toBeNull(); + expect(parseWarmThreadCacheDocument({ version: 1, threadId: "x" })).toBeNull(); + expect(canResumeFromWarmThreadCache(null)).toBe(false); + }); +}); + +describe("makeThreadWarmCacheStore", () => { + vitestIt("round-trips save / load / remove", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-bot-warm-")); + try { + await Effect.runPromise( + Effect.gen(function* () { + const store = yield* makeThreadWarmCacheStore(dir); + expect(yield* store.load("thread-1")).toBeNull(); + yield* store.save({ + threadId: "thread-1", + snapshotSequence: 99, + thread: sampleThread as never, + lastFinalizedAssistantId: "a1", + }); + const loaded = yield* store.load("thread-1"); + expect(loaded?.snapshotSequence).toBe(99); + expect(loaded?.lastFinalizedAssistantId).toBe("a1"); + expect(loaded?.thread.messages[0]?.id).toBe("a1"); + yield* store.remove("thread-1"); + expect(yield* store.load("thread-1")).toBeNull(); + }) as Effect.Effect, + ); + } finally { + await NodeFSP.rm(dir, { recursive: true, force: true }); + } + }); +}); diff --git a/apps/discord-bot/src/store/ThreadWarmCacheStore.ts b/apps/discord-bot/src/store/ThreadWarmCacheStore.ts new file mode 100644 index 000000000000..a0c92b800e6a --- /dev/null +++ b/apps/discord-bot/src/store/ThreadWarmCacheStore.ts @@ -0,0 +1,165 @@ +// @effect-diagnostics globalErrorInEffectCatch:off globalErrorInEffectFailure:off preferSchemaOverJson:off tryCatchInEffectGen:off missingEffectError:off nodeBuiltinImport:off globalDate:off globalRandom:off globalDateInEffect:off +/** + * Durable trimmed warm base for Discord bridge resume. + * + * Mirrors web/desktop EnvironmentCacheStore thread snapshots: keep a reduced + * OrchestrationThread + snapshotSequence on disk so restart can + * `subscribeThread({ afterSequence })` without re-downloading the full tip over HTTP. + * + * Storage: `$dataDir/thread-cache/.json` (atomic write), same dataDir as links.json. + */ +import type { OrchestrationThread, ThreadId } from "@t3tools/contracts"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; + +export const THREAD_WARM_CACHE_VERSION = 1 as const; + +export const WarmThreadCacheDocument = Schema.Struct({ + version: Schema.Literal(THREAD_WARM_CACHE_VERSION), + threadId: Schema.String, + snapshotSequence: Schema.Number, + lastFinalizedAssistantId: Schema.NullOr(Schema.String), + /** ISO timestamp of last successful write. */ + updatedAt: Schema.String, + /** + * Full OrchestrationThread JSON. Intentionally not Schema-validated field-by-field + * (contracts evolve); structural checks happen in parseWarmThreadCacheDocument. + */ + thread: Schema.Unknown, +}); +export type WarmThreadCacheDocument = typeof WarmThreadCacheDocument.Type; + +export type WarmThreadCacheEntry = { + readonly threadId: ThreadId; + readonly snapshotSequence: number; + readonly lastFinalizedAssistantId: string | null; + readonly updatedAt: string; + readonly thread: OrchestrationThread; +}; + +const decodeDocument = Schema.decodeUnknownSync(WarmThreadCacheDocument); + +function expandHome(path: string): string { + if (path === "~") return NodeOS.homedir(); + if (path.startsWith("~/")) return NodePath.join(NodeOS.homedir(), path.slice(2)); + return path; +} + +function safeThreadFileName(threadId: string): string { + // Thread ids are UUIDs / opaque tokens; strip path separators just in case. + return `${threadId.replaceAll(/[/\\]/gu, "_")}.json`; +} + +export function parseWarmThreadCacheDocument(raw: unknown): WarmThreadCacheEntry | null { + try { + const doc = decodeDocument(raw); + const thread = doc.thread as OrchestrationThread | null; + if (thread === null || typeof thread !== "object") return null; + if (typeof (thread as { id?: unknown }).id !== "string") return null; + if (!Array.isArray((thread as { messages?: unknown }).messages)) return null; + if (!Number.isFinite(doc.snapshotSequence) || doc.snapshotSequence < 0) return null; + return { + threadId: doc.threadId as ThreadId, + snapshotSequence: doc.snapshotSequence, + lastFinalizedAssistantId: doc.lastFinalizedAssistantId, + updatedAt: doc.updatedAt, + thread, + }; + } catch { + return null; + } +} + +/** + * Whether a warm cache entry can seed subscribe without HTTP. + * Requires a finite sequence (same bar as dual-cursor afterSequence). + */ +export function canResumeFromWarmThreadCache(entry: WarmThreadCacheEntry | null): boolean { + return entry !== null && Number.isFinite(entry.snapshotSequence) && entry.snapshotSequence >= 0; +} + +async function atomicWriteFile(filePath: string, contents: string): Promise { + const dir = NodePath.dirname(filePath); + await NodeFSP.mkdir(dir, { recursive: true, mode: 0o700 }); + const tempPath = NodePath.join( + dir, + `.${NodePath.basename(filePath)}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`, + ); + await NodeFSP.writeFile(tempPath, contents, { mode: 0o600 }); + await NodeFSP.rename(tempPath, filePath); +} + +export interface ThreadWarmCacheStoreService { + readonly load: (threadId: ThreadId | string) => Effect.Effect; + readonly save: (input: { + readonly threadId: ThreadId | string; + readonly snapshotSequence: number; + readonly thread: OrchestrationThread; + readonly lastFinalizedAssistantId?: string | null; + }) => Effect.Effect; + readonly remove: (threadId: ThreadId | string) => Effect.Effect; +} + +export class ThreadWarmCacheStore extends Context.Service< + ThreadWarmCacheStore, + ThreadWarmCacheStoreService +>()("@t3tools/discord-bot/store/ThreadWarmCacheStore") {} + +export const makeThreadWarmCacheStore = (dataDirRaw: string) => + Effect.gen(function* () { + const dataDir = expandHome(dataDirRaw); + const cacheDir = NodePath.join(dataDir, "thread-cache"); + yield* Effect.promise(() => NodeFSP.mkdir(cacheDir, { recursive: true, mode: 0o700 })); + const writeLock = yield* Semaphore.make(1); + + const pathFor = (threadId: string) => NodePath.join(cacheDir, safeThreadFileName(threadId)); + + return ThreadWarmCacheStore.of({ + load: (threadId) => + Effect.tryPromise({ + try: async () => { + const raw = await NodeFSP.readFile(pathFor(String(threadId)), "utf8"); + return parseWarmThreadCacheDocument(JSON.parse(raw) as unknown); + }, + catch: () => null as WarmThreadCacheEntry | null, + }).pipe(Effect.orElseSucceed(() => null)), + + save: (input) => + writeLock.withPermit( + Effect.gen(function* () { + if (!Number.isFinite(input.snapshotSequence) || input.snapshotSequence < 0) { + return; + } + const doc: WarmThreadCacheDocument = { + version: THREAD_WARM_CACHE_VERSION, + threadId: String(input.threadId), + snapshotSequence: input.snapshotSequence, + lastFinalizedAssistantId: input.lastFinalizedAssistantId ?? null, + updatedAt: new Date().toISOString(), + thread: input.thread, + }; + const body = `${JSON.stringify(doc)}\n`; + yield* Effect.promise(() => atomicWriteFile(pathFor(String(input.threadId)), body)); + }), + ), + + remove: (threadId) => + Effect.tryPromise({ + try: () => NodeFSP.unlink(pathFor(String(threadId))), + catch: () => undefined, + }).pipe( + Effect.asVoid, + Effect.orElseSucceed(() => undefined), + Effect.asVoid, + ), + }); + }); + +export const layer = (dataDir: string) => + Layer.effect(ThreadWarmCacheStore, makeThreadWarmCacheStore(dataDir)); diff --git a/apps/discord-bot/src/t3/DiscordThreadFollower.test.ts b/apps/discord-bot/src/t3/DiscordThreadFollower.test.ts new file mode 100644 index 000000000000..e4134f5efa01 --- /dev/null +++ b/apps/discord-bot/src/t3/DiscordThreadFollower.test.ts @@ -0,0 +1,126 @@ +import { describe, expect, it } from "vite-plus/test"; +import type { OrchestrationThread, OrchestrationThreadStreamItem } from "@t3tools/contracts"; + +import { + applyDiscordThreadStreamItem, + initialDiscordThreadFollowerState, + planThreadFollowerReconnectSeed, +} from "./DiscordThreadFollower.ts"; + +const baseThread = (overrides?: Partial): OrchestrationThread => + ({ + id: "thread-1", + projectId: "project-1", + title: "t", + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + messages: [], + activities: [], + proposedPlans: [], + checkpoints: [], + latestTurn: null, + session: null, + worktreePath: null, + modelSelection: null, + ...overrides, + }) as OrchestrationThread; + +describe("planThreadFollowerReconnectSeed", () => { + it("replays warm tip only on the first seed this process", () => { + expect(planThreadFollowerReconnectSeed({ lastAppliedSequence: -1, hasWarmSeed: true })).toBe( + "replay-warm", + ); + expect(planThreadFollowerReconnectSeed({ lastAppliedSequence: -1, hasWarmSeed: false })).toBe( + "http-or-cold", + ); + }); + + it("resumes after disconnect without replaying warm tip (no old finals at tip)", () => { + // Production: SocketClose re-ran deliver(warmSeed) with a stale in-memory tip and + // re-finalized Done.PR #156 after newer Discord turns. + expect( + planThreadFollowerReconnectSeed({ lastAppliedSequence: 104286, hasWarmSeed: true }), + ).toBe("resume-after"); + expect(planThreadFollowerReconnectSeed({ lastAppliedSequence: 0, hasWarmSeed: false })).toBe( + "resume-after", + ); + }); +}); + +describe("applyDiscordThreadStreamItem (client-runtime parity)", () => { + it("applies embedded snapshots and advances sequence", () => { + const thread = baseThread({ title: "from-snapshot" }); + const item: OrchestrationThreadStreamItem = { + kind: "snapshot", + snapshot: { snapshotSequence: 10, thread }, + }; + const result = applyDiscordThreadStreamItem(initialDiscordThreadFollowerState(), item); + expect(result._tag).toBe("deliver"); + if (result._tag === "deliver") { + expect(result.sequence).toBe(10); + expect(result.thread.title).toBe("from-snapshot"); + expect(result.state.lastSequence).toBe(10); + } + }); + + it("drops duplicate / older sequences", () => { + const thread = baseThread(); + const state = initialDiscordThreadFollowerState({ + current: thread, + lastSequence: 5, + }); + const item: OrchestrationThreadStreamItem = { + kind: "event", + event: { + type: "thread.title-updated", + sequence: 5, + threadId: "thread-1", + title: "nope", + } as OrchestrationThreadStreamItem extends { kind: "event"; event: infer E } ? E : never, + }; + const result = applyDiscordThreadStreamItem(state, item); + expect(result._tag).toBe("none"); + expect(result.state.lastSequence).toBe(5); + }); + + it("requests reload when an event arrives without a transcript", () => { + const item: OrchestrationThreadStreamItem = { + kind: "event", + event: { + type: "thread.title-updated", + sequence: 1, + threadId: "thread-1", + title: "x", + } as never, + }; + const result = applyDiscordThreadStreamItem(initialDiscordThreadFollowerState(), item); + expect(result._tag).toBe("reload-required"); + }); + + it("applies thread.deleted via client-runtime reducer", () => { + const state = initialDiscordThreadFollowerState({ + current: baseThread(), + lastSequence: 1, + }); + const item: OrchestrationThreadStreamItem = { + kind: "event", + event: { + type: "thread.deleted", + sequence: 2, + occurredAt: "2026-04-01T02:00:00.000Z", + aggregateKind: "thread", + aggregateId: "thread-1", + payload: { + threadId: "thread-1", + deletedAt: "2026-04-01T02:00:00.000Z", + }, + } as never, + }; + const result = applyDiscordThreadStreamItem(state, item); + expect(result._tag).toBe("deleted"); + if (result._tag === "deleted") { + expect(result.state.current).toBeNull(); + expect(result.state.lastSequence).toBe(2); + } + }); +}); diff --git a/apps/discord-bot/src/t3/DiscordThreadFollower.ts b/apps/discord-bot/src/t3/DiscordThreadFollower.ts new file mode 100644 index 000000000000..f236a0f1bf04 --- /dev/null +++ b/apps/discord-bot/src/t3/DiscordThreadFollower.ts @@ -0,0 +1,390 @@ +// @effect-diagnostics anyUnknownInErrorContext:off missingEffectError:off +/** + * Headless orchestration-thread follower for the Discord bot. + * + * Intentionally mirrors packages/client-runtime EnvironmentThreadState apply/reload + * semantics (sequence cursor, snapshot seed, reload-required → HTTP) without pulling + * in EnvironmentSupervisor / Atom / React. Core packages stay untouched; Discord only + * adapts the same reducer + transport patterns clients already use. + * + * Source of truth for event application: `applyThreadDetailEvent` from + * `@t3tools/client-runtime/state/threads` (re-export of threadReducer). + * + * Discord-specific projection (ResponseBridge tips / finalize) sits *on top* of this + * follower — same split as web: runtime holds OrchestrationThread, UI/surface paints it. + */ + +import type { + OrchestrationThread, + OrchestrationThreadDetailSnapshot, + OrchestrationThreadStreamItem, +} from "@t3tools/contracts"; +import { applyThreadDetailEvent } from "@t3tools/client-runtime/state/threads"; +import * as Effect from "effect/Effect"; +import * as Result from "effect/Result"; +import * as Stream from "effect/Stream"; + +import { formatAlertCause } from "../features/Alerts.ts"; + +/** Same short retry clients use for expected stream failures (`retryExpectedFailureAfter`). */ +export const DISCORD_THREAD_SUBSCRIBE_RETRY_DELAY = "250 millis" as const; + +/** Cap reconnect backoff when the whole subscription dies (session drop, etc.). */ +export const DISCORD_THREAD_SUBSCRIBE_MAX_BACKOFF = "30 seconds" as const; + +/** + * How to seed the follower after a transport death. + * + * - `resume-after` — we already applied a tip this process; only WS after lastSequence + * (do **not** re-deliver a stale in-memory warm tip — that re-finalized old Discord posts). + * - `replay-warm` — first seed this process; paint durable warm tip once. + * - `http-or-cold` — no warm tip; HTTP snapshot or wait for stream. + */ +export type ThreadFollowerReconnectSeedPlan = "resume-after" | "replay-warm" | "http-or-cold"; + +export function planThreadFollowerReconnectSeed(input: { + /** Last sequence successfully applied this process (−1 = never). */ + readonly lastAppliedSequence: number; + readonly hasWarmSeed: boolean; +}): ThreadFollowerReconnectSeedPlan { + if (Number.isFinite(input.lastAppliedSequence) && input.lastAppliedSequence >= 0) { + return "resume-after"; + } + if (input.hasWarmSeed) return "replay-warm"; + return "http-or-cold"; +} + +export type DiscordThreadFollowerState = { + readonly current: OrchestrationThread | null; + /** Last applied snapshot/event sequence (−1 = no base yet). */ + readonly lastSequence: number; +}; + +export type DiscordThreadFollowerApplyResult = + | { + readonly _tag: "deliver"; + readonly state: DiscordThreadFollowerState; + readonly thread: OrchestrationThread; + readonly sequence: number; + } + | { + readonly _tag: "none"; + readonly state: DiscordThreadFollowerState; + } + | { + readonly _tag: "deleted"; + readonly state: DiscordThreadFollowerState; + readonly sequence: number; + } + | { + readonly _tag: "reload-required"; + readonly state: DiscordThreadFollowerState; + readonly sequence: number; + readonly eventType: string; + }; + +export function initialDiscordThreadFollowerState( + seed?: Partial, +): DiscordThreadFollowerState { + return { + current: seed?.current ?? null, + lastSequence: seed?.lastSequence ?? -1, + }; +} + +/** + * Pure apply step — parity with EnvironmentThreadState.applyItem + * (packages/client-runtime/src/state/threads.ts). + */ +export function applyDiscordThreadStreamItem( + state: DiscordThreadFollowerState, + item: OrchestrationThreadStreamItem, +): DiscordThreadFollowerApplyResult { + if (item.kind === "snapshot") { + const sequence = item.snapshot.snapshotSequence; + const thread = item.snapshot.thread; + return { + _tag: "deliver", + state: { current: thread, lastSequence: sequence }, + thread, + sequence, + }; + } + + if (item.kind === "synchronized") { + return { _tag: "none", state }; + } + + const sequence = item.event.sequence; + if (sequence <= state.lastSequence) { + return { _tag: "none", state }; + } + + if (state.current === null) { + // Event before we hold a transcript — caller must HTTP-seed (same as client). + return { + _tag: "reload-required", + state: { ...state, lastSequence: sequence }, + sequence, + eventType: item.event.type, + }; + } + + const result = applyThreadDetailEvent(state.current, item.event); + if (result.kind === "updated") { + return { + _tag: "deliver", + state: { current: result.thread, lastSequence: sequence }, + thread: result.thread, + sequence, + }; + } + if (result.kind === "deleted") { + return { + _tag: "deleted", + state: { current: null, lastSequence: sequence }, + sequence, + }; + } + if (result.kind === "reload-required") { + return { + _tag: "reload-required", + state: { ...state, lastSequence: sequence }, + sequence, + eventType: item.event.type, + }; + } + // unchanged — advance sequence so we do not re-apply + return { + _tag: "none", + state: { ...state, lastSequence: sequence }, + }; +} + +export type FollowOrchestrationThreadInput = { + readonly threadId: string; + /** + * Open a WS subscribeThread stream. May end with failure (transport drop); + * the follower retries. + */ + readonly openStream: (input: { + readonly afterSequence: number | undefined; + }) => Stream.Stream; + /** HTTP full snapshot — used for resume seed + reload-required when warm seed missing. */ + readonly fetchSnapshot: () => Effect.Effect; + readonly onThread: (thread: OrchestrationThread) => Effect.Effect; + /** + * Durable cursor. With no warmSeed: HTTP-seed then WS afterSequence (cold/HTTP path). + * With warmSeed: ignored for seed base; warmSeed.snapshotSequence drives afterSequence. + */ + readonly afterSequence?: number | null; + /** + * Durable trimmed tip (web/desktop EnvironmentCacheStore-style). When set, skips HTTP + * full-tip download and resumes via afterSequence from this base. + */ + readonly warmSeed?: { + readonly snapshotSequence: number; + readonly thread: OrchestrationThread; + } | null; + /** + * Optional projection applied before onThread and retained as the apply base + * (e.g. drop Discord-finalized messages beyond a small buffer). + */ + readonly projectThread?: (thread: OrchestrationThread) => OrchestrationThread; + readonly onSequence?: (sequence: number) => Effect.Effect; + /** + * When true (default), reconnect forever with backoff — matches client durable + * subscription intent. Set false for tests / one-shot. + */ + readonly retryForever?: boolean; +}; + +/** + * Follow a thread the way other T3 clients do: seed snapshot, apply events in order, + * reload on reload-required, retry the subscription on transport death. + */ +export function followOrchestrationThread( + input: FollowOrchestrationThreadInput, +): Effect.Effect { + const retryForever = input.retryForever !== false; + const noteSequence = (sequence: number) => + input.onSequence === undefined + ? Effect.void + : input.onSequence(sequence).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to persist thread sequence marker", { + threadId: input.threadId, + sequence, + cause: formatAlertCause(cause, 300), + }), + ), + ); + + const projectThread = input.projectThread; + const warmSeed = input.warmSeed ?? null; + const hasWarmSeed = + warmSeed !== null && + Number.isFinite(warmSeed.snapshotSequence) && + warmSeed.snapshotSequence >= 0; + + const deliver = (thread: OrchestrationThread, sequence: number) => + Effect.gen(function* () { + // Project first so the retained apply base matches what Discord keeps in memory. + const projected = projectThread !== undefined ? projectThread(thread) : thread; + yield* noteSequence(sequence); + yield* input.onThread(projected).pipe( + Effect.catchCause((cause) => + Effect.logError("Thread follower onThread failed", { + threadId: input.threadId, + cause: formatAlertCause(cause), + }), + ), + ); + return projected; + }); + + // Retained across SocketClose retries so we never re-paint Discord from a stale + // in-memory warmSeed after the tip has already been applied this process. + let resumeState: DiscordThreadFollowerState | null = null; + + const runOnce = Effect.gen(function* () { + const seedPlan = planThreadFollowerReconnectSeed({ + lastAppliedSequence: resumeState?.lastSequence ?? -1, + hasWarmSeed, + }); + + let state = + seedPlan === "resume-after" && resumeState !== null + ? resumeState + : initialDiscordThreadFollowerState(); + let subscribeAfter: number | undefined = + seedPlan === "resume-after" && resumeState !== null && resumeState.lastSequence >= 0 + ? resumeState.lastSequence + : input.afterSequence !== undefined && + input.afterSequence !== null && + Number.isFinite(input.afterSequence) && + input.afterSequence >= 0 + ? input.afterSequence + : undefined; + + if (seedPlan === "replay-warm" && warmSeed !== null) { + // First seed this process only — durable tip + afterSequence, no HTTP. + const projected = yield* deliver(warmSeed.thread, warmSeed.snapshotSequence); + state = { + current: projected, + lastSequence: warmSeed.snapshotSequence, + }; + resumeState = state; + subscribeAfter = warmSeed.snapshotSequence; + yield* Effect.logInfo("Thread follower seeding from durable warm cache", { + threadId: input.threadId, + snapshotSequence: warmSeed.snapshotSequence, + messageCount: projected.messages.length, + }); + } else if (seedPlan === "resume-after") { + yield* Effect.logInfo("Thread follower resuming after disconnect (skip warm re-seed)", { + threadId: input.threadId, + afterSequence: subscribeAfter ?? null, + lastSequence: resumeState?.lastSequence ?? null, + }); + } else if (seedPlan === "http-or-cold" && subscribeAfter !== undefined) { + // HTTP base snapshot, then events after that sequence. + const seed = yield* input.fetchSnapshot(); + if (seed !== null) { + const projected = yield* deliver(seed.thread, seed.snapshotSequence); + state = { + current: projected, + lastSequence: seed.snapshotSequence, + }; + resumeState = state; + subscribeAfter = seed.snapshotSequence; + } else { + subscribeAfter = undefined; + state = initialDiscordThreadFollowerState(); + } + } + + yield* input.openStream({ afterSequence: subscribeAfter }).pipe( + Stream.runForEach((item) => + Effect.gen(function* () { + let applied = applyDiscordThreadStreamItem(state, item); + + if (applied._tag === "reload-required") { + yield* Effect.logWarning( + "Thread event requires snapshot reload; fetching HTTP thread snapshot", + { + threadId: input.threadId, + eventType: applied.eventType, + sequence: applied.sequence, + }, + ); + const fresh = yield* input.fetchSnapshot(); + if (fresh === null) { + // Keep last known current; skip corrupt apply (client leaves state in place). + state = applied.state; + resumeState = state; + return; + } + const sequence = Math.max(fresh.snapshotSequence, applied.sequence); + const projected = yield* deliver(fresh.thread, sequence); + state = { + current: projected, + lastSequence: sequence, + }; + resumeState = state; + return; + } + + if (applied._tag === "deliver") { + const projected = yield* deliver(applied.thread, applied.sequence); + state = { + current: projected, + lastSequence: applied.sequence, + }; + resumeState = state; + } else if (applied._tag === "deleted") { + state = applied.state; + resumeState = state; + yield* noteSequence(applied.sequence); + } else { + state = applied.state; + resumeState = state; + } + }), + ), + ); + }); + + if (!retryForever) { + // One-shot / test path. The retry branch below inspects failures via + // `Effect.result` and loops; the one-shot path has no retry loop, so surface a + // terminal stream failure as a defect rather than swallowing it. + return runOnce.pipe(Effect.orDie); + } + + return Effect.gen(function* () { + let attempt = 0; + while (true) { + attempt += 1; + const outcome = yield* runOnce.pipe(Effect.result); + if (Result.isSuccess(outcome)) { + return; + } + const pretty = formatAlertCause(outcome.failure); + yield* Effect.logError("Orchestration thread subscription ended; resubscribing", { + threadId: input.threadId, + attempt, + cause: pretty, + resumeAfterSequence: resumeState?.lastSequence ?? null, + seedPlan: planThreadFollowerReconnectSeed({ + lastAppliedSequence: resumeState?.lastSequence ?? -1, + hasWarmSeed, + }), + }); + // Do not re-deliver warm/HTTP tips between attempts when we already applied a + // sequence — runOnce will resume WS only. Cold path still HTTP-seeds on next runOnce. + const delayMs = Math.min(30_000, 250 * 2 ** Math.min(attempt - 1, 7)); + yield* Effect.sleep(`${delayMs} millis`); + } + }); +} diff --git a/apps/discord-bot/src/t3/PersistedBearer.test.ts b/apps/discord-bot/src/t3/PersistedBearer.test.ts new file mode 100644 index 000000000000..5533b9332681 --- /dev/null +++ b/apps/discord-bot/src/t3/PersistedBearer.test.ts @@ -0,0 +1,114 @@ +// @effect-diagnostics nodeBuiltinImport:off globalDate:off +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { describe, expect, it } from "vite-plus/test"; + +import { + clearPersistedBearerSession, + parsePersistedBearerSession, + persistedBearerExpiresAtIso, + readPersistedBearerSession, + shouldReusePersistedBearer, + writePersistedBearerSession, +} from "./PersistedBearer.ts"; + +describe("shouldReusePersistedBearer", () => { + const nowMs = Date.parse("2026-08-20T06:00:00.000Z"); + const record = { + accessToken: "tok", + expiresAt: "2026-09-19T06:00:00.000Z", + httpBaseUrl: "http://127.0.0.1:3773/", + }; + + it("reuses a same-host token with more than an hour remaining", () => { + expect( + shouldReusePersistedBearer({ + record, + nowMs, + httpBaseUrl: "http://127.0.0.1:3773", + }), + ).toBe(true); + }); + + it("rejects a token for a different T3 host", () => { + expect( + shouldReusePersistedBearer({ + record, + nowMs, + httpBaseUrl: "http://127.0.0.1:9999", + }), + ).toBe(false); + }); + + it("rejects a token inside the remaining-time floor", () => { + expect( + shouldReusePersistedBearer({ + record: { ...record, expiresAt: "2026-08-20T06:30:00.000Z" }, + nowMs, + httpBaseUrl: record.httpBaseUrl, + }), + ).toBe(false); + }); + + it("rejects an empty token", () => { + expect( + shouldReusePersistedBearer({ + record: { ...record, accessToken: " " }, + nowMs, + httpBaseUrl: record.httpBaseUrl, + }), + ).toBe(false); + }); +}); + +describe("parsePersistedBearerSession", () => { + it("accepts a well-formed document", () => { + expect( + parsePersistedBearerSession({ + accessToken: "tok", + expiresAt: "2026-09-19T06:00:00.000Z", + httpBaseUrl: "http://127.0.0.1:3773/", + }), + ).toEqual({ + accessToken: "tok", + expiresAt: "2026-09-19T06:00:00.000Z", + httpBaseUrl: "http://127.0.0.1:3773/", + }); + }); + + it("rejects missing fields and bad expiry", () => { + expect(parsePersistedBearerSession({ accessToken: "tok" })).toBeNull(); + expect( + parsePersistedBearerSession({ + accessToken: "tok", + expiresAt: "not-a-date", + httpBaseUrl: "http://127.0.0.1:3773/", + }), + ).toBeNull(); + expect(parsePersistedBearerSession("tok")).toBeNull(); + }); +}); + +describe("persisted bearer file", () => { + it("round-trips and clears a session on disk", () => { + const dataDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-discord-bearer-")); + try { + expect(readPersistedBearerSession(dataDir)).toBeNull(); + writePersistedBearerSession(dataDir, { + accessToken: "tok-1", + expiresAt: persistedBearerExpiresAtIso(Date.parse("2026-08-20T06:00:00.000Z"), 3600), + httpBaseUrl: "http://127.0.0.1:3773/", + }); + expect(readPersistedBearerSession(dataDir)).toEqual({ + accessToken: "tok-1", + expiresAt: "2026-08-20T07:00:00.000Z", + httpBaseUrl: "http://127.0.0.1:3773/", + }); + clearPersistedBearerSession(dataDir); + expect(readPersistedBearerSession(dataDir)).toBeNull(); + } finally { + NodeFS.rmSync(dataDir, { recursive: true, force: true }); + } + }); +}); diff --git a/apps/discord-bot/src/t3/PersistedBearer.ts b/apps/discord-bot/src/t3/PersistedBearer.ts new file mode 100644 index 000000000000..d5ccabfa2ab8 --- /dev/null +++ b/apps/discord-bot/src/t3/PersistedBearer.ts @@ -0,0 +1,97 @@ +// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off globalDate:off +/** + * Durable T3 bearer for the Discord bot. + * + * Bootstrap (`local-bootstrap-credential`) is exchanged for a 30-day session + * token. Persist that token so a bot restart does not need the in-memory + * bootstrap grant still to be valid. + */ +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; +import * as Schema from "effect/Schema"; + +import { expandHomePath } from "../projectAliases.ts"; + +export const PERSISTED_BEARER_FILENAME = "t3-bearer.json"; + +/** Re-bootstrap when less than this remains on the stored session. */ +export const PERSISTED_BEARER_MIN_REMAINING_MS = 60 * 60 * 1000; + +export const PersistedBearerSession = Schema.Struct({ + accessToken: Schema.String, + expiresAt: Schema.String, + httpBaseUrl: Schema.String, +}); +export type PersistedBearerSession = typeof PersistedBearerSession.Type; + +const decodePersistedBearerSession = Schema.decodeUnknownSync(PersistedBearerSession); + +export function persistedBearerFilePath(dataDir: string): string { + return NodePath.join(expandHomePath(dataDir), PERSISTED_BEARER_FILENAME); +} + +export function normalizeHttpBaseUrl(value: string): string { + try { + return new URL(value).toString(); + } catch { + return value; + } +} + +export function persistedBearerExpiresAtIso(nowMs: number, expiresInSeconds: number): string { + const ttlMs = Math.max(0, expiresInSeconds) * 1000; + return new Date(nowMs + ttlMs).toISOString(); +} + +export function parsePersistedBearerSession(raw: unknown): PersistedBearerSession | null { + try { + const decoded = decodePersistedBearerSession(raw); + if (decoded.accessToken.trim() === "" || decoded.httpBaseUrl.trim() === "") return null; + if (!Number.isFinite(Date.parse(decoded.expiresAt))) return null; + return decoded; + } catch { + return null; + } +} + +export function shouldReusePersistedBearer(input: { + readonly record: Pick; + readonly nowMs: number; + readonly httpBaseUrl: string; + readonly minRemainingMs?: number; +}): boolean { + if (input.record.accessToken.trim() === "") return false; + if (normalizeHttpBaseUrl(input.record.httpBaseUrl) !== normalizeHttpBaseUrl(input.httpBaseUrl)) { + return false; + } + const expiresAtMs = Date.parse(input.record.expiresAt); + if (!Number.isFinite(expiresAtMs)) return false; + const minRemaining = input.minRemainingMs ?? PERSISTED_BEARER_MIN_REMAINING_MS; + return expiresAtMs - input.nowMs >= minRemaining; +} + +export function readPersistedBearerSession(dataDir: string): PersistedBearerSession | null { + try { + const raw = NodeFS.readFileSync(persistedBearerFilePath(dataDir), "utf8"); + return parsePersistedBearerSession(JSON.parse(raw) as unknown); + } catch { + return null; + } +} + +export function writePersistedBearerSession(dataDir: string, record: PersistedBearerSession): void { + const filePath = persistedBearerFilePath(dataDir); + const dir = NodePath.dirname(filePath); + NodeFS.mkdirSync(dir, { recursive: true, mode: 0o700 }); + const tempPath = `${filePath}.${process.pid}.tmp`; + NodeFS.writeFileSync(tempPath, `${JSON.stringify(record)}\n`, { mode: 0o600 }); + NodeFS.renameSync(tempPath, filePath); +} + +export function clearPersistedBearerSession(dataDir: string): void { + try { + NodeFS.unlinkSync(persistedBearerFilePath(dataDir)); + } catch { + // missing is the desired end state + } +} diff --git a/apps/discord-bot/src/t3/T3Session.test.ts b/apps/discord-bot/src/t3/T3Session.test.ts new file mode 100644 index 000000000000..f7d6be54a150 --- /dev/null +++ b/apps/discord-bot/src/t3/T3Session.test.ts @@ -0,0 +1,132 @@ +// @effect-diagnostics nodeBuiltinImport:off - existence contract reads T3Session source on disk. +import * as NodeFS from "node:fs"; +import { ProviderInstanceId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + isT3InvalidCredentialError, + isT3TransportError, + shouldContinueWaitingForT3Ready, + shouldPersistThreadModelSelectionForNextTurn, + T3_STILL_CONNECTING_MESSAGE, +} from "./T3Session.ts"; + +const t3SessionSource = NodeFS.readFileSync(new URL("./T3Session.ts", import.meta.url), "utf8"); + +describe("isT3TransportError", () => { + it("matches SocketCloseError and ConnectionTransientError", () => { + expect(isT3TransportError(new Error("SocketCloseError: 1005"))).toBe(true); + expect(isT3TransportError(new Error("ConnectionTransientError: closed"))).toBe(true); + expect(isT3TransportError(new Error("SocketError: reset"))).toBe(true); + }); + + it("matches common network errno strings", () => { + expect(isT3TransportError(new Error("connect ECONNREFUSED 127.0.0.1:3773"))).toBe(true); + expect(isT3TransportError(new Error("read ECONNRESET"))).toBe(true); + }); + + it("does not match ordinary application errors", () => { + expect(isT3TransportError(new Error("No T3 project registered at /tmp/x"))).toBe(false); + expect(isT3TransportError(new Error(T3_STILL_CONNECTING_MESSAGE))).toBe(false); + }); +}); + +describe("isT3InvalidCredentialError", () => { + it("matches bootstrap/bearer rejection copy", () => { + expect( + isT3InvalidCredentialError( + new Error( + "Bootstrap failed: The environment rejected this client's credentials (invalid_credential).", + ), + ), + ).toBe(true); + expect(isT3InvalidCredentialError(new Error('reason: "invalid_credential"'))).toBe(true); + }); + + it("does not match transport or timeout copy", () => { + expect(isT3InvalidCredentialError(new Error("SocketCloseError: 1005"))).toBe(false); + expect(isT3InvalidCredentialError(new Error(T3_STILL_CONNECTING_MESSAGE))).toBe(false); + }); +}); + +describe("persisted T3 bearer", () => { + it("reuses a stored bearer on connect and falls back to bootstrap when rejected", () => { + expect(t3SessionSource).toContain("readPersistedBearerSession(botConfig.dataDir)"); + expect(t3SessionSource).toContain("shouldReusePersistedBearer({"); + expect(t3SessionSource).toContain("writePersistedBearerSession(botConfig.dataDir"); + expect(t3SessionSource).toContain("Persisted T3 bearer rejected; falling back to bootstrap"); + expect(t3SessionSource).toContain("clearPersistedBearerSession(botConfig.dataDir)"); + }); +}); + +describe("shouldContinueWaitingForT3Ready", () => { + it("returns ready as soon as the shell is live", () => { + expect(shouldContinueWaitingForT3Ready({ ready: true, elapsedMs: 0, timeoutMs: 1_000 })).toBe( + "ready", + ); + expect( + shouldContinueWaitingForT3Ready({ ready: true, elapsedMs: 5_000, timeoutMs: 1_000 }), + ).toBe("ready"); + }); + + it("keeps waiting until the timeout elapses", () => { + expect(shouldContinueWaitingForT3Ready({ ready: false, elapsedMs: 0, timeoutMs: 1_000 })).toBe( + "wait", + ); + expect( + shouldContinueWaitingForT3Ready({ ready: false, elapsedMs: 999, timeoutMs: 1_000 }), + ).toBe("wait"); + }); + + it("times out once elapsed reaches the deadline", () => { + expect( + shouldContinueWaitingForT3Ready({ ready: false, elapsedMs: 1_000, timeoutMs: 1_000 }), + ).toBe("timeout"); + expect( + shouldContinueWaitingForT3Ready({ ready: false, elapsedMs: 5_000, timeoutMs: 1_000 }), + ).toBe("timeout"); + }); +}); + +describe("shouldPersistThreadModelSelectionForNextTurn", () => { + it("returns false when no explicit model selection is provided", () => { + expect( + shouldPersistThreadModelSelectionForNextTurn({ + currentModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + }), + ).toBe(false); + }); + + it("returns true when the model changes", () => { + expect( + shouldPersistThreadModelSelectionForNextTurn({ + currentModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + nextModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.5", + }, + }), + ).toBe(true); + }); + + it("returns false when the model selection is unchanged", () => { + expect( + shouldPersistThreadModelSelectionForNextTurn({ + currentModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.5", + }, + nextModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.5", + }, + }), + ).toBe(false); + }); +}); diff --git a/apps/discord-bot/src/t3/T3Session.ts b/apps/discord-bot/src/t3/T3Session.ts new file mode 100644 index 000000000000..92c974f1eab9 --- /dev/null +++ b/apps/discord-bot/src/t3/T3Session.ts @@ -0,0 +1,1196 @@ +// @effect-diagnostics globalDate:off globalFetch:off globalFetchInEffect:off globalTimers:off globalErrorInEffectCatch:off globalErrorInEffectFailure:off anyUnknownInErrorContext:off missingEffectContext:off missingEffectError:off preferSchemaOverJson:off tryCatchInEffectGen:off deterministicKeys:off +import { + ApprovalRequestId, + DEFAULT_RUNTIME_MODE, + EnvironmentId, + ORCHESTRATION_WS_METHODS, + PRIMARY_LOCAL_ENVIRONMENT_ID, + ProjectId, + WS_METHODS, + type ClientOrchestrationCommand, + type MessageId, + type ModelSelection, + type OrchestrationProjectShell, + type OrchestrationShellSnapshot, + type OrchestrationThread, + type OrchestrationThreadDetailSnapshot, + type OrchestrationThreadShell, + type ProviderApprovalDecision, + type ProviderInteractionMode, + type ProviderUserInputAnswers, + type RuntimeMode, + type ServerConfig, + type ServerProvider, + type ThreadId, + type UploadChatAttachment, + type VcsResolveBranchChangeRequestResult, + type VcsStatusStreamEvent, +} from "@t3tools/contracts"; +import { type DiscordClientSourceHint, withTurnSourceHint } from "./sourceHint.ts"; +import { + PrimaryConnectionTarget, + type PreparedConnection, +} from "@t3tools/client-runtime/connection"; +import { + remoteHttpClientLayer, + RpcSessionFactory, + rpcSessionFactoryLayer, + type RpcSession, +} from "@t3tools/client-runtime/rpc"; +import { + bootstrapRemoteBearerSession, + resolveRemoteWebSocketConnectionUrl, +} from "@t3tools/client-runtime/authorization"; +import { fetchRemoteEnvironmentDescriptor } from "@t3tools/client-runtime/environment"; +import { applyShellStreamEvent } from "@t3tools/client-runtime/state/shell"; +import { appendOmegentT3ProductHandshake } from "@t3tools/shared/productFamily"; +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Fiber from "effect/Fiber"; +import * as Layer from "effect/Layer"; +import * as ManagedRuntime from "effect/ManagedRuntime"; +import * as Result from "effect/Result"; +import * as Scope from "effect/Scope"; +import * as Stream from "effect/Stream"; +import * as Socket from "effect/unstable/socket/Socket"; + +import type { DiscordBotConfig } from "../config.ts"; +import { preferredModelSelection } from "../config.ts"; +import { BrowserAutomationHost } from "../browser/BrowserAutomationHost.ts"; +import { formatThreadTitle } from "../presentation/messages.ts"; +import { normalizeWorkspacePath } from "../presentation/mentions.ts"; +import { followOrchestrationThread } from "./DiscordThreadFollower.ts"; +import { newCommandId, newMessageId, newThreadId, shortId } from "./ids.ts"; +import { + clearPersistedBearerSession, + persistedBearerExpiresAtIso, + readPersistedBearerSession, + shouldReusePersistedBearer, + writePersistedBearerSession, +} from "./PersistedBearer.ts"; + +function wsBaseUrl(httpBaseUrl: string): string { + const url = new URL(httpBaseUrl); + url.protocol = url.protocol === "https:" ? "wss:" : "ws:"; + return url.toString(); +} + +function localSocketUrl(httpBaseUrl: string): string { + const url = new URL(wsBaseUrl(httpBaseUrl)); + url.pathname = "/ws"; + url.search = ""; + url.hash = ""; + return appendOmegentT3ProductHandshake(url.toString()); +} + +function messageFromCause(cause: unknown): string { + if (cause instanceof Error && cause.message.trim() !== "") return cause.message; + return String(cause); +} + +/** + * Detect dead/transient socket failures that should force a reconnect when + * `RpcSession.closed` did not fire (or fired too late). Used for soft recovery + * on dispatch errors — we do **not** auto-retry the command (double-start risk). + */ +export function isT3TransportError(cause: unknown): boolean { + const msg = messageFromCause(cause); + if (/SocketCloseError|ConnectionTransientError|SocketError/i.test(msg)) return true; + if (/ECONNREFUSED|ECONNRESET|ENOTFOUND|EPIPE|ETIMEDOUT/i.test(msg)) return true; + if (/websocket/i.test(msg) && /close|closed|reset|refused|not connected/i.test(msg)) return true; + return false; +} + +/** True when T3 rejected a bearer/bootstrap credential (re-bootstrap, don't loop). */ +export function isT3InvalidCredentialError(cause: unknown): boolean { + const msg = messageFromCause(cause); + return /invalid_credential|rejected this client's credentials/i.test(msg); +} + +/** + * User-facing copy when the bot waited for T3 to become ready and the deadline + * elapsed (boot/reconnect still incomplete). Mentions normally **wait** instead + * of failing immediately — this is the timeout fallback. + */ +export const T3_STILL_CONNECTING_MESSAGE = + "T3 did not become ready after a server restart (or first boot). Try again in a minute."; + +/** Discord reaction while a mention is parked waiting for T3 to connect. */ +export const T3_CONNECT_WAIT_REACTION_EMOJI = "⏳"; + +/** Default how long inbound work waits for shell readiness before failing. */ +export const DEFAULT_T3_WAIT_UNTIL_READY_TIMEOUT_MS = 120_000; + +/** Poll interval while waiting for T3 readiness. */ +export const T3_WAIT_UNTIL_READY_POLL_MS = 200; + +/** + * Pure wait-loop decision for {@link T3SessionService.waitUntilReady}. + * Keeps the timeout policy unit-testable without a live RpcSession. + */ +export function shouldContinueWaitingForT3Ready(input: { + readonly ready: boolean; + readonly elapsedMs: number; + readonly timeoutMs: number; +}): "ready" | "wait" | "timeout" { + if (input.ready) return "ready"; + if (input.elapsedMs >= input.timeoutMs) return "timeout"; + return "wait"; +} + +export function shouldPersistThreadModelSelectionForNextTurn(input: { + readonly currentModelSelection?: ModelSelection; + readonly nextModelSelection?: ModelSelection; +}): boolean { + const next = input.nextModelSelection; + if (next === undefined) return false; + const current = input.currentModelSelection; + if (current === undefined) return true; + return ( + next.model !== current.model || + next.instanceId !== current.instanceId || + JSON.stringify(next.options ?? null) !== JSON.stringify(current.options ?? null) + ); +} + +export class T3SessionError extends Error { + constructor(message: string, options?: { cause?: unknown }) { + super(message, options); + this.name = "T3SessionError"; + } +} + +export interface T3SessionService { + readonly connect: () => Effect.Effect; + /** + * Keep retrying {@link connect} with the same backoff as mid-life reconnect + * until the shell snapshot is live. Used at boot so the process does not exit + * when Discord comes up before T3 (guest restart race). + */ + readonly connectUntilReady: () => Effect.Effect; + /** + * Register a callback invoked after a successful automatic reconnect + * (socket drop → reconnectLoop). Used to rehydrate Discord bridges. + */ + readonly setOnReconnected: (handler: (() => Promise) | null) => void; + /** + * True when a live RpcSession exists (may still be waiting for shell on a + * race; prefer {@link isReady} before project lookups). + */ + readonly isConnected: () => Effect.Effect; + /** True when connected and the orchestration shell snapshot has arrived. */ + readonly isReady: () => Effect.Effect; + /** + * Poll until {@link isReady} is true, or fail with + * {@link T3_STILL_CONNECTING_MESSAGE} after `timeoutMs` (default + * {@link DEFAULT_T3_WAIT_UNTIL_READY_TIMEOUT_MS}). Used so Discord mentions + * that land during boot/reconnect are queued instead of rejected. + */ + readonly waitUntilReady: (options?: { + readonly timeoutMs?: number; + }) => Effect.Effect; + readonly shell: () => Effect.Effect; + readonly serverConfig: () => Effect.Effect; + readonly findProjectByWorkspaceRoot: ( + workspaceRoot: string, + ) => Effect.Effect; + readonly getProjectShell: ( + projectId: ProjectId, + ) => Effect.Effect; + readonly startTurnWithWorktree: (input: { + readonly project: OrchestrationProjectShell; + readonly prompt: string; + readonly titleSeed?: string; + readonly modelSelection: ModelSelection; + readonly runtimeMode?: RuntimeMode; + readonly interactionMode?: ProviderInteractionMode; + readonly baseBranch: string; + readonly local: boolean; + /** User images from Discord (same shape as web composer uploads). */ + readonly attachments?: ReadonlyArray; + /** + * Discord human who triggered the turn. Server identity map resolves this + * into personId/username when the identity overlay is composed. + */ + readonly sourceHint?: DiscordClientSourceHint; + }) => Effect.Effect<{ readonly threadId: ThreadId; readonly messageId: string }, T3SessionError>; + readonly startTurn: (input: { + readonly threadId: ThreadId; + readonly prompt: string; + readonly messageId?: MessageId; + readonly modelSelection?: ModelSelection; + readonly runtimeMode?: RuntimeMode; + readonly interactionMode?: ProviderInteractionMode; + readonly attachments?: ReadonlyArray; + readonly sourceHint?: DiscordClientSourceHint; + }) => Effect.Effect<{ readonly messageId: string }, T3SessionError>; + /** + * Inject a server-queued follow-up into the active turn (or start a turn if + * idle). Used after `startTurn` queues a mid-turn Discord message so the bot + * keeps historical steer-by-default behavior. + */ + readonly steerQueuedMessage: (input: { + readonly threadId: ThreadId; + readonly messageId: MessageId; + }) => Effect.Effect; + readonly removeQueuedMessage: (input: { + readonly threadId: ThreadId; + readonly messageId: MessageId; + }) => Effect.Effect; + /** + * Subscribe to thread events until disconnect/interrupt. + * Runs `onThread` in the caller fiber context (must not be forked onto a bare T3 runtime). + * + * @param options.afterSequence - when set, only events after this sequence are streamed + * (no embedded snapshot unless warmSeed is missing). Prefer warm seed or HTTP tip first. + * @param options.onSequence - durable marker callback after each applied snapshot/event. + * @param options.warmSeed - durable trimmed tip (web/desktop-style cache). When set with a + * finite sequence, skips HTTP full-tip fetch and resumes via afterSequence from that base. + * @param options.projectThread - optional projection before onThread / retained apply base + * (e.g. drop Discord-finalized history beyond a small buffer). + */ + readonly subscribeThread: ( + threadId: ThreadId, + onThread: (thread: OrchestrationThread) => Effect.Effect, + options?: { + readonly afterSequence?: number; + readonly onSequence?: (sequence: number) => Effect.Effect; + readonly warmSeed?: { + readonly snapshotSequence: number; + readonly thread: OrchestrationThread; + } | null; + readonly projectThread?: (thread: OrchestrationThread) => OrchestrationThread; + }, + ) => Effect.Effect; + readonly respondToApproval: ( + threadId: ThreadId, + requestId: string, + decision: ProviderApprovalDecision, + ) => Effect.Effect; + readonly respondToUserInput: ( + threadId: ThreadId, + requestId: string, + answers: ProviderUserInputAnswers, + ) => Effect.Effect; + readonly interrupt: (threadId: ThreadId) => Effect.Effect; + readonly compact: (threadId: ThreadId) => Effect.Effect; + readonly resolveModelSelection: (input: { + readonly project?: OrchestrationProjectShell | null; + readonly stickyModelSelection?: ModelSelection | null; + readonly overrideInstanceId?: string; + readonly overrideModel?: string; + }) => Effect.Effect; + readonly getThreadShell: (threadId: ThreadId) => Effect.Effect; + /** + * HTTP snapshot of a thread (full transcript + sequence). Used by Discord bridges to + * reconcile when the WS event stream stalls mid-turn so Discord is not stuck on Working.. + * while the T3 client still shows progress. + */ + readonly fetchThreadDetail: ( + threadId: ThreadId, + ) => Effect.Effect; + readonly resolveBranchChangeRequest: (input: { + readonly cwd: string; + readonly refName: string; + }) => Effect.Effect; + readonly subscribeVcsStatus: ( + cwd: string, + onStatus: (event: VcsStatusStreamEvent) => Effect.Effect, + ) => Effect.Effect; + readonly refreshVcsStatus: (cwd: string) => Effect.Effect; + /** + * Resolve a signed absolute HTTP URL for a chat attachment (image) stored on the T3 server. + * Used so Discord can download and re-upload the file as a message attachment. + */ + readonly createAttachmentUrl: (attachmentId: string) => Effect.Effect; + /** + * Resolve a signed absolute HTTP URL for a workspace (or absolute host) file via assets.createUrl. + * Used for Codex `generated_images` paths that appear as markdown embeds, when local disk + * is not readable from the bot process. + */ + readonly createWorkspaceFileUrl: (input: { + readonly threadId: ThreadId; + readonly path: string; + }) => Effect.Effect; +} + +export class T3Session extends Context.Service()( + "@t3tools/discord-bot/t3/T3Session", +) {} + +/** + * Same backoff as EnvironmentSupervisor (client-runtime connection/supervisor.ts), so + * the bot behaves like the web and mobile clients rather than inventing its own policy. + */ +const RECONNECT_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 16_000] as const; + +/** How long to wait for the first shell snapshot after the WS is up (ms poll × attempts). */ +const SHELL_SNAPSHOT_POLL_MS = 100; +const SHELL_SNAPSHOT_MAX_ATTEMPTS = 150; // 15s — guest T3 can lag Discord on restart + +/** Brief wait for shell when a mention races reconnect completion. */ +const PROJECT_LOOKUP_SHELL_WAIT_ATTEMPTS = 30; // 3s + +export const makeT3Session = (botConfig: DiscordBotConfig) => + Effect.sync(() => { + const runtime = ManagedRuntime.make( + Layer.merge( + rpcSessionFactoryLayer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal)), + remoteHttpClientLayer((input, init) => globalThis.fetch(input, init)), + ), + ); + + let scope: Scope.Closeable | null = null; + let session: RpcSession | null = null; + let httpBaseUrl: string | null = null; + /** Bearer used for HTTP snapshot reloads (same token as WS connect). */ + let httpBearerToken: string | null = null; + let shell: OrchestrationShellSnapshot | null = null; + let serverConfig: ServerConfig | null = null; + let shellFiber: Fiber.Fiber | null = null; + let browserFiber: Fiber.Fiber | null = null; + let browserHost: BrowserAutomationHost | null = null; + let reconnecting = false; + let onReconnected: (() => Promise) | null = null; + const threadFibers = new Map>(); + + const requireSession = (): RpcSession => { + if (session === null) throw new T3SessionError(T3_STILL_CONNECTING_MESSAGE); + return session; + }; + + /** + * Tear the connection down so the next connect() rebuilds it. + * + * Without this the bot keeps a dead socket forever: connectPrepared() early-returns + * while `session` is non-null, so every dispatch after a server restart failed with + * `SocketCloseError: 1005` until the bot was manually restarted. + */ + const teardown = async () => { + const previousScope = scope; + const previousFibers = [shellFiber, browserFiber, ...threadFibers.values()]; + const previousBrowserHost = browserHost; + scope = null; + session = null; + httpBaseUrl = null; + httpBearerToken = null; + shell = null; + serverConfig = null; + shellFiber = null; + browserFiber = null; + browserHost = null; + // Drop thread subscriptions so subscribeThread() re-subscribes on the new session + // instead of holding fibers that will never emit again. + threadFibers.clear(); + + // These are forked on the ManagedRuntime, not on the connection scope, so closing + // the scope does NOT stop them -- they would sit on a dead socket forever. + // Interrupt explicitly, matching subscribeThread's existing replace-fiber pattern. + for (const fiber of previousFibers) { + if (fiber !== null) { + await runtime.runPromise(Fiber.interrupt(fiber)).catch(() => {}); + } + } + if (previousScope !== null) { + await runtime.runPromise(Scope.close(previousScope, Exit.void)).catch(() => {}); + } + if (previousBrowserHost !== null) { + await previousBrowserHost.close().catch(() => {}); + } + }; + + /** + * When the socket is dead but `closed` never fired (or dispatch saw the failure + * first), tear down and enter reconnectLoop. Does not re-run the failed command. + */ + const scheduleReconnectFromTransportError = (cause: unknown) => { + if (reconnecting) return; + void (async () => { + await runtime + .runPromise( + Effect.logWarning(`T3 transport error; forcing reconnect: ${messageFromCause(cause)}`), + ) + .catch(() => {}); + await teardown(); + await reconnectLoop(); + })(); + }; + + /** + * Reconnect with backoff, mirroring EnvironmentSupervisor's schedule + * (packages/client-runtime/src/connection/supervisor.ts) which web/mobile already + * use. Retries indefinitely: a server restart is routine here, and the bot has + * nothing useful to do while disconnected. + */ + const reconnectLoop = async () => { + if (reconnecting) return; + reconnecting = true; + try { + for (let attempt = 0; ; attempt += 1) { + const delay = + RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)] ?? 16_000; + await runtime.runPromise(Effect.sleep(Duration.millis(delay))).catch(() => {}); + try { + await runtime.runPromise(connect()); + await runtime.runPromise(Effect.logInfo("Reconnected to T3")); + const handler = onReconnected; + if (handler !== null) { + try { + await handler(); + } catch (cause) { + await runtime + .runPromise( + Effect.logError(`T3 reconnect rehydrate failed: ${messageFromCause(cause)}`), + ) + .catch(() => {}); + } + } + return; + } catch (cause) { + await runtime + .runPromise( + Effect.logWarning( + `T3 reconnect attempt ${attempt + 1} failed: ${messageFromCause(cause)}`, + ), + ) + .catch(() => {}); + } + } + } finally { + reconnecting = false; + } + }; + + /** + * `RpcSession.closed` fails with ConnectionTransientError when the socket drops. + * Watching it means we notice a server restart immediately, instead of discovering + * it on the next user-visible dispatch and reporting a raw socket error to Discord. + */ + // Not stored: this fiber ends when `closed` fires, and it is the thing that calls + // teardown() -- holding a handle would only tempt us into interrupting it from + // inside itself. + const superviseClose = (connected: RpcSession) => { + runtime.runFork( + connected.closed.pipe( + Effect.catchCause((cause) => + Effect.gen(function* () { + // Another fiber may already have torn down and started reconnect + // (e.g. soft recovery from a transport error on dispatch). + if (session !== connected) return; + yield* Effect.logWarning(`T3 connection lost: ${messageFromCause(cause)}`); + yield* Effect.promise(() => teardown()); + yield* Effect.promise(() => reconnectLoop()); + }), + ), + Effect.asVoid, + ), + ); + }; + + const nowIso = () => DateTime.formatIso(DateTime.nowUnsafe()); + + const dispatch = (command: ClientOrchestrationCommand) => + Effect.tryPromise({ + try: () => + runtime.runPromise( + requireSession().client[ORCHESTRATION_WS_METHODS.dispatchCommand](command), + ), + catch: (cause) => { + if (isT3TransportError(cause)) { + scheduleReconnectFromTransportError(cause); + } + return new T3SessionError(`dispatch failed: ${messageFromCause(cause)}`, { cause }); + }, + }).pipe(Effect.asVoid); + + const claimBrowserHost = (threadId: ThreadId) => + Effect.gen(function* () { + const claim = browserHost?.claim(threadId); + if (claim === null || claim === undefined) return; + yield* requireSession().client[WS_METHODS.previewAutomationFocusHost](claim); + yield* Effect.logInfo("Claimed Discord browser host for thread", { threadId }); + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Could not claim Discord browser host for thread", { + threadId, + cause, + }), + ), + ); + + // Parameter must not be named `httpBaseUrl` — that shadows the outer + // connection-state binding, so `httpBaseUrl = normalizedBaseUrl` would only + // mutate the parameter and leave outer state null forever. steernow and + // bridge HTTP reseed then always see "snapshot unavailable". + const connectPrepared = (baseUrl: string, bearerToken?: string) => + Effect.tryPromise({ + try: async () => { + const normalizedBaseUrl = new URL(baseUrl).toString(); + // Half-open: session without shell must never short-circuit (stuck forever). + if (session !== null && shell !== null) return; + if (session !== null && shell === null) { + await teardown(); + } + + let environmentId = EnvironmentId.make(PRIMARY_LOCAL_ENVIRONMENT_ID); + let socketUrl = localSocketUrl(normalizedBaseUrl); + let label = "T3 Code"; + if (bearerToken !== undefined && bearerToken !== "") { + const descriptor = await runtime.runPromise( + fetchRemoteEnvironmentDescriptor({ httpBaseUrl: normalizedBaseUrl }), + ); + socketUrl = await runtime.runPromise( + resolveRemoteWebSocketConnectionUrl({ + wsBaseUrl: wsBaseUrl(normalizedBaseUrl), + httpBaseUrl: normalizedBaseUrl, + bearerToken, + }), + ); + label = descriptor.label; + environmentId = descriptor.environmentId; + } + + const target = new PrimaryConnectionTarget({ + environmentId, + label, + httpBaseUrl: normalizedBaseUrl, + wsBaseUrl: wsBaseUrl(normalizedBaseUrl), + }); + const prepared: PreparedConnection = { + environmentId, + label, + httpBaseUrl: normalizedBaseUrl, + socketUrl, + httpAuthorization: + bearerToken === undefined || bearerToken === "" + ? null + : { _tag: "Bearer", token: bearerToken }, + target, + }; + + const nextScope = await runtime.runPromise(Scope.make()); + try { + const connected = await runtime.runPromise( + Effect.gen(function* () { + const factory = yield* RpcSessionFactory; + const result = yield* factory.connect(prepared); + yield* result.ready; + return result; + }).pipe(Scope.provide(nextScope)), + ); + scope = nextScope; + session = connected; + httpBaseUrl = normalizedBaseUrl; + httpBearerToken = bearerToken !== undefined && bearerToken !== "" ? bearerToken : null; + serverConfig = await runtime.runPromise(connected.initialConfig); + superviseClose(connected); + + const stream = connected.client[ORCHESTRATION_WS_METHODS.subscribeShell]({}).pipe( + Stream.runForEach((item) => + Effect.sync(() => { + if (item.kind === "snapshot") shell = item.snapshot; + else if (item.kind === "synchronized") { + // Status-only marker (parity with EnvironmentShellState.applyItem); + // no shell snapshot mutation in the headless bridge. + } else if (shell !== null) shell = applyShellStreamEvent(shell, item); + }), + ), + ); + shellFiber = runtime.runFork(stream); + + if (botConfig.browserEnabled) { + try { + const host = await BrowserAutomationHost.launch(botConfig, environmentId); + browserHost = host; + browserFiber = runtime.runFork( + connected.client[WS_METHODS.previewAutomationConnect](host.registration()).pipe( + Stream.runForEach((event) => + Effect.gen(function* () { + const startedAt = yield* Clock.currentTimeMillis; + const response = yield* Effect.tryPromise({ + try: () => host.consume(event), + catch: (cause) => + new T3SessionError( + `Browser operation failed: ${messageFromCause(cause)}`, + { cause }, + ), + }); + if (event.type === "request") { + yield* Effect.logInfo("Discord browser operation completed", { + operation: event.request.operation, + requestId: event.request.requestId, + tabId: event.request.tabId ?? null, + elapsedMs: (yield* Clock.currentTimeMillis) - startedAt, + ok: response?.ok ?? false, + errorTag: response?.error?._tag ?? null, + }); + } + return response; + }).pipe( + Effect.flatMap((response) => + response === null + ? Effect.void + : connected.client[WS_METHODS.previewAutomationRespond](response), + ), + ), + ), + Effect.catchCause((cause) => + Effect.sync(() => { + if (browserHost === host) browserHost = null; + }).pipe( + Effect.andThen(Effect.promise(() => host.close())), + Effect.ignore, + Effect.andThen( + Effect.logError( + `Discord browser automation host stopped: ${messageFromCause(cause)}`, + ), + ), + ), + ), + Effect.asVoid, + ), + ); + await runtime.runPromise( + Effect.logInfo("Discord browser automation host active", { + profile: botConfig.browserProfile, + }), + ); + } catch (cause) { + await runtime.runPromise( + Effect.logError( + `Discord browser automation unavailable: ${messageFromCause(cause)}`, + ), + ); + } + } + + // `shell` is updated by the concurrently running subscription fiber. + for (let attempt = 0; attempt < SHELL_SNAPSHOT_MAX_ATTEMPTS; attempt += 1) { + if (shell !== null) break; + await Effect.runPromise(Effect.sleep(Duration.millis(SHELL_SNAPSHOT_POLL_MS))); + } + if (shell === null) { + throw new T3SessionError( + "Connected to T3 but the orchestration shell snapshot did not arrive in time", + ); + } + } catch (cause) { + // Full teardown is required: a partial connect leaves session non-null and + // the next connectPrepared early-returns forever (stuck bot after restart). + await teardown(); + // nextScope may not have been published to `scope` yet (fail before assign). + await runtime.runPromise(Scope.close(nextScope, Exit.void)).catch(() => {}); + throw cause instanceof T3SessionError + ? cause + : new T3SessionError(`Could not connect to T3 Code: ${messageFromCause(cause)}`, { + cause, + }); + } + }, + catch: (cause) => + cause instanceof T3SessionError + ? cause + : new T3SessionError(messageFromCause(cause), { cause }), + }); + + const persistBootstrappedBearer = (accessToken: string, expiresInSeconds: number) => + Effect.gen(function* () { + const nowMs = yield* Clock.currentTimeMillis; + try { + writePersistedBearerSession(botConfig.dataDir, { + accessToken, + expiresAt: persistedBearerExpiresAtIso(nowMs, expiresInSeconds), + httpBaseUrl: botConfig.t3HttpBaseUrl, + }); + } catch (cause) { + yield* Effect.logWarning( + `Could not persist T3 bearer session: ${messageFromCause(cause)}`, + ); + } + }); + + const connectWithBootstrapCredential = () => + Effect.gen(function* () { + const tokenSession = yield* Effect.tryPromise({ + try: () => + runtime.runPromise( + bootstrapRemoteBearerSession({ + httpBaseUrl: botConfig.t3HttpBaseUrl, + credential: botConfig.t3BootstrapCredential!, + clientMetadata: { label: "T3 Discord Bot", deviceType: "bot" }, + }), + ), + catch: (cause) => + new T3SessionError(`Bootstrap failed: ${messageFromCause(cause)}`, { cause }), + }); + yield* persistBootstrappedBearer(tokenSession.access_token, tokenSession.expires_in); + yield* connectPrepared(botConfig.t3HttpBaseUrl, tokenSession.access_token); + }); + + const connect = () => + Effect.gen(function* () { + if (botConfig.t3BearerToken !== undefined && botConfig.t3BearerToken !== "") { + yield* connectPrepared(botConfig.t3HttpBaseUrl, botConfig.t3BearerToken); + return; + } + + const nowMs = yield* Clock.currentTimeMillis; + const persisted = readPersistedBearerSession(botConfig.dataDir); + if ( + persisted !== null && + shouldReusePersistedBearer({ + record: persisted, + nowMs, + httpBaseUrl: botConfig.t3HttpBaseUrl, + }) + ) { + const persistedConnect = yield* Effect.result( + connectPrepared(botConfig.t3HttpBaseUrl, persisted.accessToken), + ); + if (Result.isSuccess(persistedConnect)) return; + if (!isT3InvalidCredentialError(persistedConnect.failure)) { + return yield* Effect.fail(persistedConnect.failure); + } + yield* Effect.logWarning("Persisted T3 bearer rejected; falling back to bootstrap"); + clearPersistedBearerSession(botConfig.dataDir); + } + + if ( + botConfig.t3BootstrapCredential !== undefined && + botConfig.t3BootstrapCredential !== "" + ) { + yield* connectWithBootstrapCredential(); + return; + } + yield* connectPrepared(botConfig.t3HttpBaseUrl); + }); + + /** + * Boot path: Discord may start before guest T3 is listening. Retry forever + * with the same schedule as mid-life reconnect instead of exiting the process. + */ + const connectUntilReady = () => + Effect.gen(function* () { + for (let attempt = 0; ; attempt += 1) { + const outcome = yield* Effect.result(connect()); + if (Result.isSuccess(outcome)) return; + const delay = + RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)] ?? 16_000; + yield* Effect.logWarning( + `T3 boot connect attempt ${attempt + 1} failed: ${messageFromCause(outcome.failure)}; retrying in ${delay}ms`, + ); + yield* Effect.sleep(Duration.millis(delay)); + } + }); + + /** + * Wait for a live shell so Discord intake can park work across boot/reconnect + * instead of telling the human to retry. Polls the same readiness predicate as + * {@link isReady}; does not itself drive reconnect (that is connectUntilReady / + * reconnectLoop). + */ + const waitUntilReady = (options?: { readonly timeoutMs?: number }) => + Effect.gen(function* () { + if (session !== null && shell !== null) return; + const timeoutMs = options?.timeoutMs ?? DEFAULT_T3_WAIT_UNTIL_READY_TIMEOUT_MS; + const startedAt = yield* Clock.currentTimeMillis; + yield* Effect.logInfo("Waiting for T3 shell readiness", { timeoutMs }); + for (;;) { + const ready = session !== null && shell !== null; + const now = yield* Clock.currentTimeMillis; + const decision = shouldContinueWaitingForT3Ready({ + ready, + elapsedMs: now - startedAt, + timeoutMs, + }); + if (decision === "ready") { + yield* Effect.logInfo("T3 became ready while waiting", { + waitedMs: now - startedAt, + }); + return; + } + if (decision === "timeout") { + return yield* Effect.fail(new T3SessionError(T3_STILL_CONNECTING_MESSAGE)); + } + yield* Effect.sleep(Duration.millis(T3_WAIT_UNTIL_READY_POLL_MS)); + } + }); + + const providersForSelection = (): ReadonlyArray => + serverConfig?.providers ?? []; + + const fetchThreadDetailHttp = (threadId: ThreadId) => + Effect.tryPromise({ + try: async (): Promise => { + const base = httpBaseUrl; + if (base === null) return null; + const url = new URL( + `/api/orchestration/threads/${encodeURIComponent(threadId)}`, + base, + ).toString(); + const headers: Record = { Accept: "application/json" }; + if (httpBearerToken !== null) { + headers.Authorization = `Bearer ${httpBearerToken}`; + } + const response = await globalThis.fetch(url, { headers }); + if (!response.ok) { + throw new Error(`HTTP ${response.status} loading thread snapshot`); + } + return (await response.json()) as OrchestrationThreadDetailSnapshot; + }, + catch: (cause) => + new T3SessionError(`Thread snapshot fetch failed: ${messageFromCause(cause)}`, { + cause, + }), + }).pipe( + Effect.catch((error) => + Effect.logWarning("Could not fetch thread snapshot over HTTP", { + threadId, + error: String(error), + }).pipe(Effect.as(null)), + ), + ); + + return T3Session.of({ + connect, + connectUntilReady, + setOnReconnected: (handler) => { + onReconnected = handler; + }, + isConnected: () => Effect.sync(() => session !== null), + isReady: () => Effect.sync(() => session !== null && shell !== null), + waitUntilReady, + shell: () => Effect.succeed(shell), + serverConfig: () => Effect.succeed(serverConfig), + findProjectByWorkspaceRoot: (workspaceRoot) => + Effect.gen(function* () { + // Mentions can land while shell is still filling after reconnect. + for (let attempt = 0; attempt < PROJECT_LOOKUP_SHELL_WAIT_ATTEMPTS; attempt += 1) { + // shell/session are mutated by connect/teardown/shellFiber, not this loop body. + if (shell !== null || session === null) break; + yield* Effect.sleep(Duration.millis(SHELL_SNAPSHOT_POLL_MS)); + } + if (shell === null) return null; + const target = normalizeWorkspacePath(workspaceRoot); + return ( + shell.projects.find( + (project) => normalizeWorkspacePath(project.workspaceRoot) === target, + ) ?? null + ); + }), + getProjectShell: (projectId) => + Effect.sync(() => shell?.projects.find((project) => project.id === projectId) ?? null), + resolveModelSelection: ({ + project, + stickyModelSelection, + overrideInstanceId, + overrideModel, + }) => + Effect.sync(() => + preferredModelSelection({ + config: botConfig, + providers: providersForSelection(), + projectDefault: project?.defaultModelSelection ?? null, + ...(stickyModelSelection === undefined ? {} : { stickyModelSelection }), + ...(overrideInstanceId === undefined ? {} : { overrideInstanceId }), + ...(overrideModel === undefined ? {} : { overrideModel }), + }), + ), + getThreadShell: (threadId) => + Effect.sync(() => shell?.threads.find((thread) => thread.id === threadId) ?? null), + fetchThreadDetail: (threadId) => fetchThreadDetailHttp(threadId), + resolveBranchChangeRequest: (input) => + Effect.tryPromise({ + try: () => + runtime.runPromise( + requireSession().client[WS_METHODS.vcsResolveBranchChangeRequest](input), + ), + catch: (cause) => + new T3SessionError( + `Could not resolve branch change request for ${input.refName}: ${messageFromCause(cause)}`, + { cause }, + ), + }), + startTurnWithWorktree: (input) => + Effect.gen(function* () { + const threadId = newThreadId(); + const messageId = newMessageId(); + const createdAt = nowIso(); + const title = formatThreadTitle(input.titleSeed ?? input.prompt, 72, "Discord thread"); + const interactionMode = input.interactionMode ?? "default"; + const runtimeMode = input.runtimeMode ?? botConfig.t3DefaultRuntimeMode; + const worktreeBranch = `t3-discord/${shortId()}`; + + yield* claimBrowserHost(threadId); + const createTurn = { + type: "thread.turn.start" as const, + commandId: newCommandId(), + threadId, + message: { + messageId, + role: "user" as const, + text: input.prompt, + attachments: (input.attachments ?? []) as ReadonlyArray, + }, + modelSelection: input.modelSelection, + titleSeed: title, + runtimeMode, + interactionMode, + bootstrap: { + createThread: { + projectId: input.project.id, + title, + modelSelection: input.modelSelection, + runtimeMode, + interactionMode, + branch: null, + worktreePath: null, + createdAt, + }, + ...(input.local + ? {} + : { + prepareWorktree: { + projectCwd: input.project.workspaceRoot, + baseBranch: input.baseBranch, + branch: worktreeBranch, + startFromOrigin: true, + }, + runSetupScript: true, + }), + }, + createdAt, + }; + yield* dispatch(withTurnSourceHint(createTurn, input.sourceHint)); + + return { threadId, messageId }; + }), + startTurn: (input) => + Effect.gen(function* () { + const thread = shell?.threads.find((entry) => entry.id === input.threadId); + const messageId = input.messageId ?? newMessageId(); + // Sticky model on continue: never re-apply bot defaults (codex/gpt-5.4). + // Explicit overrides come only from Discord --provider/--model flags. + // modelSelection is optional on thread.turn.start; omit when unknown so the + // server keeps the thread's existing selection (Grok refuses mid-thread switches). + const modelSelection = input.modelSelection ?? thread?.modelSelection; + yield* claimBrowserHost(input.threadId); + if ( + shouldPersistThreadModelSelectionForNextTurn({ + ...(thread?.modelSelection === undefined + ? {} + : { currentModelSelection: thread.modelSelection }), + ...(modelSelection === undefined ? {} : { nextModelSelection: modelSelection }), + }) + ) { + yield* dispatch({ + type: "thread.meta.update", + commandId: newCommandId(), + threadId: input.threadId, + modelSelection, + }); + } + const continueTurn = { + type: "thread.turn.start" as const, + commandId: newCommandId(), + threadId: input.threadId, + message: { + messageId, + role: "user" as const, + text: input.prompt, + attachments: (input.attachments ?? []) as ReadonlyArray, + }, + ...(modelSelection === undefined ? {} : { modelSelection }), + titleSeed: input.prompt.trim().slice(0, 80) || "Continue", + runtimeMode: input.runtimeMode ?? thread?.runtimeMode ?? DEFAULT_RUNTIME_MODE, + interactionMode: input.interactionMode ?? thread?.interactionMode ?? "default", + createdAt: nowIso(), + }; + yield* dispatch(withTurnSourceHint(continueTurn, input.sourceHint)); + return { messageId }; + }), + steerQueuedMessage: (input) => + dispatch({ + type: "thread.queue.steer", + commandId: newCommandId(), + threadId: input.threadId, + messageId: input.messageId, + createdAt: nowIso(), + }), + removeQueuedMessage: (input) => + dispatch({ + type: "thread.queue.remove", + commandId: newCommandId(), + threadId: input.threadId, + messageId: input.messageId, + createdAt: nowIso(), + }), + /** + * Subscribe to thread events and run `onThread` in the **caller's** Effect context. + * + * Must NOT use `runtime.runFork` — that runs on the T3 ManagedRuntime without + * DiscordREST, so every Discord post fails silently ("nothing happens"). + * Run the stream with `yield*` so the Discord bridge fiber provides services. + * + * Client-aligned via {@link followOrchestrationThread} (same apply/reload/retry + * semantics as EnvironmentThreadState; no core package edits). + */ + subscribeThread: (threadId, onThread, options) => + Effect.gen(function* () { + const active = requireSession(); + yield* followOrchestrationThread({ + threadId, + afterSequence: options?.afterSequence ?? null, + ...(options?.onSequence !== undefined ? { onSequence: options.onSequence } : {}), + warmSeed: options?.warmSeed ?? null, + ...(options?.projectThread !== undefined + ? { projectThread: options.projectThread } + : {}), + onThread, + fetchSnapshot: () => fetchThreadDetailHttp(threadId), + openStream: ({ afterSequence }) => + active.client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId, + ...(afterSequence !== undefined ? { afterSequence } : {}), + }).pipe( + Stream.mapError( + (cause) => + new T3SessionError(`Thread subscription failed: ${messageFromCause(cause)}`, { + cause, + }), + ), + ), + retryForever: true, + }); + }), + subscribeVcsStatus: (cwd, onStatus) => + Effect.gen(function* () { + const active = requireSession(); + + yield* active.client[WS_METHODS.subscribeVcsStatus]({ + cwd, + }).pipe( + Stream.runForEach((event) => + onStatus(event).pipe( + Effect.catchCause((cause) => + Effect.logError("Thread bridge onVcsStatus failed", { cwd, cause }), + ), + ), + ), + Effect.mapError( + (cause) => + new T3SessionError(`VCS status subscription failed: ${messageFromCause(cause)}`, { + cause, + }), + ), + ); + }), + refreshVcsStatus: (cwd) => + Effect.tryPromise({ + try: () => + runtime.runPromise( + requireSession().client[WS_METHODS.vcsRefreshStatus]({ + cwd, + }), + ), + catch: (cause) => + new T3SessionError( + `Could not refresh VCS status for ${cwd}: ${messageFromCause(cause)}`, + { + cause, + }, + ), + }).pipe(Effect.asVoid), + respondToApproval: (threadId, requestId, decision) => + dispatch({ + type: "thread.approval.respond", + commandId: newCommandId(), + threadId, + requestId: ApprovalRequestId.make(requestId), + decision, + createdAt: nowIso(), + }), + respondToUserInput: (threadId, requestId, answers) => + dispatch({ + type: "thread.user-input.respond", + commandId: newCommandId(), + threadId, + requestId: ApprovalRequestId.make(requestId), + answers, + createdAt: nowIso(), + }), + interrupt: (threadId) => + Effect.gen(function* () { + const threadShell = shell?.threads.find((entry) => entry.id === threadId); + yield* dispatch({ + type: "thread.turn.interrupt", + commandId: newCommandId(), + threadId, + ...(threadShell?.latestTurn?.turnId === undefined + ? {} + : { turnId: threadShell.latestTurn.turnId }), + createdAt: nowIso(), + }); + }), + compact: (threadId) => + dispatch({ + type: "thread.context.compact", + commandId: newCommandId(), + threadId, + createdAt: nowIso(), + }), + createAttachmentUrl: (attachmentId) => + Effect.tryPromise({ + try: async () => { + const active = requireSession(); + const base = httpBaseUrl; + if (base === null) { + throw new T3SessionError("T3 Code is not connected."); + } + const result = await runtime.runPromise( + active.client[WS_METHODS.assetsCreateUrl]({ + resource: { _tag: "attachment", attachmentId }, + }), + ); + return new URL(result.relativeUrl, base).toString(); + }, + catch: (cause) => + cause instanceof T3SessionError + ? cause + : new T3SessionError( + `Could not create attachment URL for ${attachmentId}: ${messageFromCause(cause)}`, + { cause }, + ), + }), + createWorkspaceFileUrl: ({ threadId, path }) => + Effect.tryPromise({ + try: async () => { + const active = requireSession(); + const base = httpBaseUrl; + if (base === null) { + throw new T3SessionError("T3 Code is not connected."); + } + const result = await runtime.runPromise( + active.client[WS_METHODS.assetsCreateUrl]({ + resource: { _tag: "workspace-file", threadId, path }, + }), + ); + return new URL(result.relativeUrl, base).toString(); + }, + catch: (cause) => + cause instanceof T3SessionError + ? cause + : new T3SessionError( + `Could not create workspace file URL for ${path}: ${messageFromCause(cause)}`, + { cause }, + ), + }), + }); + }); + +export const layer = (botConfig: DiscordBotConfig) => + Layer.effect(T3Session, makeT3Session(botConfig)); diff --git a/apps/discord-bot/src/t3/ids.ts b/apps/discord-bot/src/t3/ids.ts new file mode 100644 index 000000000000..68bccc8ef771 --- /dev/null +++ b/apps/discord-bot/src/t3/ids.ts @@ -0,0 +1,18 @@ +import { CommandId, MessageId, ProjectId, ThreadId } from "@t3tools/contracts"; + +function randomUuid(): string { + const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16)); + bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40; + bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80; + const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(""); + return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`; +} + +export const newCommandId = (): CommandId => CommandId.make(randomUuid()); +export const newMessageId = (): MessageId => MessageId.make(randomUuid()); +export const newProjectId = (): ProjectId => ProjectId.make(randomUuid()); +export const newThreadId = (): ThreadId => ThreadId.make(randomUuid()); + +export function shortId(length = 8): string { + return randomUuid().replaceAll("-", "").slice(0, length); +} diff --git a/apps/discord-bot/src/t3/sourceHint.test.ts b/apps/discord-bot/src/t3/sourceHint.test.ts new file mode 100644 index 000000000000..331788a5f30b --- /dev/null +++ b/apps/discord-bot/src/t3/sourceHint.test.ts @@ -0,0 +1,49 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { discordSourceHint, withTurnSourceHint } from "./sourceHint.ts"; + +describe("discordSourceHint", () => { + it("builds a discord hint with actor + location for map resolution", () => { + expect( + discordSourceHint({ + authorId: "95218063095377920", + authorUsername: "patroza", + guildId: "guild-1", + channelId: "channel-1", + discordThreadId: "thread-1", + }), + ).toEqual({ + channel: "discord", + actor: { platformId: "95218063095377920", displayName: "patroza" }, + location: { + guildId: "guild-1", + channelId: "channel-1", + threadId: "thread-1", + }, + }); + }); + + it("always stamps channel discord even when author is missing", () => { + expect(discordSourceHint({})).toEqual({ channel: "discord" }); + }); +}); + +describe("withTurnSourceHint", () => { + it("attaches sourceHint to turn.start without mutating when undefined", () => { + const base = { + type: "thread.turn.start" as const, + commandId: "cmd-1", + }; + expect(withTurnSourceHint(base, undefined)).toBe(base); + expect( + withTurnSourceHint(base, { + channel: "discord", + actor: { platformId: "1" }, + }), + ).toEqual({ + type: "thread.turn.start", + commandId: "cmd-1", + sourceHint: { channel: "discord", actor: { platformId: "1" } }, + }); + }); +}); diff --git a/apps/discord-bot/src/t3/sourceHint.ts b/apps/discord-bot/src/t3/sourceHint.ts new file mode 100644 index 000000000000..53721a074830 --- /dev/null +++ b/apps/discord-bot/src/t3/sourceHint.ts @@ -0,0 +1,65 @@ +/** + * Platform provenance for bot-dispatched turn.start. + * + * Mirrors `@t3tools/contracts` ClientSourceHint so the Discord overlay can + * stamp actors without depending on the identity overlay at compile time. + * When fork/identity is composed, the server resolves platformId via the map + * into personId/username (e.g. patroza@discord). Without a hint, bot sessions + * fall back to bare `{ channel: "bot" }` — no person chip in the sidebar. + */ +export type DiscordClientSourceHint = { + readonly channel: "discord"; + readonly actor?: { + readonly platformId?: string; + readonly displayName?: string; + }; + readonly location?: { + readonly guildId?: string; + readonly channelId?: string; + readonly threadId?: string; + }; +}; + +export function discordSourceHint(input: { + readonly authorId?: string | null | undefined; + readonly authorUsername?: string | null | undefined; + readonly guildId?: string | null | undefined; + readonly channelId?: string | null | undefined; + readonly discordThreadId?: string | null | undefined; +}): DiscordClientSourceHint { + const platformId = input.authorId?.trim() ?? ""; + const displayName = input.authorUsername?.trim() ?? ""; + const guildId = input.guildId?.trim() ?? ""; + const channelId = input.channelId?.trim() ?? ""; + const threadId = input.discordThreadId?.trim() ?? ""; + + return { + channel: "discord", + ...(platformId.length > 0 || displayName.length > 0 + ? { + actor: { + ...(platformId.length > 0 ? { platformId } : {}), + ...(displayName.length > 0 ? { displayName } : {}), + }, + } + : {}), + ...(guildId.length > 0 || channelId.length > 0 || threadId.length > 0 + ? { + location: { + ...(guildId.length > 0 ? { guildId } : {}), + ...(channelId.length > 0 ? { channelId } : {}), + ...(threadId.length > 0 ? { threadId } : {}), + }, + } + : {}), + }; +} + +/** Attach sourceHint for servers that understand it (identity overlay). */ +export function withTurnSourceHint( + command: T, + sourceHint: DiscordClientSourceHint | undefined, +): T { + if (sourceHint === undefined) return command; + return { ...command, sourceHint } as T; +} diff --git a/apps/discord-bot/src/teams-main.ts b/apps/discord-bot/src/teams-main.ts new file mode 100644 index 000000000000..853cbba87fe7 --- /dev/null +++ b/apps/discord-bot/src/teams-main.ts @@ -0,0 +1,46 @@ +// @effect-diagnostics layerMergeAllWithDependencies:off missingEffectContext:off anyUnknownInErrorContext:off unsafeEffectTypeAssertion:off multipleEffectProvide:off +import { NodeRuntime } from "@effect/platform-node"; +import * as ConfigProvider from "effect/ConfigProvider"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Logger from "effect/Logger"; + +import { DiscordBotConfig } from "./config.ts"; +import { runTeamsNativeApp } from "./features/TeamsNativeApp.ts"; +import { layerFromOptionalPath as projectAliasStoreLayer } from "./projectAliases.ts"; +import { layer as threadLinkStoreLayer } from "./store/ThreadLinkStore.ts"; +import { T3Session, layer as t3SessionLayer } from "./t3/T3Session.ts"; + +const TeamsMainLayer = Layer.unwrap( + Effect.gen(function* () { + const config = yield* DiscordBotConfig; + return Layer.mergeAll( + t3SessionLayer(config), + threadLinkStoreLayer(config.dataDir), + projectAliasStoreLayer(config.projectAliasesPath), + ).pipe( + Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromEnv())), + Layer.provideMerge(Logger.layer([Logger.consolePretty()])), + ); + }), +).pipe(Layer.provide(ConfigProvider.layer(ConfigProvider.fromEnv()))); + +const program = Effect.gen(function* () { + const config = yield* DiscordBotConfig; + if (!config.teamsNativeEnabled) { + return yield* Effect.die( + new Error("TEAMS_NATIVE_ENABLED=1 is required by the Teams-only entrypoint."), + ); + } + const t3 = yield* T3Session; + yield* t3.connectUntilReady(); + yield* runTeamsNativeApp(config); + return yield* Effect.never; +}); + +NodeRuntime.runMain( + program.pipe( + Effect.provide(TeamsMainLayer), + Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv())), + ) as Effect.Effect, +); diff --git a/apps/discord-bot/src/teams/attachments.ts b/apps/discord-bot/src/teams/attachments.ts new file mode 100644 index 000000000000..f5d9de9b3a1d --- /dev/null +++ b/apps/discord-bot/src/teams/attachments.ts @@ -0,0 +1,147 @@ +// @effect-diagnostics globalFetch:off +import type { UploadChatAttachment } from "@t3tools/contracts"; +import { PROVIDER_SEND_TURN_MAX_IMAGE_BYTES } from "@t3tools/contracts"; + +import type { DiscordUploadFile } from "../presentation/discordFiles.ts"; +import type { TeamsMessage } from "./presentation.ts"; + +export interface TeamsImageDownloadResult { + readonly discordFiles: ReadonlyArray; + readonly t3Uploads: ReadonlyArray; + readonly skipped: ReadonlyArray<{ + readonly name: string; + readonly reason: string; + }>; +} + +function extensionFromName(name: string): string { + const match = /\.([a-z0-9]+)$/iu.exec(name.trim()); + return match?.[1]?.toLowerCase() ?? ""; +} + +function guessImageMimeType(input: { + readonly name: string; + readonly contentType?: string | undefined; +}): string | null { + const contentType = input.contentType?.trim().toLowerCase(); + if (contentType?.startsWith("image/")) return contentType; + + return ( + { + png: "image/png", + jpg: "image/jpeg", + jpeg: "image/jpeg", + gif: "image/gif", + webp: "image/webp", + bmp: "image/bmp", + svg: "image/svg+xml", + heic: "image/heic", + heif: "image/heif", + }[extensionFromName(input.name)] ?? null + ); +} + +function base64DataUrl(bytes: Uint8Array, mimeType: string): string { + return `data:${mimeType};base64,${Buffer.from(bytes).toString("base64")}`; +} + +async function fetchBytes(input: { + readonly url: string; + readonly accessToken?: string | undefined; +}): Promise { + const withAuth = input.accessToken + ? ({ + authorization: `Bearer ${input.accessToken}`, + } satisfies HeadersInit) + : undefined; + const response = await globalThis.fetch(input.url, withAuth ? { headers: withAuth } : undefined); + if (!response.ok) { + throw new Error(`${response.status} ${response.statusText}`); + } + return new Uint8Array(await response.arrayBuffer()); +} + +export async function downloadTeamsMessageImages(input: { + readonly message: TeamsMessage; + readonly accessToken: string; + readonly hostedContentEntries: ReadonlyArray<{ + readonly id: string; + readonly contentType?: string | undefined; + readonly valueUrl: string; + }>; +}): Promise { + const discordFiles: DiscordUploadFile[] = []; + const t3Uploads: UploadChatAttachment[] = []; + const skipped: Array<{ readonly name: string; readonly reason: string }> = []; + + const pushImage = (name: string, mimeType: string, bytes: Uint8Array) => { + discordFiles.push({ + name, + mimeType, + data: bytes, + }); + if (bytes.byteLength <= PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) { + t3Uploads.push({ + type: "image", + name, + mimeType, + sizeBytes: bytes.byteLength, + dataUrl: base64DataUrl(bytes, mimeType), + }); + } else { + skipped.push({ + name, + reason: `too large for T3 upload (${bytes.byteLength} bytes)`, + }); + } + }; + + for (const attachment of input.message.attachments ?? []) { + const name = attachment.name?.trim() || "teams-image"; + const mimeType = guessImageMimeType({ + name, + contentType: attachment.contentType, + }); + const url = attachment.contentUrl ?? attachment.thumbnailUrl ?? ""; + if (mimeType === null || url.trim() === "") continue; + + try { + const bytes = await fetchBytes({ + url, + accessToken: input.accessToken, + }); + pushImage(name, mimeType, bytes); + } catch (error) { + skipped.push({ + name, + reason: error instanceof Error ? error.message : String(error), + }); + } + } + + for (const hostedContent of input.hostedContentEntries) { + const mimeType = hostedContent.contentType?.trim().toLowerCase(); + if (!mimeType?.startsWith("image/")) continue; + + const extension = mimeType.split("/")[1]?.replace(/[^a-z0-9]+/giu, "") || "png"; + const name = `teams-inline-${hostedContent.id}.${extension}`; + try { + const bytes = await fetchBytes({ + url: hostedContent.valueUrl, + accessToken: input.accessToken, + }); + pushImage(name, mimeType, bytes); + } catch (error) { + skipped.push({ + name, + reason: error instanceof Error ? error.message : String(error), + }); + } + } + + return { + discordFiles, + t3Uploads, + skipped, + }; +} diff --git a/apps/discord-bot/src/teams/config.test.ts b/apps/discord-bot/src/teams/config.test.ts new file mode 100644 index 000000000000..50ebca1ed6a0 --- /dev/null +++ b/apps/discord-bot/src/teams/config.test.ts @@ -0,0 +1,80 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { afterEach, describe, expect, it } from "vite-plus/test"; + +import { loadTeamsChannelConfigsFromFileSync } from "./config.ts"; + +const tempDirs: string[] = []; + +afterEach(async () => { + await Promise.all( + tempDirs.splice(0).map((dir) => NodeFSP.rm(dir, { recursive: true, force: true })), + ); +}); + +describe("loadTeamsChannelConfigsFromFileSync", () => { + it("loads root channels arrays", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "teams-config-")); + tempDirs.push(dir); + const filePath = NodePath.join(dir, "teams.json"); + await NodeFSP.writeFile( + filePath, + JSON.stringify([ + { + teamId: "team-1", + channelId: "channel-1", + channelName: "Prod", + projectShortName: "MACS-SCANNER", + discordChannelId: "123", + company: "Acme", + environment: "prod", + companyKeywords: ["acme"], + environmentKeywords: ["prod"], + automaticAssessmentEnabled: false, + internalUserIds: [" user-1 ", "user-2"], + reactionTriggerTypes: [" Eyes ", "🚨"], + messageTagTriggers: [" #Investigate ", "#triage"], + }, + ]), + "utf8", + ); + + const configs = loadTeamsChannelConfigsFromFileSync(filePath); + expect(configs).toHaveLength(1); + expect(configs[0]?.projectShortName).toBe("macs-scanner"); + expect(configs[0]?.automaticAssessmentEnabled).toBe(false); + expect(configs[0]?.internalUserIds).toEqual(["user-1", "user-2"]); + expect(configs[0]?.reactionTriggerTypes).toEqual(["eyes", "🚨"]); + expect(configs[0]?.messageTagTriggers).toEqual(["#investigate", "#triage"]); + expect(configs[0]?.deliveryMode).toBe("discord"); + }); + + it("supports Discord-free native channel mappings", async () => { + const dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "teams-config-")); + tempDirs.push(dir); + const filePath = NodePath.join(dir, "teams.json"); + await NodeFSP.writeFile( + filePath, + JSON.stringify([ + { + teamId: "team-1", + channelId: "channel-1", + channelName: "Prod", + projectShortName: "scanner", + deliveryMode: "native", + company: "Acme", + environment: "prod", + companyKeywords: ["acme"], + environmentKeywords: ["prod"], + }, + ]), + "utf8", + ); + + const configs = loadTeamsChannelConfigsFromFileSync(filePath); + expect(configs[0]?.deliveryMode).toBe("native"); + expect(configs[0]?.discordChannelId).toBeUndefined(); + }); +}); diff --git a/apps/discord-bot/src/teams/config.ts b/apps/discord-bot/src/teams/config.ts new file mode 100644 index 000000000000..7ceaf9a7b4d0 --- /dev/null +++ b/apps/discord-bot/src/teams/config.ts @@ -0,0 +1,128 @@ +// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off tryCatchInEffectGen:off +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; + +import { expandHomePath } from "../projectAliases.ts"; + +export interface TeamsChannelConfig { + readonly teamId: string; + readonly channelId: string; + readonly channelName: string; + readonly projectShortName: string; + readonly discordChannelId?: string | undefined; + /** + * discord: mirror into a Discord thread (legacy compatibility). + * t3-only: start T3 directly and acknowledge through the optional Teams workflow webhook. + * native: native Teams activities own replies; Graph polling only supplies ambient triggers. + */ + readonly deliveryMode?: "discord" | "t3-only" | "native" | undefined; + readonly company: string; + readonly environment: string; + readonly companyKeywords: ReadonlyArray; + readonly environmentKeywords: ReadonlyArray; + readonly problemKeywords?: ReadonlyArray | undefined; + readonly automaticAssessmentEnabled?: boolean | undefined; + readonly internalUserIds?: ReadonlyArray | undefined; + readonly reactionTriggerTypes?: ReadonlyArray | undefined; + readonly messageTagTriggers?: ReadonlyArray | undefined; + readonly respondToMentions?: boolean | undefined; + readonly teamsIncomingWebhookUrl?: string | undefined; +} + +function isStringArray(value: unknown): value is ReadonlyArray { + return Array.isArray(value) && value.every((item) => typeof item === "string"); +} + +function isChannelConfig(value: unknown): value is TeamsChannelConfig { + if (typeof value !== "object" || value === null || Array.isArray(value)) return false; + const candidate = value as Record; + return ( + typeof candidate.teamId === "string" && + typeof candidate.channelId === "string" && + typeof candidate.channelName === "string" && + typeof candidate.projectShortName === "string" && + (candidate.discordChannelId === undefined || typeof candidate.discordChannelId === "string") && + (candidate.deliveryMode === undefined || + candidate.deliveryMode === "discord" || + candidate.deliveryMode === "t3-only" || + candidate.deliveryMode === "native") && + typeof candidate.company === "string" && + typeof candidate.environment === "string" && + isStringArray(candidate.companyKeywords) && + isStringArray(candidate.environmentKeywords) && + (candidate.problemKeywords === undefined || isStringArray(candidate.problemKeywords)) && + (candidate.automaticAssessmentEnabled === undefined || + typeof candidate.automaticAssessmentEnabled === "boolean") && + (candidate.internalUserIds === undefined || isStringArray(candidate.internalUserIds)) && + (candidate.reactionTriggerTypes === undefined || + isStringArray(candidate.reactionTriggerTypes)) && + (candidate.messageTagTriggers === undefined || isStringArray(candidate.messageTagTriggers)) && + (candidate.respondToMentions === undefined || + typeof candidate.respondToMentions === "boolean") && + (candidate.teamsIncomingWebhookUrl === undefined || + typeof candidate.teamsIncomingWebhookUrl === "string") + ); +} + +export function loadTeamsChannelConfigsFromFileSync( + filePath: string, +): ReadonlyArray { + const resolvedPath = NodePath.resolve(expandHomePath(filePath.trim())); + const raw = NodeFS.readFileSync(resolvedPath, "utf8").trim(); + if (raw.length === 0) return []; + + const parsed = JSON.parse(raw) as unknown; + const channels = Array.isArray(parsed) + ? parsed + : typeof parsed === "object" && + parsed !== null && + "channels" in parsed && + Array.isArray((parsed as { channels?: unknown }).channels) + ? (parsed as { channels: ReadonlyArray }).channels + : null; + if (channels === null || !channels.every(isChannelConfig)) { + throw new Error("Teams channel config file must be an array of valid channel objects."); + } + + return channels.map((channel) => ({ + ...channel, + deliveryMode: + channel.deliveryMode ?? (channel.discordChannelId === undefined ? "t3-only" : "discord"), + projectShortName: channel.projectShortName.trim().toLowerCase(), + companyKeywords: channel.companyKeywords.map((value: string) => value.trim()).filter(Boolean), + environmentKeywords: channel.environmentKeywords + .map((value: string) => value.trim()) + .filter(Boolean), + ...(channel.problemKeywords === undefined + ? {} + : { + problemKeywords: channel.problemKeywords + .map((value: string) => value.trim()) + .filter(Boolean), + }), + ...(channel.automaticAssessmentEnabled === undefined + ? {} + : { automaticAssessmentEnabled: channel.automaticAssessmentEnabled }), + ...(channel.internalUserIds === undefined + ? {} + : { + internalUserIds: channel.internalUserIds + .map((value: string) => value.trim()) + .filter(Boolean), + }), + ...(channel.reactionTriggerTypes === undefined + ? {} + : { + reactionTriggerTypes: channel.reactionTriggerTypes + .map((value: string) => value.trim().toLowerCase()) + .filter(Boolean), + }), + ...(channel.messageTagTriggers === undefined + ? {} + : { + messageTagTriggers: channel.messageTagTriggers + .map((value: string) => value.trim().toLowerCase()) + .filter(Boolean), + }), + })); +} diff --git a/apps/discord-bot/src/teams/presentation.test.ts b/apps/discord-bot/src/teams/presentation.test.ts new file mode 100644 index 000000000000..9bd37b0f7102 --- /dev/null +++ b/apps/discord-bot/src/teams/presentation.test.ts @@ -0,0 +1,80 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + hasAllowlistedReaction, + hasInternalTagTrigger, + looksLikeGermanProblemReport, + teamsMessageText, +} from "./presentation.ts"; + +describe("teamsMessageText", () => { + it("strips html", () => { + expect( + teamsMessageText({ + id: "1", + body: { content: "
Hallo Welt & mehr
" }, + }), + ).toBe("Hallo Welt & mehr"); + }); +}); + +describe("looksLikeGermanProblemReport", () => { + it("matches german production incidents", () => { + expect( + looksLikeGermanProblemReport({ + message: { + id: "1", + body: { content: "Beim Kunden Acme gibt es seit heute einen Fehler in Produktion." }, + }, + companyKeywords: ["Acme"], + environmentKeywords: ["Produktion"], + }), + ).toBe(true); + }); +}); + +describe("hasAllowlistedReaction", () => { + it("matches configured reactions from allowlisted users", () => { + expect( + hasAllowlistedReaction({ + message: { + id: "1", + reactions: [ + { + reactionType: "eyes", + user: { + user: { + id: "internal-user", + }, + }, + }, + ], + }, + allowlistedUserIds: ["internal-user"], + reactionTriggerTypes: ["eyes"], + }), + ).toBe(true); + }); +}); + +describe("hasInternalTagTrigger", () => { + it("matches tag commands from allowlisted users", () => { + expect( + hasInternalTagTrigger({ + message: { + id: "1", + from: { + user: { + id: "internal-user", + }, + }, + body: { + content: "Please take this one #investigate", + }, + }, + allowlistedUserIds: ["internal-user"], + messageTagTriggers: ["#investigate"], + }), + ).toBe(true); + }); +}); diff --git a/apps/discord-bot/src/teams/presentation.ts b/apps/discord-bot/src/teams/presentation.ts new file mode 100644 index 000000000000..0b559d230113 --- /dev/null +++ b/apps/discord-bot/src/teams/presentation.ts @@ -0,0 +1,338 @@ +export interface TeamsMessageAuthor { + readonly id?: string | undefined; + readonly displayName?: string | undefined; +} + +export interface TeamsMessage { + readonly id: string; + readonly replyToId?: string | null | undefined; + readonly createdDateTime?: string | undefined; + readonly subject?: string | null | undefined; + readonly summary?: string | null | undefined; + readonly webUrl?: string | undefined; + readonly messageType?: string | undefined; + readonly from?: + | { + readonly user?: TeamsMessageAuthor | null | undefined; + readonly application?: { readonly displayName?: string | undefined } | null | undefined; + } + | null + | undefined; + readonly body?: + | { + readonly contentType?: string | undefined; + readonly content?: string | null | undefined; + } + | null + | undefined; + readonly attachments?: + | ReadonlyArray<{ + readonly id?: string | undefined; + readonly contentType?: string | undefined; + readonly contentUrl?: string | undefined; + readonly name?: string | undefined; + readonly thumbnailUrl?: string | undefined; + }> + | undefined; + readonly reactions?: + | ReadonlyArray<{ + readonly reactionType?: string | undefined; + readonly displayName?: string | undefined; + readonly user?: + | { + readonly user?: + | { + readonly id?: string | undefined; + readonly displayName?: string | undefined; + } + | null + | undefined; + } + | null + | undefined; + }> + | undefined; + readonly mentions?: + | ReadonlyArray<{ + readonly mentionText?: string | undefined; + readonly mentioned?: + | { + readonly user?: TeamsMessageAuthor | null | undefined; + readonly application?: + | { readonly displayName?: string | undefined } + | null + | undefined; + } + | null + | undefined; + }> + | undefined; +} + +const DEFAULT_GERMAN_PROBLEM_KEYWORDS = [ + "fehler", + "störung", + "stoerung", + "problem", + "kaputt", + "funktioniert nicht", + "geht nicht", + "ausfall", + "dringend", + "hilfe", + "betroffen", + "unterbrochen", + "broken", + "incident", +] as const; + +const GERMAN_MARKERS = [ + "der", + "die", + "das", + "nicht", + "bitte", + "kann", + "können", + "koennen", + "seit", + "heute", + "gestern", + "kunde", + "umgebung", + "produktion", +] as const; + +export function teamsMessageText(message: TeamsMessage): string { + const content = message.body?.content ?? ""; + return decodeHtmlEntities( + content + .replace(//giu, " ") + .replace(//giu, " ") + .replace(/<[^>]+>/gu, " ") + .replace(/\s+/gu, " ") + .trim(), + ) + .replace(/\s+/gu, " ") + .trim(); +} + +function normalizedText(value: string | undefined | null): string { + return (value ?? "").trim().toLowerCase(); +} + +function decodeHtmlEntities(value: string): string { + return value + .replaceAll(" ", " ") + .replaceAll("&", "&") + .replaceAll("<", "<") + .replaceAll(">", ">") + .replaceAll(""", '"') + .replaceAll("'", "'"); +} + +export function rootTeamsMessageId(message: TeamsMessage): string { + return message.replyToId ?? message.id; +} + +export function teamsMessageTimestamp(message: TeamsMessage): string { + return message.createdDateTime ?? ""; +} + +export function isHumanTeamsMessage(message: TeamsMessage): boolean { + if (message.messageType && message.messageType !== "message") return false; + if (message.from?.application) return false; + return teamsMessageText(message).trim().length > 0; +} + +export function mentionsTeamsBot(message: TeamsMessage, displayName: string | undefined): boolean { + const normalizedDisplayName = normalizedText(displayName); + if ( + normalizedDisplayName.length > 0 && + message.mentions?.some((mention) => { + const names = [ + mention.mentionText, + mention.mentioned?.application?.displayName, + mention.mentioned?.user?.displayName, + ] + .filter((value): value is string => typeof value === "string") + .map((value) => normalizedText(value)); + return names.includes(normalizedDisplayName); + }) + ) { + return true; + } + + const text = normalizedText(teamsMessageText(message)); + return normalizedDisplayName.length > 0 ? text.includes(normalizedDisplayName) : false; +} + +export function looksLikeGermanProblemReport(input: { + readonly message: TeamsMessage; + readonly companyKeywords: ReadonlyArray; + readonly environmentKeywords: ReadonlyArray; + readonly problemKeywords?: ReadonlyArray | undefined; +}): boolean { + const text = teamsMessageText(input.message).toLowerCase(); + if (text.length === 0) return false; + + const germanMarkerHits = GERMAN_MARKERS.filter((marker) => text.includes(marker)).length; + const umlautHint = /[äöüß]/iu.test(text); + const germanish = umlautHint || germanMarkerHits >= 2; + if (!germanish) return false; + + const companyHit = input.companyKeywords.some((keyword) => text.includes(keyword.toLowerCase())); + const environmentHit = input.environmentKeywords.some((keyword) => + text.includes(keyword.toLowerCase()), + ); + const problemHit = [...DEFAULT_GERMAN_PROBLEM_KEYWORDS, ...(input.problemKeywords ?? [])].some( + (keyword) => text.includes(keyword.toLowerCase()), + ); + + return problemHit && (companyHit || environmentHit); +} + +export function isAllowlistedInternalUser( + message: TeamsMessage, + allowlistedUserIds: ReadonlyArray | undefined, +): boolean { + const authorId = normalizedText(message.from?.user?.id); + return ( + authorId.length > 0 && (allowlistedUserIds ?? []).some((id) => normalizedText(id) === authorId) + ); +} + +export function hasAllowlistedReaction(input: { + readonly message: TeamsMessage; + readonly allowlistedUserIds?: ReadonlyArray | undefined; + readonly reactionTriggerTypes?: ReadonlyArray | undefined; +}): boolean { + if ((input.reactionTriggerTypes ?? []).length === 0) return false; + + return (input.message.reactions ?? []).some((reaction) => { + const reactionType = normalizedText(reaction.reactionType); + const reactingUserId = normalizedText(reaction.user?.user?.id); + if (reactionType.length === 0 || reactingUserId.length === 0) return false; + const typeMatch = (input.reactionTriggerTypes ?? []).some( + (trigger) => normalizedText(trigger) === reactionType, + ); + const userMatch = (input.allowlistedUserIds ?? []).some( + (userId) => normalizedText(userId) === reactingUserId, + ); + return typeMatch && userMatch; + }); +} + +export function hasInternalTagTrigger(input: { + readonly message: TeamsMessage; + readonly allowlistedUserIds?: ReadonlyArray | undefined; + readonly messageTagTriggers?: ReadonlyArray | undefined; +}): boolean { + if (!isAllowlistedInternalUser(input.message, input.allowlistedUserIds)) return false; + const text = normalizedText(teamsMessageText(input.message)); + return (input.messageTagTriggers ?? []).some((tag) => { + const normalizedTag = normalizedText(tag); + return normalizedTag.length > 0 && text.includes(normalizedTag); + }); +} + +export function buildTeamsIncidentTitle(input: { + readonly company: string; + readonly environment: string; + readonly message: TeamsMessage; +}): string { + const text = teamsMessageText(input.message).replace(/\s+/gu, " ").trim(); + const summary = text.length > 96 ? `${text.slice(0, 95).trimEnd()}…` : text; + return `${input.company} ${input.environment}: ${summary || "Teams incident"}`; +} + +export function buildTeamsSeedMessage(input: { + readonly company: string; + readonly environment: string; + readonly channelName: string; + readonly message: TeamsMessage; + readonly reason: "mention" | "german-problem" | "allowlisted-reaction" | "internal-tag"; +}): string { + const author = input.message.from?.user?.displayName ?? "unknown"; + const text = teamsMessageText(input.message); + const triggerLabel = + input.reason === "mention" + ? "@mention" + : input.reason === "german-problem" + ? "German problem report" + : input.reason === "allowlisted-reaction" + ? "allowlisted reaction" + : "allowlisted internal tag"; + return [ + `**Teams intake** from **${input.channelName}**`, + `Company: **${input.company}**`, + `Environment: **${input.environment}**`, + `Trigger: ${triggerLabel}`, + `Author: ${author}`, + input.message.webUrl ? `Source: ${input.message.webUrl}` : null, + "", + text, + ] + .filter((line): line is string => line !== null) + .join("\n"); +} + +export function buildTeamsPrompt(input: { + readonly channelName: string; + readonly company: string; + readonly environment: string; + readonly projectShortName: string; + readonly reason: "mention" | "german-problem" | "allowlisted-reaction" | "internal-tag"; + readonly message: TeamsMessage; + readonly triggerMessage?: TeamsMessage | undefined; + readonly history?: ReadonlyArray | undefined; +}): string { + const text = teamsMessageText(input.message); + const author = input.message.from?.user?.displayName ?? "unknown"; + const triggerText = + input.reason === "mention" + ? "explicit @mention" + : input.reason === "german-problem" + ? "German problem report detection" + : input.reason === "allowlisted-reaction" + ? "allowlisted reaction trigger" + : "allowlisted internal tag trigger"; + const history = (input.history ?? []) + .map((message) => { + const entryAuthor = message.from?.user?.displayName ?? "unknown"; + const when = message.createdDateTime ?? "unknown time"; + const body = teamsMessageText(message); + return `[${when}] ${entryAuthor}: ${body}`; + }) + .join("\n"); + + return `## Microsoft Teams intake + +Project short name: ${input.projectShortName} +Company: ${input.company} +Environment: ${input.environment} +Teams channel: ${input.channelName} +Trigger: ${triggerText} +Author: ${author} +Message id: ${input.message.id} +${input.message.replyToId ? `Reply to: ${input.message.replyToId}` : "Root message: yes"} +${input.message.webUrl ? `Source URL: ${input.message.webUrl}` : "Source URL: unavailable"} + +${ + input.triggerMessage && input.triggerMessage.id !== input.message.id + ? `Trigger message id: ${input.triggerMessage.id} +Trigger message author: ${input.triggerMessage.from?.user?.displayName ?? "unknown"} +Trigger message text: ${teamsMessageText(input.triggerMessage)}` + : "" +} + +## Original Teams message +${text} + +## Recent channel history +${history.length > 0 ? history : "(no recent preceding messages in scope)"} + +## Task +Treat this as an incident intake from Teams. Infer the likely user problem from the German text, investigate it, and post the analysis into this Discord thread. +If details are ambiguous, say so explicitly instead of inventing specifics.`; +} diff --git a/apps/discord-bot/teams-app/README.md b/apps/discord-bot/teams-app/README.md new file mode 100644 index 000000000000..b3db5c7da3dd --- /dev/null +++ b/apps/discord-bot/teams-app/README.md @@ -0,0 +1,11 @@ +# Teams app package + +Before zipping this directory: + +1. Replace `${TEAMS_APP_ID}` and `${TEAMS_CLIENT_ID}` with the app/client ID. +2. Replace `${PUBLIC_BASE_URL}` and `${PUBLIC_HOST}` with the public HTTPS origin and host. +3. Add a transparent 32×32 `outline.png` and a full-color 192×192 `color.png`. +4. Zip `manifest.json`, `outline.png`, and `color.png` at the archive root. + +The app sends activities to the Azure Bot messaging endpoint configured separately as +`https:///api/messages`. diff --git a/apps/discord-bot/teams-app/manifest.json b/apps/discord-bot/teams-app/manifest.json new file mode 100644 index 000000000000..14b6f570bfa0 --- /dev/null +++ b/apps/discord-bot/teams-app/manifest.json @@ -0,0 +1,76 @@ +{ + "$schema": "https://developer.microsoft.com/json-schemas/teams/v1.23/MicrosoftTeams.schema.json", + "manifestVersion": "1.23", + "version": "1.0.0", + "id": "${TEAMS_APP_ID}", + "developer": { + "name": "T3 Code", + "websiteUrl": "${PUBLIC_BASE_URL}", + "privacyUrl": "${PUBLIC_BASE_URL}/privacy", + "termsOfUseUrl": "${PUBLIC_BASE_URL}/terms" + }, + "name": { + "short": "T3 Code", + "full": "T3 Code engineering agent" + }, + "description": { + "short": "Start and continue T3 Code work from Microsoft Teams.", + "full": "Runs T3 Code engineering sessions from Teams conversations or from the Start T3 investigation message action." + }, + "icons": { + "outline": "outline.png", + "color": "color.png" + }, + "accentColor": "#5B5FC7", + "bots": [ + { + "botId": "${TEAMS_CLIENT_ID}", + "scopes": ["personal", "team", "groupChat"], + "supportsFiles": true, + "isNotificationOnly": false, + "supportsCalling": false, + "supportsVideo": false, + "commandLists": [ + { + "scopes": ["personal", "team", "groupChat"], + "commands": [ + { + "title": "stop", + "description": "Stop the active T3 turn in this conversation." + }, + { + "title": "approve", + "description": "Approve a pending T3 request by request id." + }, + { + "title": "deny", + "description": "Deny a pending T3 request by request id." + }, + { + "title": "answer", + "description": "Answer a T3 user-input request with a JSON object." + } + ] + } + ] + } + ], + "composeExtensions": [ + { + "botId": "${TEAMS_CLIENT_ID}", + "commands": [ + { + "id": "startT3Investigation", + "type": "action", + "title": "Start T3 investigation", + "description": "Start a T3 investigation from the selected message.", + "initialRun": false, + "fetchTask": true, + "context": ["message"] + } + ] + } + ], + "permissions": ["identity", "messageTeamMembers"], + "validDomains": ["${PUBLIC_HOST}"] +} diff --git a/apps/discord-bot/teams.channels.example.json b/apps/discord-bot/teams.channels.example.json new file mode 100644 index 000000000000..4d7d8f163a03 --- /dev/null +++ b/apps/discord-bot/teams.channels.example.json @@ -0,0 +1,22 @@ +{ + "channels": [ + { + "teamId": "00000000-0000-0000-0000-000000000000", + "channelId": "19:examplechannel@thread.tacv2", + "channelName": "Acme Prod Incidents", + "projectShortName": "macs-scanner", + "deliveryMode": "native", + "company": "Acme", + "environment": "prod", + "companyKeywords": ["acme", "kunde acme"], + "environmentKeywords": ["prod", "produktion", "live"], + "problemKeywords": ["fehler", "störung", "ausfall", "geht nicht"], + "automaticAssessmentEnabled": true, + "internalUserIds": ["11111111-1111-1111-1111-111111111111"], + "reactionTriggerTypes": ["eyes", "🚨"], + "messageTagTriggers": ["#investigate", "#triage"], + "respondToMentions": true, + "teamsIncomingWebhookUrl": "https://example.webhook.office.com/webhookb2/..." + } + ] +} diff --git a/apps/discord-bot/tsconfig.json b/apps/discord-bot/tsconfig.json new file mode 100644 index 000000000000..d3081eb428ae --- /dev/null +++ b/apps/discord-bot/tsconfig.json @@ -0,0 +1,8 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "rootDir": "src", + "types": ["node"] + }, + "include": ["src"] +} diff --git a/apps/discord-bot/vite.config.ts b/apps/discord-bot/vite.config.ts new file mode 100644 index 000000000000..74055a558f66 --- /dev/null +++ b/apps/discord-bot/vite.config.ts @@ -0,0 +1,7 @@ +import { defineConfig } from "vite-plus"; + +export default defineConfig({ + test: { + include: ["src/**/*.test.ts"], + }, +}); diff --git a/apps/mobile/README.md b/apps/mobile/README.md index a9a8177c4ece..7ed242b1f307 100644 --- a/apps/mobile/README.md +++ b/apps/mobile/README.md @@ -20,6 +20,39 @@ T3 Connect is optional and disabled in a fresh clone. Public configuration belon repository-root `.env` or `.env.local`, not an `apps/mobile/.env` file. See [`../../.env.example`](../../.env.example). +To sign a fork with your own Apple Developer account, set +`T3CODE_MOBILE_IOS_TEAM_ID`, `T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER`, +`T3CODE_MOBILE_EAS_PROJECT_ID`, and `T3CODE_MOBILE_EXPO_OWNER` in the repository-root +`.env.local`. Development and preview builds append `.dev` and `.preview` to your bundle +identifier. Run `eas init` once under your Expo account to create the project ID, then use +the existing EAS iOS build commands below. EAS can perform the build remotely; a local +`ios:*` build still requires macOS and Xcode. + +### Free Apple Personal Team build + +For temporary testing on your own iPhone, a borrowed Mac and a free Apple Account are enough. +This mode removes capabilities that a Personal Team cannot sign: widgets and Live Activities, +push notifications, App Groups, associated domains, and EAS updates. Apple expires free +provisioning profiles after seven days, so the app must then be rebuilt and reinstalled. + +On the Mac: + +1. Install Xcode, open it once, accept its license, and add your Apple Account under + **Xcode → Settings → Accounts**. +2. Enable **Developer Mode** on the iPhone and connect it to the Mac by USB. +3. Set `T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER=com.example.t3code` in the repository-root + `.env.local`. `T3CODE_MOBILE_IOS_TEAM_ID` is optional; leave it unset to select your + Personal Team interactively in Xcode. +4. From `apps/mobile`, run `vp run config:personal` to confirm that `associatedDomains` and + the `expo-widgets` plugin are absent. +5. Run `vp run ios:personal`. If Xcode requests a team, open `ios/T3Code.xcworkspace`, select + the main T3Code target, choose **Signing & Capabilities → Team → your name (Personal + Team)**, select your iPhone as the run destination, and press **Run** in Xcode. Do not run + the clean prebuild command again after choosing the team, because it regenerates `ios/`. + +The personal build uses a separate development bundle ID, so it remains +separate from a future production build. + ## Development Start Metro for the dev client: @@ -106,9 +139,9 @@ The native lint task runs SwiftLint for Swift plus ktlint and detekt for Kotlin. ## EAS Builds -Preview and production variants use Expo fingerprinting so OTA updates only reach binaries with matching native dependencies, config plugins, and patches. CI uses the `preview:dev` profile to reuse a compatible native build when possible. +Preview and production variants use Expo fingerprinting so OTA updates only reach binaries with matching native dependencies, config plugins, and patches. CI uses the `preview` profile to reuse an existing compatible build when possible, or start a new internal EAS build when native runtime inputs change. That profile builds the release configuration, so labelled PR builds behave like production for performance and memory; use `preview:dev` when you want a dev client on the preview channel that attaches to local Metro. -The development variant uses `appVersion` to avoid recalculating the native fingerprint for each Metro launch manifest. `MOBILE_VERSION_POLICY` can override either default. If you distribute a custom Release build with the development identity and publish OTA updates to it, set `MOBILE_VERSION_POLICY=fingerprint` for both its build and updates. Changing the runtime policy requires a native rebuild for OTA matching; an existing dev client can still load local Metro bundles. +The development variant uses `appVersion` to avoid recalculating the native fingerprint for each Metro launch manifest. `MOBILE_VERSION_POLICY` can override either default. `MOBILE_RUNTIME_VERSION_OVERRIDE` pins an explicit runtime version when CI must ship pure-JS fixes to an already-installed binary (for example when the Free-plan build quota is exhausted). If you distribute a custom Release build with the development identity and publish OTA updates to it, set `MOBILE_VERSION_POLICY=fingerprint` for both its build and updates. Changing the runtime policy requires a native rebuild for OTA matching; an existing dev client can still load local Metro bundles. For preview or production EAS environments, set `T3CODE_CLERK_PUBLISHABLE_KEY`, `T3CODE_CLERK_JWT_TEMPLATE`, and `T3CODE_RELAY_URL` diff --git a/apps/mobile/app.config.ts b/apps/mobile/app.config.ts index f34f9c4b39d8..e4d28c027dfb 100644 --- a/apps/mobile/app.config.ts +++ b/apps/mobile/app.config.ts @@ -31,6 +31,14 @@ if ( "T3CODE_IOS_PERSONAL_TEAM_BUNDLE_ID must be a reverse-DNS identifier such as com.example.t3code when T3CODE_IOS_PERSONAL_TEAM=1.", ); } +const IOS_BUNDLE_IDENTIFIER = repoEnv.T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER ?? "com.t3tools.t3code"; +const IOS_TEAM_ID = isIosPersonalTeamBuild + ? repoEnv.T3CODE_MOBILE_IOS_TEAM_ID + : (repoEnv.T3CODE_MOBILE_IOS_TEAM_ID ?? "ARK85ZXQ4Z"); +const EXPO_OWNER = repoEnv.T3CODE_MOBILE_EXPO_OWNER ?? "pingdotgg"; +const EAS_PROJECT_ID = + repoEnv.T3CODE_MOBILE_EAS_PROJECT_ID ?? + (EXPO_OWNER === "pingdotgg" ? "d763fcb8-d37c-41ea-a773-b54a0ab4a454" : undefined); const DEVELOPMENT_ASSETS = { appIcon: fromRepoRoot(BRAND_ASSET_PATHS.developmentIosIconPng), @@ -75,7 +83,9 @@ const VARIANT_CONFIG = { development: { appName: "T3 Code Dev", scheme: "t3code-dev", - iosBundleIdentifier: "com.t3tools.t3code.dev", + iosIcon: "./assets/icon-composer-dev.icon", + splashIcon: "./assets/splash-icon-dev.png", + iosBundleIdentifier: `${IOS_BUNDLE_IDENTIFIER}.dev`, androidPackage: "com.t3tools.t3code.dev", relyingParty: "clerk.t3.codes", assets: DEVELOPMENT_ASSETS, @@ -83,7 +93,9 @@ const VARIANT_CONFIG = { preview: { appName: "T3 Code Preview", scheme: "t3code-preview", - iosBundleIdentifier: "com.t3tools.t3code.preview", + iosIcon: "./assets/icon-composer-prod.icon", + splashIcon: "./assets/splash-icon-prod.png", + iosBundleIdentifier: `${IOS_BUNDLE_IDENTIFIER}.preview`, androidPackage: "com.t3tools.t3code.preview", relyingParty: "clerk.t3.codes", assets: PREVIEW_ASSETS, @@ -91,7 +103,9 @@ const VARIANT_CONFIG = { production: { appName: "T3 Code", scheme: "t3code", - iosBundleIdentifier: "com.t3tools.t3code", + iosIcon: "./assets/icon-composer-prod.icon", + splashIcon: "./assets/splash-icon-prod.png", + iosBundleIdentifier: IOS_BUNDLE_IDENTIFIER, androidPackage: "com.t3tools.t3code", relyingParty: "clerk.t3.codes", assets: RELEASE_ASSETS, @@ -176,21 +190,32 @@ const config: ExpoConfig = { platforms: ["ios", "android"], scheme: variant.scheme, version: "1.1.1", - runtimeVersion: { - // Development manifests resolve on every launch, so avoid fingerprint's - // expensive native-project calculation there. Preview and production stay - // fingerprinted so OTAs only reach binaries with matching native projects. - policy: runtimeVersionPolicy, - }, + // Development manifests resolve on every launch, so avoid fingerprint's + // expensive native-project calculation there. Preview and production stay + // fingerprinted so OTAs only reach binaries with matching native projects. + // Override with MOBILE_RUNTIME_VERSION_OVERRIDE when CI must ship pure-JS + // fixes to an already-installed binary (e.g. Free-plan build quota exhausted). + runtimeVersion: (() => { + const override = process.env.MOBILE_RUNTIME_VERSION_OVERRIDE?.trim(); + if (override) { + return override; + } + return { + policy: runtimeVersionPolicy, + }; + })(), orientation: "portrait", icon: variant.assets.appIcon, userInterfaceStyle: "automatic", - updates: { - enabled: repoEnv.T3CODE_MOBILE_UPDATES_ENABLED !== "0", - url: "https://u.expo.dev/d763fcb8-d37c-41ea-a773-b54a0ab4a454", - checkAutomatically: "ON_LOAD", - fallbackToCacheTimeout: 0, - }, + updates: + EAS_PROJECT_ID === undefined + ? { enabled: false } + : { + enabled: !isIosPersonalTeamBuild && process.env.T3CODE_MOBILE_UPDATES_ENABLED !== "0", + url: `https://u.expo.dev/${EAS_PROJECT_ID}`, + checkAutomatically: "ON_LOAD", + fallbackToCacheTimeout: 0, + }, ios: { icon: variant.assets.iosIcon, supportsTablet: true, @@ -201,13 +226,17 @@ const config: ExpoConfig = { // Pin code signing to the T3 Tools team so non-interactive `expo run:ios` // does not fall back to a personal team (which cannot sign app groups, // Sign in with Apple, or push notification entitlements). - appleTeamId: "ARK85ZXQ4Z", - associatedDomains: [ - `applinks:${variant.relyingParty}`, - `webcredentials:${variant.relyingParty}`, - ], + ...(IOS_TEAM_ID ? { appleTeamId: IOS_TEAM_ID } : {}), + ...(isIosPersonalTeamBuild + ? {} + : { + associatedDomains: [ + `applinks:${variant.relyingParty}`, + `webcredentials:${variant.relyingParty}`, + ], + }), entitlements: { - "keychain-access-groups": [`$(AppIdentifierPrefix)${variant.iosBundleIdentifier}`], + "keychain-access-groups": [`$(AppIdentifierPrefix)${iosBundleIdentifier}`], }, infoPlist: { NSAppTransportSecurity: { @@ -413,11 +442,9 @@ const config: ExpoConfig = { tracesDataset: repoEnv.EXPO_PUBLIC_OTLP_TRACES_DATASET ?? null, tracesToken: repoEnv.EXPO_PUBLIC_OTLP_TRACES_TOKEN ?? null, }, - eas: { - projectId: "d763fcb8-d37c-41ea-a773-b54a0ab4a454", - }, + ...(EAS_PROJECT_ID === undefined ? {} : { eas: { projectId: EAS_PROJECT_ID } }), }, - owner: "pingdotgg", + owner: EXPO_OWNER, }; export default config; diff --git a/apps/mobile/eas.json b/apps/mobile/eas.json index a1d315b7e149..9f5d768e14c1 100644 --- a/apps/mobile/eas.json +++ b/apps/mobile/eas.json @@ -12,6 +12,7 @@ "NODE_OPTIONS": "--max-old-space-size=4096" }, "channel": "development", + "environment": "development", "developmentClient": true, "distribution": "internal" }, @@ -19,11 +20,15 @@ "corepack": true, "env": { "APP_VARIANT": "preview", + "MOBILE_VERSION_POLICY": "fingerprint", "NODE_OPTIONS": "--max-old-space-size=4096" }, "channel": "preview", "environment": "preview", - "distribution": "internal" + "distribution": "internal", + "android": { + "buildType": "apk" + } }, "preview:dev": { "corepack": true, @@ -44,7 +49,11 @@ "corepack": true, "env": { "APP_VARIANT": "production", - "NODE_OPTIONS": "--max-old-space-size=4096" + "NODE_OPTIONS": "--max-old-space-size=4096", + "T3CODE_MOBILE_EAS_PROJECT_ID": "731ac55d-f006-4a63-95ef-091c2146caeb", + "T3CODE_MOBILE_EXPO_OWNER": "patroza", + "T3CODE_MOBILE_IOS_BUNDLE_IDENTIFIER": "dev.patroza.t3code", + "T3CODE_MOBILE_IOS_TEAM_ID": "8B9VRZFRAA" }, "channel": "production", "environment": "production", @@ -54,7 +63,7 @@ "submit": { "production": { "ios": { - "ascAppId": "6787819824" + "ascAppId": "6794618314" }, "android": { "track": "internal" diff --git a/apps/mobile/modules/t3-markdown-text/src/NativeMarkdownBlock.tsx b/apps/mobile/modules/t3-markdown-text/src/NativeMarkdownBlock.tsx index ab75eaf32a2c..8b32032ec557 100644 --- a/apps/mobile/modules/t3-markdown-text/src/NativeMarkdownBlock.tsx +++ b/apps/mobile/modules/t3-markdown-text/src/NativeMarkdownBlock.tsx @@ -5,6 +5,7 @@ import type { MarkdownNode } from "react-native-nitro-markdown/headless"; import { CopyTextButton } from "./CopyTextButton"; import { MarkdownTextPrimitive } from "./MarkdownTextPrimitive"; import { nativeMarkdownDocumentRuns, nativeMarkdownListItemBlocks } from "./nativeMarkdownText"; +import { markdownNodeKey, markdownTableCellKey, markdownTableRowKey } from "./markdownNodeKey"; import { NativeMarkdownSelectableText } from "./NativeMarkdownSelectableText"; import type { MarkdownCodeHighlighter, @@ -29,7 +30,7 @@ const MONO_FONT_FAMILY = Platform.select({ }); function nodeKey(node: MarkdownNode, index: number): string { - return `${node.type}:${node.beg ?? index}:${node.end ?? index}`; + return markdownNodeKey(node, index); } /** Code inside markdown scales with the base text size (12pt at the default 15pt body). */ @@ -139,7 +140,9 @@ function useHighlightedCode( const cached = highlightedCodeCache.get(key); if (cached) { cacheHighlightedCode(key, cached); - setHighlighted({ key, tokens: cached }); + setHighlighted((current) => + current.key === key && current.tokens === cached ? current : { key, tokens: cached }, + ); return () => { active = false; }; @@ -353,7 +356,7 @@ function NativeTable(props: { > {rows.map((row, rowIndex) => ( {(row.children ?? []).map((cell, cellIndex) => ( &2 + exit 1 + ;; + esac +done + +if [[ -z "$PROFILE" || -z "$CHANNEL" ]]; then + echo "--profile and --channel are required" >&2 + exit 1 +fi + +if [[ ! "$PLATFORM" =~ ^(ios|android|all)$ ]]; then + echo "--platform must be ios, android, or all" >&2 + exit 1 +fi + +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +cd "$ROOT" + +# EAS CLI mixes human-readable notices into `--json` stdout, so every payload +# goes through this reader instead of a bare JSON.parse. See scripts/lib/eas-json.mjs. +EAS_JSON="$ROOT/scripts/lib/eas-json.mjs" +if [[ ! -f "$EAS_JSON" ]]; then + echo "Missing EAS JSON reader at $EAS_JSON" >&2 + exit 1 +fi + +if [[ -z "$MESSAGE" ]]; then + MESSAGE="EAS continuous deploy $(date -u +%Y-%m-%dT%H:%MZ) ${GITHUB_SHA:-local}" +fi + +platforms=() +if [[ "$PLATFORM" == "all" ]]; then + platforms=(ios android) +else + platforms=("$PLATFORM") +fi + +generate_fingerprint() { + local platform="$1" + local args=(fingerprint:generate --platform "$platform" --json --non-interactive) + if [[ -n "$ENVIRONMENT" ]]; then + args+=(--environment "$ENVIRONMENT") + else + args+=(--build-profile "$PROFILE") + fi + # JSON on stdout; progress (and stray notices) mixed in — the reader tolerates both + eas "${args[@]}" | node "$EAS_JSON" fingerprint-hash +} + +find_matching_build() { + local platform="$1" + local runtime="$2" + eas build:list \ + --platform "$platform" \ + --build-profile "$PROFILE" \ + --runtime-version "$runtime" \ + --limit 5 \ + --json \ + --non-interactive \ + | node "$EAS_JSON" usable-build-id +} + +latest_finished_runtime() { + local platform="$1" + eas build:list \ + --platform "$platform" \ + --build-profile "$PROFILE" \ + --status finished \ + --limit 1 \ + --json \ + --non-interactive \ + | node "$EAS_JSON" latest-finished-runtime +} + +publish_update() { + local platform="$1" + local runtime_override="${2:-}" + local msg="$3" + local env_args=() + if [[ -n "$ENVIRONMENT" ]]; then + env_args+=(--environment "$ENVIRONMENT") + fi + if [[ -n "$runtime_override" ]]; then + echo "Publishing OTA for platform=$platform runtimeVersion=$runtime_override (override)" + MOBILE_RUNTIME_VERSION_OVERRIDE="$runtime_override" eas update \ + --channel "$CHANNEL" \ + --platform "$platform" \ + --message "$msg" \ + --non-interactive \ + "${env_args[@]}" + else + echo "Publishing OTA for platform=$platform (fingerprint policy)" + unset MOBILE_RUNTIME_VERSION_OVERRIDE || true + eas update \ + --channel "$CHANNEL" \ + --platform "$platform" \ + --message "$msg" \ + --non-interactive \ + "${env_args[@]}" + fi +} + +try_build() { + local platform="$1" + local args=( + build + --platform "$platform" + --profile "$PROFILE" + --non-interactive + --no-wait + ) + if [[ "$AUTO_SUBMIT" -eq 1 ]]; then + args+=(--auto-submit) + fi + echo "Starting eas build: ${args[*]}" + # Capture output so Free-plan / credential errors are visible in CI logs + if eas "${args[@]}"; then + return 0 + fi + return 1 +} + +for platform in "${platforms[@]}"; do + echo "==== platform: $platform ====" + + if [[ -n "$FORCE_RUNTIME" ]]; then + publish_update "$platform" "$FORCE_RUNTIME" "$MESSAGE (forced runtime $FORCE_RUNTIME)" + continue + fi + + echo "Generating fingerprint..." + fingerprint="$(generate_fingerprint "$platform")" + echo "$platform fingerprint: $fingerprint" + + echo "Looking for builds with runtimeVersion=$fingerprint ..." + build_id="$(find_matching_build "$platform" "$fingerprint" || true)" + if [[ -n "$build_id" ]]; then + echo "Existing build found: $build_id — publishing OTA only" + publish_update "$platform" "" "$MESSAGE" + continue + fi + + echo "No matching build for fingerprint $fingerprint — attempting native build" + if try_build "$platform"; then + echo "Native build queued; publishing OTA for current fingerprint so it is ready when the binary finishes" + publish_update "$platform" "" "$MESSAGE" + continue + fi + + echo "Native build failed (often Expo Free plan monthly iOS quota or credentials)." + echo "Falling back to OTA against the latest finished $PROFILE $platform binary runtime." + fallback="$(latest_finished_runtime "$platform" || true)" + if [[ -z "$fallback" ]]; then + echo "ERROR: no finished $PROFILE $platform builds found to target for fallback OTA" >&2 + exit 1 + fi + if [[ "$fallback" == "$fingerprint" ]]; then + echo "Latest finished runtime equals current fingerprint but no matching build list hit; publishing with fingerprint policy" + publish_update "$platform" "" "$MESSAGE (fallback)" + else + echo "Fallback runtimeVersion: $fallback (installed clients will receive pure-JS fixes)" + echo "NOTE: native-input changes in this tip will not land until a new binary is built for $fingerprint" + publish_update "$platform" "$fallback" "$MESSAGE (fallback runtime $fallback; tip fingerprint $fingerprint)" + fi +done + +echo "eas-continuous-deploy finished successfully" diff --git a/apps/mobile/scripts/lib/eas-json.mjs b/apps/mobile/scripts/lib/eas-json.mjs new file mode 100644 index 000000000000..0481690e9782 --- /dev/null +++ b/apps/mobile/scripts/lib/eas-json.mjs @@ -0,0 +1,137 @@ +#!/usr/bin/env node +// Tolerant reader for `eas ... --json` output. +// +// EAS CLI prints human-readable notices on stdout even in `--json` mode. The +// one that broke every production deploy comes from +// `eas fingerprint:generate --environment production` when that EAS +// environment holds no plain-text/sensitive variables: +// +// No environment variables with visibility "Plain text" and "Sensitive" +// found for the "production" environment on EAS. +// {"hash":"...","sources":[...]} +// +// A bare `JSON.parse(stdin)` dies on the notice ("Unexpected token 'N'"), so +// pull the first well-formed JSON value out of the stream instead of trusting +// the whole pipe. +// +// Usage: --json | node scripts/lib/eas-json.mjs + +import * as NodeURL from "node:url"; + +const OPENERS = new Set(["{", "["]); +const CLOSERS = new Map([ + ["{", "}"], + ["[", "]"], +]); + +/** Index just past the JSON value opening at `start`, or -1 when unbalanced. */ +function findValueEnd(text, start) { + const stack = []; + let inString = false; + let escaped = false; + for (let i = start; i < text.length; i++) { + const ch = text[i]; + if (inString) { + if (escaped) escaped = false; + else if (ch === "\\") escaped = true; + else if (ch === '"') inString = false; + continue; + } + if (ch === '"') { + inString = true; + continue; + } + if (OPENERS.has(ch)) { + stack.push(ch); + continue; + } + if (ch === "}" || ch === "]") { + const opener = stack.pop(); + if (opener === undefined || CLOSERS.get(opener) !== ch) return -1; + if (stack.length === 0) return i + 1; + } + } + return -1; +} + +/** First parseable JSON object/array in `raw`, or undefined when there is none. */ +export function extractJson(raw) { + const text = String(raw ?? ""); + for (let i = 0; i < text.length; i++) { + if (!OPENERS.has(text[i])) continue; + const end = findValueEnd(text, i); + if (end === -1) continue; + try { + return JSON.parse(text.slice(i, end)); + } catch { + // A brace inside a notice line is not JSON — keep scanning. + } + } + return undefined; +} + +/** Statuses whose build can still serve an OTA for its runtime version. */ +const USABLE_BUILD_STATUSES = new Set(["NEW", "IN_QUEUE", "IN_PROGRESS", "FINISHED"]); + +export function pickFingerprintHash(raw) { + const value = extractJson(raw); + if (value === undefined || value === null || Array.isArray(value)) return undefined; + const hash = value.hash ?? value.fingerprintHash; + return hash ? String(hash) : undefined; +} + +export function pickUsableBuildId(raw) { + const builds = extractJson(raw); + if (!Array.isArray(builds)) return undefined; + const build = builds.find((b) => + USABLE_BUILD_STATUSES.has( + String(b?.status ?? "") + .toUpperCase() + .replaceAll("-", "_"), + ), + ); + return build?.id ? String(build.id) : undefined; +} + +export function pickLatestFinishedRuntime(raw) { + const builds = extractJson(raw); + if (!Array.isArray(builds)) return undefined; + const runtime = builds[0]?.runtimeVersion; + return runtime ? String(runtime) : undefined; +} + +// `required` modes fail the deploy when nothing usable came back; the build +// lookups stay lenient because "no build yet" is a normal, handled outcome. +const MODES = new Map([ + ["fingerprint-hash", { pick: pickFingerprintHash, required: true }], + ["usable-build-id", { pick: pickUsableBuildId, required: false }], + ["latest-finished-runtime", { pick: pickLatestFinishedRuntime, required: false }], +]); + +const invokedDirectly = + process.argv[1] !== undefined && import.meta.url === NodeURL.pathToFileURL(process.argv[1]).href; + +if (invokedDirectly) { + const mode = process.argv[2]; + const handler = MODES.get(mode); + if (!handler) { + console.error( + `eas-json: unknown mode ${JSON.stringify(mode)}; expected one of ${[...MODES.keys()].join(", ")}`, + ); + process.exit(2); + } + + let raw = ""; + process.stdin.setEncoding("utf8"); + for await (const chunk of process.stdin) raw += chunk; + + const value = handler.pick(raw); + if (value === undefined) { + if (handler.required) { + console.error(`eas-json: ${mode} found no value in EAS output:`, raw.slice(0, 500)); + process.exit(1); + } + } else { + process.stdout.write(value); + } +} diff --git a/apps/mobile/scripts/lib/eas-json.test.mjs b/apps/mobile/scripts/lib/eas-json.test.mjs new file mode 100644 index 000000000000..ee3a11267a19 --- /dev/null +++ b/apps/mobile/scripts/lib/eas-json.test.mjs @@ -0,0 +1,89 @@ +import { describe, expect, it } from "vitest"; +import { + extractJson, + pickFingerprintHash, + pickLatestFinishedRuntime, + pickUsableBuildId, +} from "./eas-json.mjs"; + +// The exact stdout line that failed every production deploy from 2026-07-31 on. +const ENV_NOTICE = + 'No environment variables with visibility "Plain text" and "Sensitive" found for the "production" environment on EAS.\n'; + +describe("extractJson", () => { + it("parses clean JSON", () => { + expect(extractJson('{"hash":"abc"}')).toEqual({ hash: "abc" }); + }); + + it("skips a leading human-readable notice", () => { + expect(extractJson(`${ENV_NOTICE}{"hash":"abc"}\n`)).toEqual({ hash: "abc" }); + }); + + it("skips trailing output after the JSON value", () => { + expect(extractJson('[{"id":"b1"}]\nDone.\n')).toEqual([{ id: "b1" }]); + }); + + it("ignores braces that belong to prose", () => { + expect(extractJson('warning: unresolved {placeholder} in config\n{"hash":"abc"}')).toEqual({ + hash: "abc", + }); + }); + + it("does not stop at a brace inside a JSON string", () => { + expect(extractJson(`${ENV_NOTICE}{"hash":"a}b","extra":1}`)).toEqual({ + hash: "a}b", + extra: 1, + }); + }); + + it("returns undefined when there is no JSON at all", () => { + expect(extractJson(ENV_NOTICE)).toBeUndefined(); + expect(extractJson("")).toBeUndefined(); + expect(extractJson(undefined)).toBeUndefined(); + }); +}); + +describe("pickFingerprintHash", () => { + it("reads hash past the environment notice", () => { + expect(pickFingerprintHash(`${ENV_NOTICE}{"hash":"deadbeef","sources":[]}`)).toBe("deadbeef"); + }); + + it("accepts the fingerprintHash alias", () => { + expect(pickFingerprintHash('{"fingerprintHash":"cafe"}')).toBe("cafe"); + }); + + it("returns undefined when the payload carries no hash", () => { + expect(pickFingerprintHash('{"sources":[]}')).toBeUndefined(); + expect(pickFingerprintHash(ENV_NOTICE)).toBeUndefined(); + }); +}); + +describe("pickUsableBuildId", () => { + it("returns the first build that can still serve an OTA", () => { + const raw = `${ENV_NOTICE}[{"id":"b0","status":"errored"},{"id":"b1","status":"in-queue"}]`; + expect(pickUsableBuildId(raw)).toBe("b1"); + }); + + it("normalizes dashed and lowercase statuses", () => { + expect(pickUsableBuildId('[{"id":"b1","status":"in-progress"}]')).toBe("b1"); + expect(pickUsableBuildId('[{"id":"b1","status":"FINISHED"}]')).toBe("b1"); + }); + + it("returns undefined for empty, absent, or unusable lists", () => { + expect(pickUsableBuildId("[]")).toBeUndefined(); + expect(pickUsableBuildId("")).toBeUndefined(); + expect(pickUsableBuildId('[{"id":"b1","status":"canceled"}]')).toBeUndefined(); + }); +}); + +describe("pickLatestFinishedRuntime", () => { + it("reads the newest build's runtime version past a notice", () => { + const raw = `${ENV_NOTICE}[{"id":"b1","runtimeVersion":"a79f66c8"}]`; + expect(pickLatestFinishedRuntime(raw)).toBe("a79f66c8"); + }); + + it("returns undefined when no build is listed", () => { + expect(pickLatestFinishedRuntime("[]")).toBeUndefined(); + expect(pickLatestFinishedRuntime("")).toBeUndefined(); + }); +}); diff --git a/apps/mobile/src/App.tsx b/apps/mobile/src/App.tsx index b7f1db54e8c0..c046b8f02502 100644 --- a/apps/mobile/src/App.tsx +++ b/apps/mobile/src/App.tsx @@ -12,6 +12,7 @@ import { RegistryContext } from "@effect/atom-react"; import { ThreadArrangementHost } from "./features/threads/ThreadArrangementSheet"; import { ConfirmDialogHost } from "./components/ConfirmDialogHost"; import { CloudAuthProvider } from "./features/cloud/CloudAuthProvider"; +import { IdentityClaimGate } from "./features/identity/IdentityClaimGate"; import { prepareNativeShowcaseCapture } from "./features/showcase/nativeShowcaseScene"; import { IncomingShareProvider } from "./features/sharing/IncomingShareProvider"; import { @@ -95,6 +96,7 @@ function AppContent() { + {/* Anchored-menu overlays render here — in-window, so the diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx index dd0b48700ef7..3efaac1e16a2 100644 --- a/apps/mobile/src/Stack.tsx +++ b/apps/mobile/src/Stack.tsx @@ -15,7 +15,6 @@ import { Platform, Pressable, ScrollView, StyleSheet, View } from "react-native" import { useResolveClassNames } from "uniwind"; import { AppText as Text } from "./components/AppText"; -import { getCompactBrandHeaderOptions } from "./components/CompactBrandTitle"; import { ArchivedThreadsRouteScreen } from "./features/archive/ArchivedThreadsRouteScreen"; import { useAgentNotificationNavigation } from "./features/agent-awareness/notificationNavigation"; import { ConnectOnboardingRouteScreen } from "./features/cloud/ConnectOnboardingRouteScreen"; @@ -33,6 +32,7 @@ import { GitOverviewSheet } from "./features/threads/git/GitOverviewSheet"; import { ThreadRouteScreen } from "./features/threads/ThreadRouteScreen"; import { ConnectionsRouteScreen } from "./features/connection/ConnectionsRouteScreen"; import { ConnectionsNewRouteScreen } from "./features/connection/ConnectionsNewRouteScreen"; +import { BoardRouteScreen } from "./features/board/BoardRouteScreen"; import { HomeRouteScreen } from "./features/home/HomeRouteScreen"; import { AddProjectDestinationRoute } from "./features/projects/AddProjectDestinationRoute"; import { AddProjectLocalRoute } from "./features/projects/AddProjectLocalRoute"; @@ -464,7 +464,16 @@ export const RootStack = createNativeStackNavigator({ ...GLASS_HEADER_OPTIONS, contentStyle: { backgroundColor: "transparent" }, headerBackVisible: false, - ...getCompactBrandHeaderOptions(), + title: "Threads", + }, + }), + Board: createNativeStackScreen({ + screen: BoardRouteScreen, + linking: "board", + options: { + ...GLASS_HEADER_OPTIONS, + contentStyle: { backgroundColor: "transparent" }, + title: "Board", }, }), Thread: createNativeStackScreen({ diff --git a/apps/mobile/src/components/ProviderUsageIcon.tsx b/apps/mobile/src/components/ProviderUsageIcon.tsx new file mode 100644 index 000000000000..b6f860efdb79 --- /dev/null +++ b/apps/mobile/src/components/ProviderUsageIcon.tsx @@ -0,0 +1,83 @@ +import { View } from "react-native"; + +import type { UsageMarker } from "@t3tools/client-runtime/state/aiUsagePresentation"; + +import { ProviderIcon } from "./ProviderIcon"; + +export interface ProviderUsageIconProps { + readonly provider: string | null | undefined; + readonly size?: number; + readonly marker?: UsageMarker | null; +} + +/** + * Renders a provider icon with an optional usage status dot + ring, + * for use in conversation lists, composer, headers etc. + */ +export function ProviderUsageIcon(props: ProviderUsageIconProps) { + const { provider, size = 16, marker } = props; + + if (!marker) { + return ; + } + + const { fill, outlookAtRisk } = marker; + + let dotColor: string; + let ringColor: string | null = null; + + if (fill === "critical") { + dotColor = "#ef4444"; + if (outlookAtRisk) ringColor = "#f59e0b"; + } else if (fill === "warn") { + dotColor = "#f59e0b"; + if (outlookAtRisk) ringColor = "#f59e0b"; + } else if (outlookAtRisk) { + dotColor = "#6b7280"; + ringColor = "#f59e0b"; + } else { + return ; + } + + const dotSize = ringColor ? 7 : 5; + const containerSize = size + 4; + + return ( + + + + + + + ); +} diff --git a/apps/mobile/src/features/archive/ArchivedThreadsScreen.tsx b/apps/mobile/src/features/archive/ArchivedThreadsScreen.tsx index 97f9c5b69d0f..02766f993a1a 100644 --- a/apps/mobile/src/features/archive/ArchivedThreadsScreen.tsx +++ b/apps/mobile/src/features/archive/ArchivedThreadsScreen.tsx @@ -35,10 +35,7 @@ import { relativeTime } from "../../lib/time"; import { useUniwindTheme } from "../../lib/useUniwindTheme"; import { useServerConfigs } from "../../state/entities"; import { ThreadSwipeable } from "../home/thread-swipe-actions"; -import { - createNativeMailSearchToolbarItem, - NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED, -} from "../layout/native-mail-search-toolbar"; +import { createNativeMailSearchToolbarItem } from "../layout/native-mail-search-toolbar"; import type { ArchivedThreadGroup, ArchivedThreadSortOrder } from "./archivedThreadList"; export interface ArchivedThreadsHeaderEnvironment { @@ -78,8 +75,7 @@ function ArchivedThreadsHeader(props: { const insets = useSafeAreaInsets(); const hasCustomFilter = props.selectedEnvironmentId !== null || props.sortOrder !== "newest"; const usesNativeChrome = Platform.OS === "ios"; - const usesCompactMailToolbar = - Platform.OS === "ios" && width < 700 && NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED; + const usesCompactMailToolbar = Platform.OS === "ios" && width < 700; const androidFilterActions = useMemo( () => [ { @@ -281,11 +277,7 @@ function ArchivedThreadsHeader(props: { ...(usesNativeChrome ? { allowToolbarIntegration: true, - // "integratedButton" is an iOS 26 search-bar placement; - // pre-glass iOS keeps the default pull-down placement. - ...(NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED - ? { placement: "integratedButton" as const } - : null), + placement: "integratedButton" as const, } : { placement: "stacked" as const, diff --git a/apps/mobile/src/features/board/BoardRouteScreen.tsx b/apps/mobile/src/features/board/BoardRouteScreen.tsx new file mode 100644 index 000000000000..a6df70cd0d62 --- /dev/null +++ b/apps/mobile/src/features/board/BoardRouteScreen.tsx @@ -0,0 +1,83 @@ +import { useAtomValue } from "@effect/atom-react"; +import { AsyncResult } from "effect/unstable/reactivity"; +import { useNavigation } from "@react-navigation/native"; +import { useMemo } from "react"; +import { Platform } from "react-native"; + +import { AndroidScreenHeader } from "../../components/AndroidScreenHeader"; +import { NativeStackScreenOptions } from "../../native/StackHeader"; +import { useProjects, useThreadShells } from "../../state/entities"; +import { mobilePreferencesAtom } from "../../state/preferences"; +import { prefetchEnvironmentThread, warmSelectedEnvironmentThread } from "../../state/threads"; +import { useSavedRemoteConnections } from "../../state/use-remote-environment-registry"; +import { resolveProjectGroupingMode, useHomeListOptions } from "../home/home-list-options"; +import { useThreadListActions } from "../home/useThreadListActions"; +import { BoardScreen } from "./BoardScreen"; + +export function BoardRouteScreen() { + const navigation = useNavigation(); + const projects = useProjects(); + const threads = useThreadShells(); + const { savedConnectionsById } = useSavedRemoteConnections(); + const preferencesResult = useAtomValue(mobilePreferencesAtom); + const { archiveThread, confirmDeleteThread, settleThread, unsettleThread } = + useThreadListActions(); + + const projectGroupingMode = resolveProjectGroupingMode( + AsyncResult.isSuccess(preferencesResult) + ? preferencesResult.value.projectGroupingEnabled + : undefined, + ); + + const availableEnvironmentIds = useMemo( + () => new Set(Object.values(savedConnectionsById).map((c) => c.environmentId)), + [savedConnectionsById], + ); + const { + options: listOptions, + clearSelectedEnvironments, + toggleSelectedEnvironmentId, + } = useHomeListOptions(availableEnvironmentIds); + + const environmentLabelById = useMemo(() => { + const map = new Map(); + for (const connection of Object.values(savedConnectionsById)) { + map.set(connection.environmentId, connection.environmentLabel); + } + return map; + }, [savedConnectionsById]); + + return ( + <> + {Platform.OS === "android" ? ( + <> + + navigation.goBack()} /> + + ) : ( + + )} + { + prefetchEnvironmentThread(thread.environmentId, thread.id); + warmSelectedEnvironmentThread(thread.environmentId, thread.id); + navigation.navigate("Thread", { + environmentId: thread.environmentId, + threadId: thread.id, + }); + }} + onArchiveThread={archiveThread} + onDeleteThread={confirmDeleteThread} + onSettleThread={settleThread} + onUnsettleThread={unsettleThread} + /> + + ); +} diff --git a/apps/mobile/src/features/board/BoardScreen.tsx b/apps/mobile/src/features/board/BoardScreen.tsx new file mode 100644 index 000000000000..7244d9630375 --- /dev/null +++ b/apps/mobile/src/features/board/BoardScreen.tsx @@ -0,0 +1,744 @@ +import { useAtomValue } from "@effect/atom-react"; +import { + deriveLogicalProjectKey, + deriveProjectGroupLabel, +} from "@t3tools/client-runtime/state/project-grouping"; +import type { + EnvironmentProject, + EnvironmentThreadShell, +} from "@t3tools/client-runtime/state/shell"; +import type { EnvironmentId, SidebarProjectGroupingMode } from "@t3tools/contracts"; +import type { MenuAction } from "@react-native-menu/menu"; +import { memo, useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react"; +import { + FlatList, + Pressable, + ScrollView, + useWindowDimensions, + View, + type ListRenderItemInfo, +} from "react-native"; +import { useSafeAreaInsets } from "react-native-safe-area-context"; + +import { AppText as Text } from "../../components/AppText"; +import { ControlPillMenu } from "../../components/ControlPill"; +import { EmptyState } from "../../components/EmptyState"; +import { ProjectFavicon } from "../../components/ProjectFavicon"; +import { SymbolView } from "../../components/AppSymbol"; +import { ThreadIdentityMark } from "../identity/ParticipantStack"; +import { relativeTime } from "../../lib/time"; +import { scopedProjectKey, scopedThreadKey } from "../../lib/scopedEntities"; +import { environmentServerConfigsAtom } from "../../state/server"; +import { + isAllEnvironmentsSelected, + isEnvironmentSelected, + matchesEnvironmentFilter, + toggleEnvironmentId, +} from "../home/homeEnvironmentFilter"; +import { + BOARD_COLUMN_IDS, + BOARD_COLUMN_LABELS, + boardGitKey, + boardWorktreeKey, + buildBoardColumns, + buildBoardProjectFilterPredicate, + countBoardColumnThreads, + deriveBoardColumn, + sliceBoardSettledItems, + type BoardColumnId, + type BoardColumnItem, +} from "./boardLogic"; +import { resolveBoardThreadStatusLabel, resolveBoardWorkingStartedAt } from "./boardStatus"; +import { useBoardVcsStatuses, type BoardVcsTarget } from "./useBoardVcsStatuses"; + +const SETTLED_INITIAL_COUNT = 10; +const SETTLED_PAGE_COUNT = 25; + +export interface BoardScreenProps { + readonly projects: ReadonlyArray; + readonly threads: ReadonlyArray; + readonly projectGroupingMode: SidebarProjectGroupingMode; + readonly environmentLabelById: ReadonlyMap; + /** + * Shared multi-select environment filter. Empty = all environments. + * When provided with on*Environment callbacks, the board uses the parent + * filter (home list modes). Otherwise the board keeps a local multi-select. + */ + readonly selectedEnvironmentIds?: readonly EnvironmentId[]; + readonly onClearEnvironments?: () => void; + readonly onToggleEnvironment?: (environmentId: EnvironmentId) => void; + readonly onSelectThread: (thread: EnvironmentThreadShell) => void; + readonly onArchiveThread: (thread: EnvironmentThreadShell) => void; + readonly onDeleteThread: (thread: EnvironmentThreadShell) => void; + readonly onSettleThread: (thread: EnvironmentThreadShell) => Promise; + readonly onUnsettleThread: (thread: EnvironmentThreadShell) => void; + /** Hide the in-board filter chrome when the parent header already owns it. */ + readonly hideFilterChrome?: boolean; + /** + * Extra top inset when the parent still uses a transparent glass header + * (board columns are not a single UIKit-inset scroll view). Prefer a solid + * stack header for Board; use this only as a fallback. + */ + readonly contentTopInset?: number; +} + +interface BoardProjectFilterOption { + readonly key: string; + readonly label: string; + readonly memberProjectRefs: ReadonlyArray<{ + readonly environmentId: EnvironmentId; + readonly projectId: EnvironmentProject["id"]; + }>; + readonly representative: EnvironmentProject; +} + +function BoardCard(props: { + readonly thread: EnvironmentThreadShell; + readonly project: EnvironmentProject | null; + readonly projectTitle: string | null; + readonly environmentLabel: string | null; + readonly statusLabel: string | null; + readonly isSettled: boolean; + readonly onSelect: () => void; + readonly onArchive: () => void; + readonly onDelete: () => void; + readonly onSettle: () => void; + readonly onUnsettle: () => void; + readonly settlementSupported: boolean; +}) { + const timestamp = relativeTime( + props.thread.latestUserMessageAt ?? props.thread.updatedAt ?? props.thread.createdAt, + ); + const subtitleParts = [props.projectTitle, props.environmentLabel, props.thread.branch].filter( + (part): part is string => Boolean(part), + ); + + const menuActions = useMemo(() => { + const actions: MenuAction[] = []; + if (props.settlementSupported) { + actions.push( + props.isSettled + ? { id: "unsettle", title: "Unsettle", image: "pin" } + : { id: "settle", title: "Settle", image: "checkmark.circle" }, + ); + } + actions.push( + { id: "archive", title: "Archive", image: "archivebox" }, + { id: "delete", title: "Delete", image: "trash", attributes: { destructive: true } }, + ); + return actions; + }, [props.isSettled, props.settlementSupported]); + + const handleMenuAction = useCallback( + ({ nativeEvent }: { readonly nativeEvent: { readonly event: string } }) => { + switch (nativeEvent.event) { + case "archive": + props.onArchive(); + break; + case "delete": + props.onDelete(); + break; + case "settle": + void props.onSettle(); + break; + case "unsettle": + props.onUnsettle(); + break; + } + }, + [props], + ); + + return ( + + ({ opacity: pressed ? 0.75 : 1 })} + > + + {props.project ? ( + + ) : null} + + + + {props.thread.title} + + + + {subtitleParts.length > 0 ? ( + + {subtitleParts.join(" · ")} + + ) : null} + + {props.statusLabel ? ( + + + {props.statusLabel} + + + ) : ( + + )} + {timestamp} + + + + + + ); +} + +const BoardColumnView = memo(function BoardColumnView(props: { + readonly columnId: BoardColumnId; + readonly items: ReadonlyArray>; + readonly width: number; + readonly projectByKey: ReadonlyMap; + readonly projectTitleByKey: ReadonlyMap; + readonly environmentLabelById: ReadonlyMap; + readonly settledThreadKeys: ReadonlySet; + readonly statusLabelByKey: ReadonlyMap; + readonly settlementEnvironmentIds: ReadonlySet; + readonly onSelectThread: (thread: EnvironmentThreadShell) => void; + readonly onArchiveThread: (thread: EnvironmentThreadShell) => void; + readonly onDeleteThread: (thread: EnvironmentThreadShell) => void; + readonly onSettleThread: (thread: EnvironmentThreadShell) => Promise; + readonly onUnsettleThread: (thread: EnvironmentThreadShell) => void; + readonly footer?: ReactNode; +}) { + const count = countBoardColumnThreads(props.items); + const threads = useMemo(() => { + const list: EnvironmentThreadShell[] = []; + for (const item of props.items) { + if (item.kind === "thread") { + list.push(item.thread); + } else { + list.push(...item.threads); + } + } + return list; + }, [props.items]); + + const renderItem = useCallback( + ({ item }: ListRenderItemInfo) => { + const threadKey = scopedThreadKey(item.environmentId, item.id); + const projectKey = scopedProjectKey(item.environmentId, item.projectId); + return ( + + props.onSelectThread(item)} + onArchive={() => props.onArchiveThread(item)} + onDelete={() => props.onDeleteThread(item)} + onSettle={() => props.onSettleThread(item)} + onUnsettle={() => props.onUnsettleThread(item)} + /> + + ); + }, + [props], + ); + + return ( + + + + {BOARD_COLUMN_LABELS[props.columnId]} + + + {count} + + + `${thread.environmentId}:${thread.id}`} + renderItem={renderItem} + ListEmptyComponent={ + + No threads + + } + ListFooterComponent={props.footer ? <>{props.footer} : null} + showsVerticalScrollIndicator={false} + contentContainerStyle={{ paddingBottom: 24 }} + /> + + ); +}); + +export function BoardScreen(props: BoardScreenProps) { + const insets = useSafeAreaInsets(); + const { width: windowWidth } = useWindowDimensions(); + const columnWidth = Math.min(Math.max(windowWidth * 0.78, 260), 320); + const serverConfigs = useAtomValue(environmentServerConfigsAtom); + const [projectFilterKey, setProjectFilterKey] = useState(null); + const [localEnvironmentIds, setLocalEnvironmentIds] = useState([]); + const [settledVisibleCount, setSettledVisibleCount] = useState(SETTLED_INITIAL_COUNT); + const [nowMinute, setNowMinute] = useState(() => new Date().toISOString().slice(0, 16)); + + const selectedEnvironmentIds = props.selectedEnvironmentIds ?? localEnvironmentIds; + const clearEnvironments = props.onClearEnvironments ?? (() => setLocalEnvironmentIds([])); + const toggleEnvironment = + props.onToggleEnvironment ?? + ((environmentId: EnvironmentId) => { + setLocalEnvironmentIds((current) => toggleEnvironmentId(current, environmentId)); + }); + + useEffect(() => { + const id = setInterval(() => setNowMinute(new Date().toISOString().slice(0, 16)), 60_000); + return () => clearInterval(id); + }, []); + + const environmentFilterOptions = useMemo(() => { + const labels = new Map(); + for (const [environmentId, label] of props.environmentLabelById) { + labels.set(environmentId, label); + } + for (const project of props.projects) { + if (!labels.has(project.environmentId)) { + labels.set(project.environmentId, project.environmentId); + } + } + return [...labels.entries()] + .map(([environmentId, label]) => ({ + environmentId: environmentId as EnvironmentId, + label, + })) + .sort((left, right) => left.label.localeCompare(right.label)); + }, [props.environmentLabelById, props.projects]); + + const envFilteredProjects = useMemo( + () => + props.projects.filter((project) => + matchesEnvironmentFilter(project.environmentId, selectedEnvironmentIds), + ), + [props.projects, selectedEnvironmentIds], + ); + + const projectFilterOptions = useMemo>(() => { + const groups = new Map(); + for (const project of envFilteredProjects) { + const key = deriveLogicalProjectKey(project, { + groupingMode: props.projectGroupingMode, + }); + const existing = groups.get(key); + if (existing) existing.push(project); + else groups.set(key, [project]); + } + return [...groups.entries()] + .map(([key, members]) => { + const representative = members[0]!; + return { + key, + label: deriveProjectGroupLabel({ representative, members }), + memberProjectRefs: members.map((project) => ({ + environmentId: project.environmentId, + projectId: project.id, + })), + representative, + }; + }) + .sort((left, right) => left.label.localeCompare(right.label)); + }, [envFilteredProjects, props.projectGroupingMode]); + + useEffect(() => { + if ( + projectFilterKey !== null && + !projectFilterOptions.some((option) => option.key === projectFilterKey) + ) { + setProjectFilterKey(null); + } + }, [projectFilterKey, projectFilterOptions]); + + const filterPredicate = useMemo( + () => + buildBoardProjectFilterPredicate({ + selectedProjectKey: projectFilterKey, + snapshots: projectFilterOptions.map((option) => ({ + projectKey: option.key, + memberProjectRefs: option.memberProjectRefs, + })), + }), + [projectFilterKey, projectFilterOptions], + ); + + const liveThreads = useMemo( + () => + props.threads.filter( + (thread) => + thread.archivedAt === null && + matchesEnvironmentFilter(thread.environmentId, selectedEnvironmentIds), + ), + [props.threads, selectedEnvironmentIds], + ); + const filteredThreads = useMemo( + () => liveThreads.filter(filterPredicate), + [filterPredicate, liveThreads], + ); + + const projectByKey = useMemo(() => { + const map = new Map(); + for (const project of props.projects) { + map.set(scopedProjectKey(project.environmentId, project.id), project); + } + return map; + }, [props.projects]); + + const projectTitleByKey = useMemo(() => { + const map = new Map(); + for (const option of projectFilterOptions) { + for (const ref of option.memberProjectRefs) { + map.set(scopedProjectKey(ref.environmentId, ref.projectId), option.label); + } + } + return map; + }, [projectFilterOptions]); + + const resolveThreadGitCwd = useCallback( + (thread: EnvironmentThreadShell): string | null => { + if (thread.branch == null) return null; + const project = projectByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)); + return thread.worktreePath ?? project?.workspaceRoot ?? null; + }, + [projectByKey], + ); + + const vcsTargets = useMemo( + () => + filteredThreads.flatMap((thread) => { + const cwd = resolveThreadGitCwd(thread); + return cwd === null ? [] : [{ environmentId: thread.environmentId, cwd }]; + }), + [filteredThreads, resolveThreadGitCwd], + ); + const gitStatuses = useBoardVcsStatuses(vcsTargets); + + const getGitStatus = useCallback( + (thread: EnvironmentThreadShell) => { + const cwd = resolveThreadGitCwd(thread); + if (cwd === null) return null; + return gitStatuses.get(boardGitKey(thread.environmentId, cwd)) ?? null; + }, + [gitStatuses, resolveThreadGitCwd], + ); + + const settlementEnvironmentIds = useMemo(() => { + const supported = new Set(); + for (const [environmentId, config] of serverConfigs) { + if (config.environment.capabilities.threadSettlement === true) { + supported.add(environmentId); + } + } + return supported; + }, [serverConfigs]); + + const statusLabelByKey = useMemo(() => { + const map = new Map(); + for (const thread of liveThreads) { + map.set( + scopedThreadKey(thread.environmentId, thread.id), + resolveBoardThreadStatusLabel(thread), + ); + } + return map; + }, [liveThreads]); + + const previousSettledRef = useRef>(new Set()); + const settledThreadKeys = useMemo(() => { + const keys = new Set(); + for (const thread of filteredThreads) { + if (!settlementEnvironmentIds.has(thread.environmentId)) continue; + if (thread.settledOverride === "settled") { + keys.add(scopedThreadKey(thread.environmentId, thread.id)); + } + } + const previous = previousSettledRef.current; + if (previous.size === keys.size && [...keys].every((key) => previous.has(key))) { + return previous; + } + previousSettledRef.current = keys; + return keys; + }, [filteredThreads, settlementEnvironmentIds]); + + const workingWorktreeKeys = useMemo(() => { + const keys = new Set(); + for (const thread of liveThreads) { + const label = statusLabelByKey.get(scopedThreadKey(thread.environmentId, thread.id)); + if (label !== "Working" && label !== "Connecting") continue; + const cwd = resolveThreadGitCwd(thread); + if (cwd !== null) { + keys.add(boardGitKey(thread.environmentId, cwd)); + } + } + return keys; + }, [liveThreads, resolveThreadGitCwd, statusLabelByKey]); + + const columns = useMemo( + () => + buildBoardColumns( + filteredThreads, + (thread) => { + const threadKey = scopedThreadKey(thread.environmentId, thread.id); + const cwd = resolveThreadGitCwd(thread); + return deriveBoardColumn({ + threadStatusLabel: + (statusLabelByKey.get(threadKey) as ReturnType< + typeof resolveBoardThreadStatusLabel + >) ?? null, + interactionMode: thread.interactionMode, + isSettled: settledThreadKeys.has(threadKey), + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + readySessionUpdatedAt: + thread.latestTurn === null && thread.session?.status === "ready" + ? thread.session.updatedAt + : null, + lastVisitedAt: null, + threadBranch: thread.branch, + hasDedicatedWorktree: thread.worktreePath != null, + hasWorkingThreadForWorktree: + cwd !== null && workingWorktreeKeys.has(boardGitKey(thread.environmentId, cwd)), + gitStatus: getGitStatus(thread), + }); + }, + (thread) => resolveBoardWorkingStartedAt(thread), + boardWorktreeKey, + ), + [ + filteredThreads, + getGitStatus, + resolveThreadGitCwd, + settledThreadKeys, + statusLabelByKey, + workingWorktreeKeys, + ], + ); + + const settledResetKey = `${selectedEnvironmentIds.join(",") || "all"}:${projectFilterKey ?? "all"}`; + const lastSettledResetKeyRef = useRef(settledResetKey); + if (lastSettledResetKeyRef.current !== settledResetKey) { + lastSettledResetKeyRef.current = settledResetKey; + if (settledVisibleCount !== SETTLED_INITIAL_COUNT) { + setSettledVisibleCount(SETTLED_INITIAL_COUNT); + } + } + + const settledTail = useMemo( + () => sliceBoardSettledItems(columns.settled, settledVisibleCount), + [columns.settled, settledVisibleCount], + ); + const showMoreSettled = useCallback( + () => setSettledVisibleCount((count) => count + SETTLED_PAGE_COUNT), + [], + ); + + const filterMenuActions = useMemo( + () => [ + { + id: "environment", + title: "Environment", + subactions: [ + { + id: "environment:all", + title: "All environments", + state: isAllEnvironmentsSelected(selectedEnvironmentIds) ? "on" : "off", + }, + ...environmentFilterOptions.map((environment) => ({ + id: `environment:${environment.environmentId}`, + title: environment.label, + state: (isEnvironmentSelected(selectedEnvironmentIds, environment.environmentId) + ? "on" + : "off") as "on" | "off", + })), + ], + }, + { + id: "project", + title: "Project", + subactions: [ + { + id: "project:all", + title: "All projects", + state: projectFilterKey === null ? "on" : "off", + }, + ...projectFilterOptions.map((option) => ({ + id: `project:${option.key}`, + title: option.label, + state: (projectFilterKey === option.key ? "on" : "off") as "on" | "off", + })), + ], + }, + ], + [environmentFilterOptions, projectFilterKey, projectFilterOptions, selectedEnvironmentIds], + ); + + const handleFilterAction = useCallback( + ({ nativeEvent }: { readonly nativeEvent: { readonly event: string } }) => { + const id = nativeEvent.event; + if (id === "environment:all") { + clearEnvironments(); + return; + } + if (id.startsWith("environment:")) { + const environmentId = id.slice("environment:".length) as EnvironmentId; + toggleEnvironment(environmentId); + return; + } + if (id === "project:all") { + setProjectFilterKey(null); + return; + } + if (id.startsWith("project:")) { + setProjectFilterKey(id.slice("project:".length)); + } + }, + [clearEnvironments, toggleEnvironment], + ); + + const selectedFilterLabel = (() => { + const envPart = isAllEnvironmentsSelected(selectedEnvironmentIds) + ? "All environments" + : selectedEnvironmentIds.length === 1 + ? (environmentFilterOptions.find( + (environment) => environment.environmentId === selectedEnvironmentIds[0], + )?.label ?? "1 environment") + : `${selectedEnvironmentIds.length} environments`; + const projectPart = + projectFilterKey === null + ? "All projects" + : (projectFilterOptions.find((option) => option.key === projectFilterKey)?.label ?? + "All projects"); + return `${envPart} · ${projectPart}`; + })(); + + const topInset = props.contentTopInset ?? 0; + + if (liveThreads.length === 0) { + return ( + + + + ); + } + + return ( + + {props.hideFilterChrome ? null : ( + + + ({ opacity: pressed ? 0.7 : 1 })} + > + + + {selectedFilterLabel} + + + + + {filteredThreads.length} thread{filteredThreads.length === 1 ? "" : "s"} + + + )} + + {filteredThreads.length === 0 ? ( + + + + ) : ( + + {BOARD_COLUMN_IDS.map((columnId) => { + const items = columnId === "settled" ? settledTail.visibleItems : columns[columnId]; + return ( + 0 ? ( + ({ opacity: pressed ? 0.6 : 1 })} + > + + Show more ({settledTail.hiddenThreadCount} settled hidden) + + + ) : null + } + /> + ); + })} + + )} + + ); +} diff --git a/apps/mobile/src/features/board/boardLogic.test.ts b/apps/mobile/src/features/board/boardLogic.test.ts new file mode 100644 index 000000000000..9f0226d69485 --- /dev/null +++ b/apps/mobile/src/features/board/boardLogic.test.ts @@ -0,0 +1,607 @@ +import { EnvironmentId, ProjectId, type VcsStatusResult } from "@t3tools/contracts"; +import { scopeProjectRef } from "@t3tools/client-runtime/environment"; +import { describe, expect, it } from "vite-plus/test"; +import { + BOARD_ARCHIVE_DROPPABLE_ID, + BOARD_SETTLED_COLUMN_DROPPABLE_ID, + BOARD_TRASH_DROPPABLE_ID, + BOARD_UNSETTLE_DROPPABLE_ID, + boardWorktreeGroupDragId, + boardWorktreeKey, + buildBoardColumns, + buildBoardProjectFilterPredicate, + countBoardColumnThreads, + deriveBoardColumn, + parseBoardWorktreeGroupDragId, + resolveBoardDropIntent, + sliceBoardSettledItems, + sortBoardThreads, + type BoardColumnItem, + type BoardColumnInput, +} from "./boardLogic"; + +const localEnvironmentId = EnvironmentId.make("environment-local"); +const remoteEnvironmentId = EnvironmentId.make("environment-remote"); + +function columnThreadIds( + items: readonly BoardColumnItem[], +): string[] { + return items.flatMap((item) => + item.kind === "thread" ? [item.thread.id] : item.threads.map((thread) => thread.id), + ); +} + +function makeGitStatus(overrides: Partial = {}): VcsStatusResult { + return { + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "feature/board", + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + pr: null, + ...overrides, + }; +} + +function makePr(state: "open" | "closed" | "merged"): NonNullable { + return { + number: 42, + title: "Board view", + url: "https://github.com/example/repo/pull/42", + baseRef: "main", + headRef: "feature/board", + state, + }; +} + +function makeColumnInput(overrides: Partial = {}): BoardColumnInput { + return { + threadStatusLabel: null, + interactionMode: "default", + isSettled: false, + latestTurnCompletedAt: null, + readySessionUpdatedAt: null, + lastVisitedAt: null, + threadBranch: "feature/board", + hasDedicatedWorktree: false, + hasWorkingThreadForWorktree: false, + gitStatus: makeGitStatus(), + ...overrides, + }; +} + +describe("deriveBoardColumn", () => { + it("puts attention status pills in review ahead of working or merged lifecycle state", () => { + const gitStatus = makeGitStatus({ pr: makePr("merged") }); + expect( + deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Pending Approval", gitStatus })), + ).toBe("review"); + expect( + deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Awaiting Input", gitStatus })), + ).toBe("review"); + expect( + deriveBoardColumn( + makeColumnInput({ + interactionMode: "plan", + threadStatusLabel: "Plan Ready", + gitStatus, + }), + ), + ).toBe("review"); + expect(deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Completed", gitStatus }))).toBe( + "review", + ); + }); + + it("puts working and connecting status pills in working, even with a merged PR", () => { + const gitStatus = makeGitStatus({ pr: makePr("merged") }); + expect(deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Working", gitStatus }))).toBe( + "working", + ); + expect(deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Connecting", gitStatus }))).toBe( + "working", + ); + }); + + it("defaults to review while git status is unloaded or the cwd is not a repo", () => { + expect(deriveBoardColumn(makeColumnInput({ gitStatus: null }))).toBe("review"); + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ isRepo: false }) })), + ).toBe("review"); + }); + + it("ignores git status from a shared cwd checked out on a different branch", () => { + const gitStatus = makeGitStatus({ + refName: "someone-elses-branch", + hasWorkingTreeChanges: true, + pr: makePr("open"), + }); + expect(deriveBoardColumn(makeColumnInput({ gitStatus }))).toBe("review"); + }); + + it("applies git status from a dedicated worktree regardless of ref name", () => { + const gitStatus = makeGitStatus({ refName: "detached-head", hasWorkingTreeChanges: true }); + expect(deriveBoardColumn(makeColumnInput({ hasDedicatedWorktree: true, gitStatus }))).toBe( + "review", + ); + }); + + it("puts a branch ahead of upstream in review", () => { + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ aheadCount: 2 }) })), + ).toBe("review"); + }); + + it("puts a never-pushed branch ahead of (or with unknown distance to) the default in review", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + gitStatus: makeGitStatus({ hasUpstream: false, aheadOfDefaultCount: 3 }), + }), + ), + ).toBe("review"); + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ hasUpstream: false }) })), + ).toBe("review"); + }); + + it("puts a clean fully pushed feature branch without a PR in published", () => { + expect(deriveBoardColumn(makeColumnInput())).toBe("published"); + }); + + it("puts an open PR with unpublished work in review", () => { + const gitStatus = makeGitStatus({ + hasWorkingTreeChanges: true, + pr: makePr("open"), + }); + expect(deriveBoardColumn(makeColumnInput({ gitStatus }))).toBe("review"); + }); + + it("does not move a sibling thread to review for a dirty worktree that is still working", () => { + const gitStatus = makeGitStatus({ + hasWorkingTreeChanges: true, + pr: makePr("open"), + }); + expect( + deriveBoardColumn( + makeColumnInput({ + hasDedicatedWorktree: true, + hasWorkingThreadForWorktree: true, + gitStatus, + }), + ), + ).toBe("published"); + }); + + it("still moves locally-ahead siblings to review while their worktree is working", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + hasDedicatedWorktree: true, + hasWorkingThreadForWorktree: true, + gitStatus: makeGitStatus({ aheadCount: 1, pr: makePr("open") }), + }), + ), + ).toBe("review"); + }); + + it("puts a clean open PR in published", () => { + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ pr: makePr("open") }) })), + ).toBe("published"); + }); + + it("keeps an unsettled merged PR in published instead of guessing settled", () => { + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ pr: makePr("merged") }) })), + ).toBe("published"); + }); + + it("lets the settled flag win regardless of git or completion state", () => { + expect(deriveBoardColumn(makeColumnInput({ isSettled: true, gitStatus: null }))).toBe( + "settled", + ); + expect( + deriveBoardColumn( + makeColumnInput({ + isSettled: true, + gitStatus: makeGitStatus({ hasWorkingTreeChanges: true, aheadCount: 1 }), + }), + ), + ).toBe("settled"); + expect( + deriveBoardColumn(makeColumnInput({ isSettled: true, threadStatusLabel: "Completed" })), + ).toBe("settled"); + }); + + it("puts an unseen turn completion in review regardless of git state", () => { + const unseen = { + latestTurnCompletedAt: "2026-07-22T10:00:00.000Z", + lastVisitedAt: "2026-07-22T09:00:00.000Z", + }; + expect(deriveBoardColumn(makeColumnInput({ ...unseen, gitStatus: null }))).toBe("review"); + expect( + deriveBoardColumn( + makeColumnInput({ ...unseen, gitStatus: makeGitStatus({ pr: makePr("merged") }) }), + ), + ).toBe("review"); + }); + + it("keeps a working status pill in working even with an unseen completion", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + threadStatusLabel: "Working", + latestTurnCompletedAt: "2026-07-22T10:00:00.000Z", + lastVisitedAt: "2026-07-22T09:00:00.000Z", + }), + ), + ).toBe("working"); + }); + + it("keeps a visited ready session in review when its latest turn summary is unavailable", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + latestTurnCompletedAt: null, + readySessionUpdatedAt: "2026-07-22T03:45:04.819Z", + lastVisitedAt: "2026-07-22T03:45:04.819Z", + gitStatus: null, + }), + ), + ).toBe("review"); + }); + + it("lets in-flight git work outrank a seen completion", () => { + const seen = { + latestTurnCompletedAt: "2026-07-22T09:00:00.000Z", + lastVisitedAt: "2026-07-22T10:00:00.000Z", + }; + expect( + deriveBoardColumn( + makeColumnInput({ ...seen, gitStatus: makeGitStatus({ hasWorkingTreeChanges: true }) }), + ), + ).toBe("review"); + expect(deriveBoardColumn(makeColumnInput({ ...seen }))).toBe("published"); + }); + + it("keeps a plan-only thread's column off its worktree's git state", () => { + // This git state would classify as published; a plan-mode thread does not + // own it (the implementation thread does), so the plan thread stays in + // review until settled. + const badgelessPlan = { + interactionMode: "plan" as const, + threadStatusLabel: null, + hasDedicatedWorktree: true, + gitStatus: makeGitStatus({ pr: makePr("open") }), + }; + expect( + deriveBoardColumn(makeColumnInput({ ...badgelessPlan, interactionMode: "default" })), + ).toBe("published"); + expect(deriveBoardColumn(makeColumnInput(badgelessPlan))).toBe("review"); + expect(deriveBoardColumn(makeColumnInput({ ...badgelessPlan, isSettled: true }))).toBe( + "settled", + ); + }); + + it("puts a clean default branch in review", () => { + const gitStatus = makeGitStatus({ refName: "main", isDefaultRef: true }); + expect(deriveBoardColumn(makeColumnInput({ threadBranch: "main", gitStatus }))).toBe("review"); + }); +}); + +describe("sortBoardThreads", () => { + const byUpdatedAt = (thread: { updatedAt: string }) => thread.updatedAt; + + it("orders by the selected timestamp descending", () => { + const sorted = sortBoardThreads( + [ + { id: "thread-1", updatedAt: "2026-07-20T10:00:00.000Z" }, + { id: "thread-2", updatedAt: "2026-07-21T10:00:00.000Z" }, + { id: "thread-3", updatedAt: "2026-07-19T10:00:00.000Z" }, + ], + byUpdatedAt, + ); + expect(sorted.map((thread) => thread.id)).toEqual(["thread-2", "thread-1", "thread-3"]); + }); + + it("breaks timestamp ties by thread id", () => { + const sorted = sortBoardThreads( + [ + { id: "thread-b", updatedAt: "2026-07-20T10:00:00.000Z" }, + { id: "thread-a", updatedAt: "2026-07-20T10:00:00.000Z" }, + ], + byUpdatedAt, + ); + expect(sorted.map((thread) => thread.id)).toEqual(["thread-a", "thread-b"]); + }); + + it("sorts invalid timestamps last", () => { + const sorted = sortBoardThreads( + [ + { id: "thread-1", updatedAt: "not-a-date" }, + { id: "thread-2", updatedAt: "2026-07-20T10:00:00.000Z" }, + ], + byUpdatedAt, + ); + expect(sorted.map((thread) => thread.id)).toEqual(["thread-2", "thread-1"]); + }); +}); + +describe("buildBoardColumns", () => { + it("sorts working threads by active session start (falling back to update time) and other columns by update time", () => { + const threads = [ + { + id: "thread-review-old", + updatedAt: "2026-07-18T10:00:00.000Z", + workingStartedAt: null, + }, + { + id: "thread-review-new", + updatedAt: "2026-07-21T10:00:00.000Z", + workingStartedAt: null, + }, + { + id: "thread-working-old", + updatedAt: "2026-07-22T10:00:00.000Z", + workingStartedAt: "2026-07-19T10:00:00.000Z", + }, + { + id: "thread-working-new", + updatedAt: "2026-07-20T10:00:00.000Z", + workingStartedAt: "2026-07-21T10:00:00.000Z", + }, + { + id: "thread-working-fallback", + updatedAt: "2026-07-23T10:00:00.000Z", + workingStartedAt: null, + }, + ]; + const columns = buildBoardColumns( + threads, + (thread) => (thread.id.startsWith("thread-working") ? "working" : "review"), + (thread) => thread.workingStartedAt, + ); + expect(columnThreadIds(columns.review)).toEqual(["thread-review-new", "thread-review-old"]); + expect(columnThreadIds(columns.working)).toEqual([ + "thread-working-fallback", + "thread-working-new", + "thread-working-old", + ]); + expect(columns.published).toEqual([]); + expect(columns.settled).toEqual([]); + }); + + it("hosts shared groups in their earliest column and orders members by actual column then time", () => { + const threads = [ + { + id: "group-review-old", + updatedAt: "2026-07-19T10:00:00.000Z", + workingStartedAt: null, + column: "review" as const, + groupKey: "shared-worktree", + }, + { + id: "group-working-old", + updatedAt: "2026-07-24T10:00:00.000Z", + workingStartedAt: "2026-07-20T10:00:00.000Z", + column: "working" as const, + groupKey: "shared-worktree", + }, + { + id: "group-published", + updatedAt: "2026-07-25T10:00:00.000Z", + workingStartedAt: null, + column: "published" as const, + groupKey: "shared-worktree", + }, + { + id: "group-review-new", + updatedAt: "2026-07-23T10:00:00.000Z", + workingStartedAt: null, + column: "review" as const, + groupKey: "shared-worktree", + }, + { + id: "group-working-new", + updatedAt: "2026-07-18T10:00:00.000Z", + workingStartedAt: "2026-07-22T10:00:00.000Z", + column: "working" as const, + groupKey: "shared-worktree", + }, + ]; + const columns = buildBoardColumns( + threads, + (thread) => thread.column, + (thread) => thread.workingStartedAt, + (thread) => thread.groupKey, + ); + + expect(columns.working).toEqual([ + { + kind: "worktreeGroup", + worktreeKey: "shared-worktree", + threads: [threads[4], threads[1], threads[3], threads[0], threads[2]], + }, + ]); + expect(columns.review).toEqual([]); + expect(columns.published).toEqual([]); + expect(columns.settled).toEqual([]); + }); + + it("uses the earliest represented column rather than moving every group to working", () => { + const threads = [ + { + id: "standalone-working", + updatedAt: "2026-07-22T10:00:00.000Z", + column: "working" as const, + groupKey: null, + }, + { + id: "group-settled", + updatedAt: "2026-07-23T10:00:00.000Z", + column: "settled" as const, + groupKey: "later-group", + }, + { + id: "group-review", + updatedAt: "2026-07-21T10:00:00.000Z", + column: "review" as const, + groupKey: "later-group", + }, + ]; + const columns = buildBoardColumns( + threads, + (thread) => thread.column, + () => null, + (thread) => thread.groupKey, + ); + + expect(columns.working).toEqual([{ kind: "thread", thread: threads[0] }]); + expect(columns.review).toEqual([ + { + kind: "worktreeGroup", + worktreeKey: "later-group", + threads: [threads[2], threads[1]], + }, + ]); + expect(columns.settled).toEqual([]); + }); +}); + +describe("countBoardColumnThreads", () => { + it("counts a worktree group as its member count", () => { + const items: BoardColumnItem<{ readonly id: string }>[] = [ + { kind: "thread", thread: { id: "thread-1" } }, + { + kind: "worktreeGroup", + worktreeKey: "shared-worktree", + threads: [{ id: "thread-2" }, { id: "thread-3" }], + }, + ]; + expect(countBoardColumnThreads(items)).toBe(3); + expect(countBoardColumnThreads([])).toBe(0); + }); +}); + +describe("sliceBoardSettledItems", () => { + const thread = (id: string): BoardColumnItem<{ readonly id: string }> => ({ + kind: "thread", + thread: { id }, + }); + const group = ( + worktreeKey: string, + ...ids: string[] + ): BoardColumnItem<{ readonly id: string }> => ({ + kind: "worktreeGroup", + worktreeKey, + threads: ids.map((id) => ({ id })), + }); + + it("returns the same array with no hidden count when the total fits the limit", () => { + const items = [thread("thread-1"), group("shared-worktree", "thread-2", "thread-3")]; + const result = sliceBoardSettledItems(items, 3); + expect(result.visibleItems).toBe(items); + expect(result.hiddenThreadCount).toBe(0); + }); + + it("slices plain thread items at the limit", () => { + const items = [thread("thread-1"), thread("thread-2"), thread("thread-3")]; + const result = sliceBoardSettledItems(items, 2); + expect(columnThreadIds(result.visibleItems)).toEqual(["thread-1", "thread-2"]); + expect(result.hiddenThreadCount).toBe(1); + }); + + it("includes a group straddling the limit whole and counts its members", () => { + const items = [ + thread("thread-1"), + group("shared-worktree", "thread-2", "thread-3", "thread-4"), + thread("thread-5"), + ]; + const result = sliceBoardSettledItems(items, 2); + expect(result.visibleItems).toEqual([items[0], items[1]]); + expect(result.hiddenThreadCount).toBe(1); + }); + + it("returns no visible items for a zero limit with non-empty input", () => { + const items = [thread("thread-1"), thread("thread-2")]; + const result = sliceBoardSettledItems(items, 0); + expect(result.visibleItems).toEqual([]); + expect(result.hiddenThreadCount).toBe(2); + }); +}); + +describe("buildBoardProjectFilterPredicate", () => { + const projectId = ProjectId.make("project-1"); + const otherProjectId = ProjectId.make("project-2"); + const snapshots = [ + { + projectKey: "logical-project-1", + memberProjectRefs: [ + scopeProjectRef(localEnvironmentId, projectId), + scopeProjectRef(remoteEnvironmentId, projectId), + ], + }, + ]; + + it("matches everything when no project is selected or the stored key no longer resolves", () => { + const noSelection = buildBoardProjectFilterPredicate({ selectedProjectKey: null, snapshots }); + expect(noSelection({ environmentId: localEnvironmentId, projectId: otherProjectId })).toBe( + true, + ); + const staleSelection = buildBoardProjectFilterPredicate({ + selectedProjectKey: "removed-project", + snapshots, + }); + expect(staleSelection({ environmentId: localEnvironmentId, projectId: otherProjectId })).toBe( + true, + ); + }); + + it("matches threads from any member project of the selected group", () => { + const predicate = buildBoardProjectFilterPredicate({ + selectedProjectKey: "logical-project-1", + snapshots, + }); + expect(predicate({ environmentId: localEnvironmentId, projectId })).toBe(true); + expect(predicate({ environmentId: remoteEnvironmentId, projectId })).toBe(true); + expect(predicate({ environmentId: localEnvironmentId, projectId: otherProjectId })).toBe(false); + }); +}); + +describe("boardWorktreeKey", () => { + it("returns null without a dedicated worktree", () => { + expect(boardWorktreeKey({ environmentId: localEnvironmentId, worktreePath: null })).toBeNull(); + expect(boardWorktreeKey({ environmentId: localEnvironmentId, worktreePath: " " })).toBeNull(); + }); +}); + +describe("resolveBoardDropIntent", () => { + it("maps the drop-zone droppables to their intents and everything else to null", () => { + expect(resolveBoardDropIntent(BOARD_ARCHIVE_DROPPABLE_ID)).toBe("archive"); + expect(resolveBoardDropIntent(BOARD_TRASH_DROPPABLE_ID)).toBe("trash"); + expect(resolveBoardDropIntent(BOARD_UNSETTLE_DROPPABLE_ID)).toBe("unsettle"); + expect(resolveBoardDropIntent(BOARD_SETTLED_COLUMN_DROPPABLE_ID)).toBe("settle"); + expect(resolveBoardDropIntent("board-column-review")).toBeNull(); + expect(resolveBoardDropIntent(null)).toBeNull(); + }); +}); + +describe("parseBoardWorktreeGroupDragId", () => { + it("round-trips the worktree key through the group drag id and rejects thread drag ids", () => { + const worktreeKey = boardWorktreeKey({ + environmentId: localEnvironmentId, + worktreePath: "/wt", + }); + expect(worktreeKey).not.toBeNull(); + const dragId = boardWorktreeGroupDragId(worktreeKey ?? ""); + + expect(dragId).not.toBe(worktreeKey); + expect(parseBoardWorktreeGroupDragId(dragId)).toBe(worktreeKey); + expect(parseBoardWorktreeGroupDragId("environment-local thread-1")).toBeNull(); + }); +}); diff --git a/apps/mobile/src/features/board/boardLogic.ts b/apps/mobile/src/features/board/boardLogic.ts new file mode 100644 index 000000000000..c0b55a5f81f9 --- /dev/null +++ b/apps/mobile/src/features/board/boardLogic.ts @@ -0,0 +1,411 @@ +import { scopedProjectKey, scopeProjectRef } from "@t3tools/client-runtime/environment"; +import { toSortableTimestamp } from "@t3tools/client-runtime/state/thread-sort"; +import type { + EnvironmentId, + ProjectId, + ProviderInteractionMode, + ScopedProjectRef, + VcsStatusResult, +} from "@t3tools/contracts"; +import { resolveThreadChangeRequest } from "@t3tools/shared/sourceControl"; + +/** Web-compatible status labels used by column derivation. */ +export type BoardThreadStatusLabel = + | "Working" + | "Connecting" + | "Completed" + | "Pending Approval" + | "Awaiting Input" + | "Wake Required" + | "Plan Ready"; + +/** Same rules as web `isCompletionUnseen` (Sidebar.logic). */ +export function isCompletionUnseen( + completedAt: string | null | undefined, + lastVisitedAt: string | null | undefined, +): boolean { + if (!completedAt) return false; + const completedAtMs = Date.parse(completedAt); + if (Number.isNaN(completedAtMs)) return false; + if (!lastVisitedAt) return false; + const lastVisitedAtMs = Date.parse(lastVisitedAt); + if (Number.isNaN(lastVisitedAtMs)) return true; + return completedAtMs > lastVisitedAtMs; +} + +const resolveThreadPr = resolveThreadChangeRequest; + +export type BoardColumnId = "working" | "review" | "published" | "settled"; + +export const BOARD_COLUMN_IDS: readonly BoardColumnId[] = [ + "working", + "review", + "published", + "settled", +]; + +export const BOARD_COLUMN_LABELS: Record = { + working: "Working", + review: "Review", + published: "Published", + settled: "Settled", +}; + +export const BOARD_TRASH_DROPPABLE_ID = "board-trash"; +export const BOARD_ARCHIVE_DROPPABLE_ID = "board-archive"; +export const BOARD_UNSETTLE_DROPPABLE_ID = "board-unsettle"; +export const BOARD_SETTLED_COLUMN_DROPPABLE_ID = "board-column-settled"; + +export type BoardDropIntent = "archive" | "trash" | "settle" | "unsettle"; + +/** Drag-overlay feedback per drop intent, shared by the card and group overlays. */ +export const BOARD_DROP_INTENT_OVERLAY_CLASSES: Record = { + archive: "scale-90 border-amber-500 opacity-60", + trash: "scale-90 border-destructive opacity-60", + settle: "scale-90 border-primary opacity-60", + unsettle: "scale-90 border-emerald-500 opacity-60", +}; + +/** + * Intent implied by the droppable currently under the pointer, or null when + * the drag is over neither zone. Drives feedback on the dragged card itself — + * the card usually covers the drop zone, hiding the zone's own highlight. + */ +export function resolveBoardDropIntent( + droppableId: string | number | null | undefined, +): BoardDropIntent | null { + if (droppableId === BOARD_ARCHIVE_DROPPABLE_ID) return "archive"; + if (droppableId === BOARD_TRASH_DROPPABLE_ID) return "trash"; + if (droppableId === BOARD_UNSETTLE_DROPPABLE_ID) return "unsettle"; + if (droppableId === BOARD_SETTLED_COLUMN_DROPPABLE_ID) return "settle"; + return null; +} + +const BOARD_WORKTREE_GROUP_DRAG_PREFIX = "board-worktree-group\u0000"; + +/** Draggable id for a whole worktree group; drops act on every member thread. */ +export function boardWorktreeGroupDragId(worktreeKey: string): string { + return `${BOARD_WORKTREE_GROUP_DRAG_PREFIX}${worktreeKey}`; +} + +/** Worktree key encoded in a group draggable id, or null for thread drags. */ +export function parseBoardWorktreeGroupDragId( + dragId: string | number | null | undefined, +): string | null { + return typeof dragId === "string" && dragId.startsWith(BOARD_WORKTREE_GROUP_DRAG_PREFIX) + ? dragId.slice(BOARD_WORKTREE_GROUP_DRAG_PREFIX.length) + : null; +} + +export interface BoardColumnInput { + threadStatusLabel: BoardThreadStatusLabel | null; + interactionMode: ProviderInteractionMode; + isSettled: boolean; + latestTurnCompletedAt: string | null; + readySessionUpdatedAt: string | null; + lastVisitedAt: string | null; + threadBranch: string | null; + hasDedicatedWorktree: boolean; + hasWorkingThreadForWorktree: boolean; + gitStatus: VcsStatusResult | null; +} + +/** + * Whether the thread completed after the user's last visit. Falls back to the + * ready-session timestamp for providers whose shell cannot retain a + * latest-turn summary; both sources follow the sidebar's `isCompletionUnseen` + * rules. + */ +export function hasUnseenBoardCompletion( + input: Pick< + BoardColumnInput, + "latestTurnCompletedAt" | "readySessionUpdatedAt" | "lastVisitedAt" + >, +): boolean { + return isCompletionUnseen( + input.latestTurnCompletedAt ?? input.readySessionUpdatedAt, + input.lastVisitedAt, + ); +} + +/** + * Cache key for the board's aggregated VCS status map. Matches the dedupe + * granularity of the underlying subscription family: one entry per unique + * (environmentId, cwd) pair. + */ +export function boardGitKey(environmentId: EnvironmentId, cwd: string): string { + return `${environmentId}\u0000${cwd}`; +} + +/** + * Git status a thread may be attributed at all, or null. Threads sharing the + * project-root cwd must not inherit another branch's state, so without a + * dedicated worktree the checked-out ref has to match the thread's branch. + */ +export function resolveAppliedBoardGitStatus( + input: Pick, +): VcsStatusResult | null { + if (input.gitStatus === null || !input.gitStatus.isRepo) { + return null; + } + if (input.hasDedicatedWorktree) { + return input.gitStatus; + } + return input.threadBranch !== null && input.gitStatus.refName === input.threadBranch + ? input.gitStatus + : null; +} + +/** + * Lifecycle column for a thread. The server-backed settled flag is + * authoritative — safe to check first because `effectiveSettled` is never + * true for running or blocked threads, and it keeps a just-settled card from + * bouncing back to review on an unseen completion pill. Attention states win + * over the remaining lifecycle states: a thread blocked on the user + * (question/permission prompt) or holding an unseen completion sits in + * "review" regardless of git state. An actionable ready plan is also always + * reviewable. Git-driven columns still only move a card rightward as statuses + * stream in: unknown/unattributable git state falls through instead of + * guessing. + */ +export function deriveBoardColumn(input: BoardColumnInput): BoardColumnId { + if (input.isSettled) { + return "settled"; + } + + switch (input.threadStatusLabel) { + case "Pending Approval": + case "Awaiting Input": + case "Wake Required": + case "Plan Ready": + case "Completed": + return "review"; + case "Working": + case "Connecting": + return "working"; + case null: + break; + default: { + const exhaustiveStatusLabel: never = input.threadStatusLabel; + return exhaustiveStatusLabel; + } + } + + if (hasUnseenBoardCompletion(input)) { + return "review"; + } + + // A plan-mode thread does not own worktree changes made by the separate + // implementation thread that consumed its plan. Keep its column tied to + // its own attention/completion state instead of the shared worktree. + const gitStatus = input.interactionMode === "plan" ? null : resolveAppliedBoardGitStatus(input); + if (gitStatus !== null) { + const hasUnpublishedWork = + (gitStatus.hasWorkingTreeChanges && !input.hasWorkingThreadForWorktree) || + gitStatus.aheadCount > 0 || + (!gitStatus.hasUpstream && (gitStatus.aheadOfDefaultCount ?? 0) > 0); + if (hasUnpublishedWork) { + return "review"; + } + + // A merged PR is not special-cased here: it settles the thread through + // `effectiveSettled` upstream. When that is unavailable (pinned active, + // server without the settlement capability) the branch classifies by its + // git state alone, since it could not be moved out of Settled anyway. + const pr = resolveThreadPr(input.threadBranch, input.gitStatus); + const isCleanPushedFeatureBranch = + gitStatus.aheadCount === 0 && gitStatus.hasUpstream && !gitStatus.isDefaultRef; + if (pr?.state === "open" || isCleanPushedFeatureBranch) { + return "published"; + } + } + + return "review"; +} + +export interface BoardSortableThread { + readonly id: string; + readonly updatedAt: string; +} + +/** Sorts board threads newest-first by the timestamp selected for the column. */ +export function sortBoardThreads( + threads: readonly T[], + getSortTimestamp: (thread: T) => string | null, +): T[] { + return [...threads].sort((left, right) => { + const leftTimestamp = + toSortableTimestamp(getSortTimestamp(left) ?? undefined) ?? Number.NEGATIVE_INFINITY; + const rightTimestamp = + toSortableTimestamp(getSortTimestamp(right) ?? undefined) ?? Number.NEGATIVE_INFINITY; + if (leftTimestamp !== rightTimestamp) { + return rightTimestamp > leftTimestamp ? 1 : -1; + } + return left.id < right.id ? -1 : left.id > right.id ? 1 : 0; + }); +} + +export type BoardColumnItem = + | { readonly kind: "thread"; readonly thread: T } + | { + readonly kind: "worktreeGroup"; + readonly worktreeKey: string; + readonly threads: readonly T[]; + }; + +/** + * Builds board items in lifecycle order. A shared group is emitted on its + * first encounter, which is its earliest column and most recent member there. + * Its members are already ordered by actual column, then that column's time. + */ +export function buildBoardColumns( + threads: readonly T[], + getColumn: (thread: T) => BoardColumnId, + getWorkingStartedAt: (thread: T) => string | null, + getGroupKey: (thread: T) => string | null = () => null, +): Record[]> { + const threadsByColumn: Record = { + working: [], + review: [], + published: [], + settled: [], + }; + for (const thread of threads) { + threadsByColumn[getColumn(thread)].push(thread); + } + for (const columnId of BOARD_COLUMN_IDS) { + threadsByColumn[columnId] = sortBoardThreads( + threadsByColumn[columnId], + columnId === "working" + ? (thread) => getWorkingStartedAt(thread) ?? thread.updatedAt + : (thread) => thread.updatedAt, + ); + } + + const groupMembersByKey = new Map(); + for (const columnId of BOARD_COLUMN_IDS) { + for (const thread of threadsByColumn[columnId]) { + const groupKey = getGroupKey(thread); + if (groupKey === null) { + continue; + } + const members = groupMembersByKey.get(groupKey); + if (members) { + members.push(thread); + } else { + groupMembersByKey.set(groupKey, [thread]); + } + } + } + + const columns: Record[]> = { + working: [], + review: [], + published: [], + settled: [], + }; + const emittedGroupKeys = new Set(); + for (const columnId of BOARD_COLUMN_IDS) { + for (const thread of threadsByColumn[columnId]) { + const groupKey = getGroupKey(thread); + const groupMembers = groupKey === null ? undefined : groupMembersByKey.get(groupKey); + if (groupKey === null || groupMembers === undefined || groupMembers.length < 2) { + columns[columnId].push({ kind: "thread", thread }); + continue; + } + if (emittedGroupKeys.has(groupKey)) { + continue; + } + emittedGroupKeys.add(groupKey); + columns[columnId].push({ + kind: "worktreeGroup", + worktreeKey: groupKey, + threads: groupMembers, + }); + } + } + return columns; +} + +/** Total threads across column items; a worktree group counts each member. */ +export function countBoardColumnThreads(items: readonly BoardColumnItem[]): number { + return items.reduce( + (count, item) => count + (item.kind === "thread" ? 1 : item.threads.length), + 0, + ); +} + +/** + * Settled-tail slice for the board column. The limit counts threads (a + * worktree group counts as its member count) so paging matches the sidebar's + * thread-based tail; a group straddling the limit is included whole since a + * group card cannot render partially. + */ +export function sliceBoardSettledItems( + items: readonly BoardColumnItem[], + limit: number, +): { visibleItems: readonly BoardColumnItem[]; hiddenThreadCount: number } { + const total = countBoardColumnThreads(items); + if (total <= limit) { + return { visibleItems: items, hiddenThreadCount: 0 }; + } + const visibleItems: BoardColumnItem[] = []; + let shown = 0; + for (const item of items) { + if (shown >= limit) break; + visibleItems.push(item); + shown += item.kind === "thread" ? 1 : item.threads.length; + } + return { visibleItems, hiddenThreadCount: total - shown }; +} + +export interface BoardWorktreeThread { + readonly environmentId: EnvironmentId; + readonly worktreePath: string | null; +} + +/** + * Identity of a thread's dedicated worktree for board grouping, or null when + * the thread runs in the shared project checkout. Only dedicated worktrees + * group: threads in the project root are unrelated lines of work even though + * they share a checkout. + */ +export function boardWorktreeKey(thread: BoardWorktreeThread): string | null { + const worktreePath = thread.worktreePath?.trim(); + if (!worktreePath) { + return null; + } + return `${thread.environmentId}\u0000${worktreePath}`; +} + +export interface BoardProjectFilterThread { + readonly environmentId: EnvironmentId; + readonly projectId: ProjectId; +} + +/** + * Predicate matching threads against a selected sidebar project group. + * Membership is by scoped project ref so locally+remotely-open copies of the + * same repository stay one entry, matching the sidebar's grouping. An + * unresolvable stored key (project removed, grouping changed) matches + * everything, i.e. falls back to "All projects". + */ +export function buildBoardProjectFilterPredicate(input: { + selectedProjectKey: string | null; + snapshots: ReadonlyArray<{ + readonly projectKey: string; + readonly memberProjectRefs: readonly ScopedProjectRef[]; + }>; +}): (thread: BoardProjectFilterThread) => boolean { + const selectedSnapshot = + input.selectedProjectKey === null + ? null + : (input.snapshots.find((snapshot) => snapshot.projectKey === input.selectedProjectKey) ?? + null); + if (selectedSnapshot === null) { + return () => true; + } + const memberKeys = new Set(selectedSnapshot.memberProjectRefs.map(scopedProjectKey)); + return (thread) => + memberKeys.has(scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId))); +} diff --git a/apps/mobile/src/features/board/boardStatus.ts b/apps/mobile/src/features/board/boardStatus.ts new file mode 100644 index 000000000000..f7dc98785383 --- /dev/null +++ b/apps/mobile/src/features/board/boardStatus.ts @@ -0,0 +1,74 @@ +import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; +import { sessionNeedsWakeUp } from "@t3tools/shared/sessionWake"; + +import type { BoardThreadStatusLabel } from "./boardLogic"; + +/** + * Maps a live thread shell to the board status labels used by + * {@link deriveBoardColumn}. Labels match web `resolveThreadStatusPill` so + * column placement stays consistent across clients. + */ +export function resolveBoardThreadStatusLabel( + thread: Pick< + EnvironmentThreadShell, + | "hasPendingApprovals" + | "hasPendingUserInput" + | "hasActionableProposedPlan" + | "interactionMode" + | "latestTurn" + | "session" + >, +): BoardThreadStatusLabel | null { + if (thread.hasPendingApprovals) { + return "Pending Approval"; + } + if (thread.hasPendingUserInput) { + return "Awaiting Input"; + } + if ( + thread.interactionMode === "plan" && + thread.hasActionableProposedPlan && + !thread.hasPendingUserInput + ) { + return "Plan Ready"; + } + if (thread.session?.status === "running") { + return "Working"; + } + if (thread.session?.status === "starting") { + return "Connecting"; + } + if ( + sessionNeedsWakeUp({ + sessionStatus: thread.session?.status ?? null, + activeTurnId: thread.session?.activeTurnId ?? null, + latestTurnState: thread.latestTurn?.state ?? null, + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + }) + ) { + return "Wake Required"; + } + // Mobile has no last-visited tracking yet, so the web "Completed" (unseen) + // pill is not emitted here. Unseen-completion still flows through + // deriveBoardColumn via lastVisitedAt when that lands later. + return null; +} + +/** Working-column sort timestamp for a running turn, matching web board. */ +export function resolveBoardWorkingStartedAt( + thread: Pick, +): string | null { + const turn = thread.latestTurn; + if (turn && turn.completedAt === null) { + return firstValidTimestamp(turn.startedAt, turn.requestedAt, thread.session?.updatedAt); + } + return firstValidTimestamp(thread.session?.updatedAt); +} + +function firstValidTimestamp(...candidates: Array): string | null { + for (const candidate of candidates) { + if (candidate == null) continue; + if (!Number.isNaN(Date.parse(candidate))) return candidate; + } + return null; +} diff --git a/apps/mobile/src/features/board/useBoardVcsStatuses.ts b/apps/mobile/src/features/board/useBoardVcsStatuses.ts new file mode 100644 index 000000000000..5d0a195aa343 --- /dev/null +++ b/apps/mobile/src/features/board/useBoardVcsStatuses.ts @@ -0,0 +1,71 @@ +import { useAtomValue } from "@effect/atom-react"; +import type { EnvironmentId, VcsStatusResult } from "@t3tools/contracts"; +import * as Option from "effect/Option"; +import { AsyncResult, Atom } from "effect/unstable/reactivity"; +import { useMemo, useRef } from "react"; + +import { vcsEnvironment } from "../../state/vcs"; +import { boardGitKey } from "./boardLogic"; + +export interface BoardVcsTarget { + readonly environmentId: EnvironmentId; + readonly cwd: string; +} + +const EMPTY_STATUSES_ATOM = Atom.make( + (): ReadonlyMap => new Map(), +).pipe(Atom.withLabel("mobile:board-vcs-statuses:empty")); + +/** + * Aggregated list-mode VCS status for the board (shared budgeted refresh) — + * same shape as web `useBoardVcsStatuses`. + */ +export function useBoardVcsStatuses( + targets: ReadonlyArray, +): ReadonlyMap { + const previousTargetsRef = useRef>([]); + const dedupedTargets = useMemo(() => { + const byKey = new Map(); + for (const target of targets) { + byKey.set(boardGitKey(target.environmentId, target.cwd), target); + } + const next = [...byKey.entries()].sort(([left], [right]) => + left < right ? -1 : left > right ? 1 : 0, + ); + const previous = previousTargetsRef.current; + if ( + previous.length === next.length && + previous.every(([key], index) => key === next[index]![0]) + ) { + return previous; + } + previousTargetsRef.current = next; + return next; + }, [targets]); + + const statusesAtom = useMemo(() => { + if (dedupedTargets.length === 0) { + return EMPTY_STATUSES_ATOM; + } + return Atom.make( + (get): ReadonlyMap => + new Map( + dedupedTargets.map(([key, target]) => [ + key, + Option.getOrNull( + AsyncResult.value( + get( + vcsEnvironment.listStatus({ + environmentId: target.environmentId, + input: { cwd: target.cwd }, + }), + ), + ), + ), + ]), + ), + ).pipe(Atom.withLabel(`mobile:board-vcs-statuses:${dedupedTargets.length}`)); + }, [dedupedTargets]); + + return useAtomValue(statusesAtom); +} diff --git a/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx b/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx index 5555548ff799..cbc19dedb18b 100644 --- a/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx +++ b/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx @@ -16,6 +16,7 @@ import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic"; import type { ConnectedEnvironmentSummary } from "../../state/remote-runtime-types"; import { serverEnvironment } from "../../state/server"; import { ConnectionStatusDot } from "./ConnectionStatusDot"; +import { HostResourceStatus } from "./HostResourceStatus"; function connectionStatusLabel(environment: ConnectedEnvironmentSummary): string | null { return connectionStatusText({ @@ -123,6 +124,11 @@ export function ConnectionEnvironmentRow(props: { ) : null} ) : null} + ): string { + if (pressure === "critical") return "text-danger-foreground"; + if (pressure === "warning") return "text-foreground-secondary"; + return "text-foreground-muted"; +} + +export function HostResourceStatus(props: { + readonly environmentId: EnvironmentId; + readonly environmentLabel: string; + readonly connected: boolean; +}) { + const { data, isPending, refresh } = useHostResourceSnapshot( + props.environmentId, + props.connected, + ); + if (!props.connected) return null; + + const unavailable = !data || data.status === "unavailable"; + return ( + + + {unavailable + ? isPending + ? "Reading host resources…" + : "Host resources unavailable" + : `C ${Math.round(data.cpuPercent ?? 0)}% · M ${Math.round(data.memoryUsedPercent ?? 0)}% · L ${data.loadAverage?.m1.toFixed(1) ?? "—"}`} + + { + event.stopPropagation(); + refresh(); + }} + > + + + + ); +} diff --git a/apps/mobile/src/features/connection/pairing.test.ts b/apps/mobile/src/features/connection/pairing.test.ts index 193927684794..18b6c71a293a 100644 --- a/apps/mobile/src/features/connection/pairing.test.ts +++ b/apps/mobile/src/features/connection/pairing.test.ts @@ -1,32 +1,11 @@ import { describe, expect, it } from "vite-plus/test"; import { - buildPairingUrl, extractPairingUrlFromQrPayload, PairingQrPayloadEmptyError, parsePairingUrl, } from "./pairing"; -describe("buildPairingUrl", () => { - it("uses HTTP for a schemeless IP address", () => { - expect(buildPairingUrl("192.168.1.100:3773", "pairing-token")).toBe( - "http://192.168.1.100:3773/#token=pairing-token", - ); - }); - - it("keeps HTTPS as the default for a schemeless hostname", () => { - expect(buildPairingUrl("remote.example.com", "pairing-token")).toBe( - "https://remote.example.com/#token=pairing-token", - ); - }); - - it("preserves an explicit scheme for an IP address", () => { - expect(buildPairingUrl("https://192.168.1.100:3773", "pairing-token")).toBe( - "https://192.168.1.100:3773/#token=pairing-token", - ); - }); -}); - describe("extractPairingUrlFromQrPayload", () => { it("trims raw pairing urls from qr payloads", () => { expect( diff --git a/apps/mobile/src/features/files/ThreadFilesRouteScreen.tsx b/apps/mobile/src/features/files/ThreadFilesRouteScreen.tsx index 3be551d0604b..b62677a733c1 100644 --- a/apps/mobile/src/features/files/ThreadFilesRouteScreen.tsx +++ b/apps/mobile/src/features/files/ThreadFilesRouteScreen.tsx @@ -43,10 +43,7 @@ import { useAdaptiveWorkspacePaneRole, useRegisterWorkspaceInspector, } from "../layout/AdaptiveWorkspaceLayout"; -import { - createNativeMailSearchToolbarItem, - NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED, -} from "../layout/native-mail-search-toolbar"; +import { createNativeMailSearchToolbarItem } from "../layout/native-mail-search-toolbar"; import { WorkspaceSidebarToolbar } from "../layout/workspace-sidebar-toolbar"; import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; import { ThreadRouteScreen } from "../threads/ThreadRouteScreen"; @@ -422,8 +419,7 @@ export function ThreadFilesTreeScreen(props: ThreadFilesRouteScreenProps) { ); } - const usesCompactMailToolbar = - Platform.OS === "ios" && !layout.usesSplitView && NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED; + const usesCompactMailToolbar = Platform.OS === "ios" && !layout.usesSplitView; const content = ( <> diff --git a/apps/mobile/src/features/files/preload-workspace-file.ts b/apps/mobile/src/features/files/preload-workspace-file.ts index a91e4f84b0d0..8dba5e9d2b9d 100644 --- a/apps/mobile/src/features/files/preload-workspace-file.ts +++ b/apps/mobile/src/features/files/preload-workspace-file.ts @@ -4,6 +4,7 @@ import { isWorkspaceBrowserPreviewPath, isWorkspaceImagePreviewPath, } from "@t3tools/shared/filePreview"; +import { Atom } from "effect/unstable/reactivity"; import { appAtomRegistry } from "../../state/atom-registry"; import { projectEnvironment } from "../../state/projects"; @@ -14,6 +15,7 @@ import type { ReviewDiffTheme } from "../review/shikiReviewHighlighter"; const inFlightPreloads = new Map>(); const MAX_HIGHLIGHT_PRELOAD_CHARACTERS = 256 * 1024; +const WORKSPACE_FILE_PRELOAD_RETAIN_MS = 1_000; function preloadKey(input: { readonly cwd: string; @@ -44,10 +46,12 @@ export function preloadWorkspaceFileContents(input: { const preload = executeAtomQuery( appAtomRegistry, - projectEnvironment.readFile({ - environmentId: input.environmentId, - input: { cwd: input.cwd, relativePath: input.relativePath }, - }), + projectEnvironment + .readFile({ + environmentId: input.environmentId, + input: { cwd: input.cwd, relativePath: input.relativePath }, + }) + .pipe(Atom.setIdleTTL(WORKSPACE_FILE_PRELOAD_RETAIN_MS)), { label: "workspace file preload", reportDefect: false, diff --git a/apps/mobile/src/features/home/HomeHeader.tsx b/apps/mobile/src/features/home/HomeHeader.tsx index f67c2bff0f68..68f9006ba6fd 100644 --- a/apps/mobile/src/features/home/HomeHeader.tsx +++ b/apps/mobile/src/features/home/HomeHeader.tsx @@ -1,16 +1,28 @@ import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; import type { EnvironmentId, SidebarThreadSortOrder } from "@t3tools/contracts"; -import type { MenuAction } from "@react-native-menu/menu"; import Constants from "expo-constants"; -import { NativeHeaderToolbar, NativeStackScreenOptions } from "../../native/StackHeader"; +import type { MenuAction } from "@react-native-menu/menu"; +import { + NativeHeaderToolbar, + NativeStackScreenOptions, + nativeHeaderScrollEdgeEffects, +} from "../../native/StackHeader"; import { useCallback, useMemo, useRef } from "react"; -import { Platform, Pressable, Text as RNText, TextInput, View } from "react-native"; +import { + Platform, + Pressable, + Text as RNText, + TextInput, + useWindowDimensions, + View, +} from "react-native"; import type { SearchBarCommands } from "react-native-screens"; import { useSafeAreaInsets } from "react-native-safe-area-context"; import { ControlPillMenu } from "../../components/ControlPill"; import { SymbolView } from "../../components/AppSymbol"; import { T3Wordmark } from "../../components/T3Wordmark"; +import { NATIVE_LIQUID_GLASS_SUPPORTED } from "../../native/native-glass"; import { HOME_HORIZONTAL_INSET } from "../../lib/layoutMetrics"; import { resolveMobileStageLabel } from "../../lib/mobileBranding"; import { useUniwindTheme } from "../../lib/useUniwindTheme"; @@ -22,17 +34,41 @@ import { NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED, } from "../layout/native-mail-search-toolbar"; import type { HomeProjectSortOrder } from "./homeThreadList"; -import { WorkspaceConnectionTitle } from "./WorkspaceConnectionTitle"; +import { + getConnectionAwareBrandHeaderOptions, + WorkspaceConnectionTitle, +} from "./WorkspaceConnectionTitle"; import { buildHomeListFilterMenu, type HomeListFilterMenuEnvironment, type HomeListFilterMenuProject, } from "./home-list-filter-menu"; import { + DEFAULT_OWNERSHIP_FILTER, hasCustomHomeListOptions, + OWNERSHIP_FILTER_LABELS, + OWNERSHIP_FILTERS, + OWNERSHIP_RELATION_LABELS, + OWNERSHIP_RELATIONS, + type OwnershipFilter, + type OwnershipRelation, PROJECT_SORT_OPTIONS, THREAD_SORT_OPTIONS, } from "./home-list-options"; +import { isAllEnvironmentsSelected, isEnvironmentSelected } from "./homeEnvironmentFilter"; +import { + HOME_LIST_MODE_ICONS, + HOME_LIST_MODE_LABELS, + HOME_LIST_MODE_TITLES, + HOME_THREAD_GROUPING_LABELS, + HOME_THREAD_GROUPINGS, + otherHomeListModes, + usesProjectThreadGrouping, + type HomeListMode, + type HomeThreadGrouping, +} from "./homeListMode"; + +const HEADER_SCROLL_EDGE_EFFECTS = nativeHeaderScrollEdgeEffects(Platform.OS, Platform.Version); export type HomeHeaderEnvironment = HomeListFilterMenuEnvironment; @@ -40,13 +76,28 @@ export function HomeHeader(props: { readonly environments: ReadonlyArray; readonly projects: ReadonlyArray; readonly searchQuery: string; - readonly selectedEnvironmentId: EnvironmentId | null; + readonly listMode: HomeListMode; + readonly threadGrouping: HomeThreadGrouping; + readonly selectedEnvironmentIds: readonly EnvironmentId[]; readonly selectedProjectKey: string | null; + readonly ownershipFilter: OwnershipFilter; + readonly ownershipRelation: OwnershipRelation; + /** + * Hide settled from the main Threads inbox. Recency/none default on; + * project grouping defaults off at the call site. + */ + readonly hideSettledThreads: boolean; readonly projectSortOrder: HomeProjectSortOrder; readonly threadSortOrder: SidebarThreadSortOrder; readonly onSearchQueryChange: (query: string) => void; - readonly onEnvironmentChange: (environmentId: EnvironmentId | null) => void; + readonly onListModeChange: (mode: HomeListMode) => void; + readonly onThreadGroupingChange: (grouping: HomeThreadGrouping) => void; + readonly onClearEnvironments: () => void; + readonly onToggleEnvironment: (environmentId: EnvironmentId) => void; readonly onProjectChange: (projectKey: string | null) => void; + readonly onOwnershipFilterChange: (filter: OwnershipFilter) => void; + readonly onOwnershipRelationChange: (relation: OwnershipRelation) => void; + readonly onHideSettledThreadsChange: (hide: boolean) => void; readonly onProjectSortOrderChange: (sortOrder: HomeProjectSortOrder) => void; readonly onThreadSortOrderChange: (sortOrder: SidebarThreadSortOrder) => void; readonly onOpenEnvironments: () => void; @@ -66,17 +117,42 @@ function checkedMenuState(checked: boolean) { return checked ? ("on" as const) : undefined; } +/** Sort projects/threads only apply when Threads are grouped by project. */ +function usesListOrganization(listMode: HomeListMode, threadGrouping: HomeThreadGrouping) { + return listMode === "threads" && usesProjectThreadGrouping(threadGrouping); +} + +function defaultHideSettledForGrouping(threadGrouping: HomeThreadGrouping): boolean { + return !usesProjectThreadGrouping(threadGrouping); +} + function AndroidHomeHeader(props: HomeHeaderProps) { const { materialYouStyleLayoutActive } = useAppearancePreferences(); const insets = useSafeAreaInsets(); const stageLabel = resolveMobileStageLabel(Constants.expoConfig?.extra?.appVariant); - // Thread List v2 lays the list out in fixed creation order, so the - // sort/group filter controls would be silently ignored — hide them and - // key the "customized" icon state off the environment filter alone. const threadListV2Enabled = useThreadListV2Enabled(); - const hasCustomListOptions = threadListV2Enabled - ? props.selectedEnvironmentId !== null || props.selectedProjectKey !== null - : hasCustomHomeListOptions(props); + const listOrganization = + usesListOrganization(props.listMode, props.threadGrouping) && !threadListV2Enabled; + const alternateModes = otherHomeListModes(props.listMode); + const hasCustomListOptions = + props.selectedEnvironmentIds.length > 0 || + props.ownershipFilter !== DEFAULT_OWNERSHIP_FILTER || + props.ownershipRelation !== "both" || + props.selectedProjectKey !== null || + (props.listMode === "threads" && + props.hideSettledThreads !== defaultHideSettledForGrouping(props.threadGrouping)) || + props.threadGrouping !== "project" || + (listOrganization && + hasCustomHomeListOptions({ + selectedEnvironmentIds: props.selectedEnvironmentIds, + ownershipFilter: props.ownershipFilter, + ownershipRelation: props.ownershipRelation, + listMode: props.listMode, + threadGrouping: props.threadGrouping, + projectSortOrder: props.projectSortOrder, + threadSortOrder: props.threadSortOrder, + selectedProjectKey: props.selectedProjectKey, + })); const menuActions = useMemo( () => [ { @@ -86,16 +162,40 @@ function AndroidHomeHeader(props: HomeHeaderProps) { { id: "environment:all", title: "All environments", - state: checkedMenuState(props.selectedEnvironmentId === null), + state: checkedMenuState(isAllEnvironmentsSelected(props.selectedEnvironmentIds)), }, ...props.environments.map((environment) => ({ id: `environment:${environment.environmentId}`, title: environment.label, - state: checkedMenuState(props.selectedEnvironmentId === environment.environmentId), + state: checkedMenuState( + isEnvironmentSelected(props.selectedEnvironmentIds, environment.environmentId), + ), })), ], }, - ...(props.projects.length === 0 + { + id: "ownership", + title: "Ownership", + subactions: OWNERSHIP_FILTERS.map((value) => ({ + id: `ownership:${value}`, + title: OWNERSHIP_FILTER_LABELS[value], + state: checkedMenuState(value === props.ownershipFilter), + })), + }, + ...(props.ownershipFilter === "mine" || props.ownershipFilter === "theirs" + ? ([ + { + id: "ownership-relation", + title: props.ownershipFilter === "mine" ? "Mine includes" : "Theirs includes", + subactions: OWNERSHIP_RELATIONS.map((value) => ({ + id: `ownership-relation:${value}`, + title: OWNERSHIP_RELATION_LABELS[value], + state: checkedMenuState(value === props.ownershipRelation), + })), + }, + ] satisfies MenuAction[]) + : []), + ...(props.projects.length === 0 || props.listMode === "board" ? [] : ([ { @@ -115,9 +215,26 @@ function AndroidHomeHeader(props: HomeHeaderProps) { ], }, ] satisfies MenuAction[])), - ...(threadListV2Enabled - ? [] - : ([ + ...(props.listMode === "threads" + ? ([ + { + id: "grouping", + title: "Group threads", + subactions: HOME_THREAD_GROUPINGS.map((grouping) => ({ + id: `grouping:${grouping}`, + title: HOME_THREAD_GROUPING_LABELS[grouping], + state: checkedMenuState(props.threadGrouping === grouping), + })), + }, + { + id: "hide-settled", + title: "Hide settled", + state: checkedMenuState(props.hideSettledThreads), + }, + ] satisfies MenuAction[]) + : []), + ...(listOrganization + ? ([ { id: "project-sort", title: "Sort projects", @@ -136,34 +253,35 @@ function AndroidHomeHeader(props: HomeHeaderProps) { state: checkedMenuState(props.threadSortOrder === option.value), })), }, - ] satisfies MenuAction[])), + ] satisfies MenuAction[]) + : []), ], [ + listOrganization, props.environments, + props.hideSettledThreads, + props.listMode, + props.ownershipFilter, + props.ownershipRelation, props.projectSortOrder, props.projects, - props.selectedEnvironmentId, + props.selectedEnvironmentIds, props.selectedProjectKey, + props.threadGrouping, props.threadSortOrder, - threadListV2Enabled, ], ); const handleMenuAction = useCallback( (event: { nativeEvent: { event: string } }) => { const id = event.nativeEvent.event; if (id === "environment:all") { - props.onEnvironmentChange(null); + props.onClearEnvironments(); return; } if (id.startsWith("environment:")) { - const environmentId = id.slice("environment:".length); - const environment = props.environments.find( - (candidate) => candidate.environmentId === environmentId, - ); - if (environment) { - props.onEnvironmentChange(environment.environmentId); - } + const environmentId = id.slice("environment:".length) as EnvironmentId; + props.onToggleEnvironment(environmentId); return; } @@ -172,6 +290,22 @@ function AndroidHomeHeader(props: HomeHeaderProps) { return; } + if (id.startsWith("ownership-relation:")) { + const relation = id.slice("ownership-relation:".length); + if (relation === "created" || relation === "participated" || relation === "both") { + props.onOwnershipRelationChange(relation); + } + return; + } + + if (id.startsWith("ownership:")) { + const ownership = id.slice("ownership:".length); + if (ownership === "any" || ownership === "mine" || ownership === "theirs") { + props.onOwnershipFilterChange(ownership); + } + return; + } + if (id.startsWith("project:")) { const projectKey = id.slice("project:".length); if (props.projects.some((project) => project.key === projectKey)) { @@ -180,6 +314,19 @@ function AndroidHomeHeader(props: HomeHeaderProps) { return; } + if (id.startsWith("grouping:")) { + const grouping = id.slice("grouping:".length); + if (grouping === "recency" || grouping === "project" || grouping === "none") { + props.onThreadGroupingChange(grouping); + } + return; + } + + if (id === "hide-settled") { + props.onHideSettledThreadsChange(!props.hideSettledThreads); + return; + } + const projectSort = PROJECT_SORT_OPTIONS.find( (option) => id === `project-sort:${option.value}`, ); @@ -235,6 +382,23 @@ function AndroidHomeHeader(props: HomeHeaderProps) { } /> + {alternateModes.map((mode) => ( + props.onListModeChange(mode)} + className="size-11 items-center justify-center rounded-full bg-subtle" + > + + + ))} + - {/* Built identically to the filter button so the two circles - match exactly (ControlPill sizes via Tailwind classes and - resolves to a different box). */} - - - - {props.searchQuery.length > 0 ? ( - props.onSearchQueryChange("")} - > - - - ) : null} - + {props.listMode === "board" ? null : ( + + + + {props.searchQuery.length > 0 ? ( + props.onSearchQueryChange("")} + > + + + ) : null} + + )} @@ -320,35 +483,134 @@ function AndroidHomeHeader(props: HomeHeaderProps) { function IosHomeHeader(props: HomeHeaderProps) { const searchBarRef = useRef(null); - const iconColor = useUniwindTheme()["--color-icon"]; + const { width: headerWidth } = useWindowDimensions(); + const theme = useUniwindTheme(); + const iconColor = theme["--color-icon"]; + const sheetBackground = theme["--color-sheet"]; // Thread List v2 lays the list out in fixed creation order, so the // sort/group filter controls would be silently ignored — hide them and - // key the "customized" icon state off the environment filter alone. + // key the "customized" icon state off filters that still apply. const threadListV2Enabled = useThreadListV2Enabled(); - const hasCustomListOptions = threadListV2Enabled - ? props.selectedEnvironmentId !== null || props.selectedProjectKey !== null - : hasCustomHomeListOptions(props); + const listOrganization = + usesListOrganization(props.listMode, props.threadGrouping) && !threadListV2Enabled; + const alternateModes = otherHomeListModes(props.listMode); + const isBoardMode = props.listMode === "board"; + // Board columns are nested horizontal/vertical lists — not one UIKit scroll + // view that glass can sample / auto-inset. Use a solid bar so cards never + // paint under the status/nav chrome (same as the dedicated Board route). + const useSolidBoardHeader = isBoardMode && NATIVE_LIQUID_GLASS_SUPPORTED; + const hasCustomListOptions = + props.selectedEnvironmentIds.length > 0 || + props.ownershipFilter !== DEFAULT_OWNERSHIP_FILTER || + props.ownershipRelation !== "both" || + props.selectedProjectKey !== null || + (props.listMode === "threads" && + props.hideSettledThreads !== defaultHideSettledForGrouping(props.threadGrouping)) || + props.threadGrouping !== "project" || + (listOrganization && + hasCustomHomeListOptions({ + selectedEnvironmentIds: props.selectedEnvironmentIds, + ownershipFilter: props.ownershipFilter, + ownershipRelation: props.ownershipRelation, + listMode: props.listMode, + threadGrouping: props.threadGrouping, + projectSortOrder: props.projectSortOrder, + threadSortOrder: props.threadSortOrder, + selectedProjectKey: props.selectedProjectKey, + })); const focusSearch = useCallback(() => { searchBarRef.current?.focus(); return searchBarRef.current !== null; }, []); useHardwareKeyboardCommand("focusSearch", focusSearch); const filterMenu = buildHomeListFilterMenu({ - ...props, - listOrganization: !threadListV2Enabled, + environments: props.environments, + projects: props.projects, + selectedEnvironmentIds: props.selectedEnvironmentIds, + selectedProjectKey: props.selectedProjectKey, + ownershipFilter: props.ownershipFilter, + ownershipRelation: props.ownershipRelation, + projectSortOrder: props.projectSortOrder, + threadSortOrder: props.threadSortOrder, + onClearEnvironments: props.onClearEnvironments, + onToggleEnvironment: props.onToggleEnvironment, + onProjectChange: props.onProjectChange, + onOwnershipFilterChange: props.onOwnershipFilterChange, + onOwnershipRelationChange: props.onOwnershipRelationChange, + onProjectSortOrderChange: props.onProjectSortOrderChange, + onThreadSortOrderChange: props.onThreadSortOrderChange, + listOrganization, + showProjectFilter: props.listMode !== "board", + threadGrouping: props.listMode === "threads" ? props.threadGrouping : undefined, + onThreadGroupingChange: props.listMode === "threads" ? props.onThreadGroupingChange : undefined, + ...(props.listMode === "threads" + ? { + hideSettledThreads: props.hideSettledThreads, + onHideSettledThreadsChange: props.onHideSettledThreadsChange, + } + : {}), }); + const headerTitle = HOME_LIST_MODE_TITLES[props.listMode]; + return ( <> + {headerTitle} + + ), + }), headerTintColor: iconColor, + // Explicitly toggle glass ↔ solid when switching modes so board + // underlap does not stick after leaving Board, and vice versa. + ...(NATIVE_LIQUID_GLASS_SUPPORTED + ? useSolidBoardHeader + ? { + headerTransparent: false, + // native-stack types backgroundColor as string; ColorValue is fine at runtime. + headerStyle: { + backgroundColor: sheetBackground as unknown as string, + }, + scrollEdgeEffects: undefined, + } + : { + headerTransparent: true, + headerStyle: { backgroundColor: "transparent" }, + scrollEdgeEffects: HEADER_SCROLL_EDGE_EFFECTS, + } + : {}), unstable_headerRightItems: Platform.OS === "ios" ? () => [ + ...alternateModes.map((mode) => + withNativeGlassHeaderItem({ + accessibilityLabel: HOME_LIST_MODE_LABELS[mode], + icon: { name: HOME_LIST_MODE_ICONS[mode], type: "sfSymbol" } as const, + identifier: `home-mode-${mode}`, + label: "", + onPress: () => props.onListModeChange(mode), + type: "button", + }), + ), withNativeGlassHeaderItem({ accessibilityLabel: "Open settings", icon: { name: "ellipsis", type: "sfSymbol" } as const, @@ -359,47 +621,71 @@ function IosHomeHeader(props: HomeHeaderProps) { }), ] : undefined, - // The keys below are set per-branch (not `undefined`) so a later - // reapply cannot clobber options owned by NativeHeaderToolbar. + // Board has no thread search. Mail-search toolbar is iOS 26+ only; + // pre-Liquid-Glass falls back to the standard nav search field. + // Keys are omitted (not `undefined`) on the NativeHeaderToolbar + // fallback so a reapply cannot clobber options that toolbar owns. ...(NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED - ? { - unstable_headerToolbarItems: () => [ - createNativeMailSearchToolbarItem({ - composeButtonId: "home-new-task", - composeSystemImageName: "square.and.pencil", - filterMenu, - filterButtonId: "home-filter", - filterSystemImageName: hasCustomListOptions - ? "line.3.horizontal.decrease.circle.fill" - : "line.3.horizontal.decrease", - onComposePress: props.onStartNewTask, - onSearchTextChange: props.onSearchQueryChange, + ? isBoardMode + ? { unstable_headerToolbarItems: undefined } + : { + unstable_headerToolbarItems: () => [ + createNativeMailSearchToolbarItem({ + composeButtonId: "home-new-task", + composeSystemImageName: "square.and.pencil", + filterMenu, + filterButtonId: "home-filter", + filterSystemImageName: hasCustomListOptions + ? "line.3.horizontal.decrease.circle.fill" + : "line.3.horizontal.decrease", + onComposePress: props.onStartNewTask, + onSearchTextChange: props.onSearchQueryChange, + placeholder: "Search", + searchTextChangeId: "home-search-text", + showsSearchDismissButton: true, + }), + ], + } + : isBoardMode + ? {} + : { + headerSearchBarOptions: { + ref: searchBarRef, + autoCapitalize: "none" as const, + hideNavigationBar: false, placeholder: "Search", - searchTextChangeId: "home-search-text", - showsSearchDismissButton: true, - }), - ], - } - : { - // Pre-Liquid-Glass iOS: standard pull-down search in the nav - // bar; create + sort live in the plain bottom toolbar below. - headerSearchBarOptions: { - ref: searchBarRef, - autoCapitalize: "none" as const, - hideNavigationBar: false, - placeholder: "Search", - onCancelButtonPress: () => { - props.onSearchQueryChange(""); + onCancelButtonPress: () => { + props.onSearchQueryChange(""); + }, + onChangeText: (event: { nativeEvent: { text: string } }) => { + props.onSearchQueryChange(event.nativeEvent.text); + }, }, - onChangeText: (event) => { - props.onSearchQueryChange(event.nativeEvent.text); - }, - }, - }), + }), }} /> - {NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED ? null : ( + {Platform.OS === "ios" ? null : ( + + {alternateModes.map((mode) => ( + props.onListModeChange(mode)} + separateBackground + /> + ))} + + + )} + + {NATIVE_MAIL_SEARCH_TOOLBAR_SUPPORTED || isBoardMode ? null : ( Environment props.onEnvironmentChange(null)} + isOn={isAllEnvironmentsSelected(props.selectedEnvironmentIds)} + onPress={() => props.onClearEnvironments()} subtitle="Show threads from every environment" > All environments @@ -423,8 +709,11 @@ function IosHomeHeader(props: HomeHeaderProps) { {props.environments.map((environment) => ( props.onEnvironmentChange(environment.environmentId)} + isOn={isEnvironmentSelected( + props.selectedEnvironmentIds, + environment.environmentId, + )} + onPress={() => props.onToggleEnvironment(environment.environmentId)} > {environment.label} @@ -453,37 +742,65 @@ function IosHomeHeader(props: HomeHeaderProps) { ) : null} - {threadListV2Enabled ? null : ( - - Sort projects - {PROJECT_SORT_OPTIONS.map((option) => ( - props.onProjectSortOrderChange(option.value)} - > - {option.label} - - ))} - - )} + {props.listMode === "threads" ? ( + <> + + Group threads + {HOME_THREAD_GROUPINGS.map((grouping) => ( + props.onThreadGroupingChange(grouping)} + > + + {HOME_THREAD_GROUPING_LABELS[grouping]} + + + ))} + + props.onHideSettledThreadsChange(!props.hideSettledThreads)} + subtitle="Move settled threads out of the main list" + > + Hide settled + + + ) : null} - {threadListV2Enabled ? null : ( - - Sort threads - {THREAD_SORT_OPTIONS.map((option) => ( - props.onThreadSortOrderChange(option.value)} - > - {option.label} - - ))} - - )} + {listOrganization ? ( + <> + + Sort projects + {PROJECT_SORT_OPTIONS.map((option) => ( + props.onProjectSortOrderChange(option.value)} + > + {option.label} + + ))} + + + + Sort threads + {THREAD_SORT_OPTIONS.map((option) => ( + props.onThreadSortOrderChange(option.value)} + > + {option.label} + + ))} + + + ) : null} - + + + + threads.filter((thread) => + threadMatchesMine({ + claimPersonId: claimPersonIdForEnvironment( + claimPersonIdByEnvironment, + thread.environmentId, + ), + originPersonId: thread.originSource?.personId ?? null, + participantPersonIds: (thread.participantSummaries ?? []).map( + (participant) => participant.personId, + ), + mode: listOptions.ownershipFilter, + relation: listOptions.ownershipRelation, + }), + ), + [ + claimPersonIdByEnvironment, + listOptions.ownershipFilter, + listOptions.ownershipRelation, + threads, + ], + ); + const preferencesResult = useAtomValue(mobilePreferencesAtom); + const savePreferences = useAtomSet(updateMobilePreferencesAtom); + // Recency/none default to hide settled; project grouping defaults to show. + const hideSettledOnRecent = AsyncResult.isSuccess(preferencesResult) + ? resolveHideSettledOnRecent(preferencesResult.value) + : true; + const hideSettledOnProjects = AsyncResult.isSuccess(preferencesResult) + ? resolveHideSettledOnProjects(preferencesResult.value) + : false; + const hideSettledThreads = + listOptions.threadGrouping === "project" ? hideSettledOnProjects : hideSettledOnRecent; + const setHideSettledThreads = useCallback( + (hide: boolean) => { + if (listOptions.threadGrouping === "project") { + savePreferences({ hideSettledOnProjects: hide }); + return; + } + savePreferences({ hideSettledOnRecent: hide }); + }, + [listOptions.threadGrouping, savePreferences], + ); const [selectedProjectKey, setSelectedProjectKey] = useState(null); const projectFilterOptions = useMemo( () => buildHomeProjectScopes({ projects, - environmentId: selectedEnvironmentId, + selectedEnvironmentIds, projectGroupingMode: listOptions.projectGroupingMode, }).map((scope) => ({ key: scope.key, label: scope.title, })), - [listOptions.projectGroupingMode, projects, selectedEnvironmentId], + [listOptions.projectGroupingMode, projects, selectedEnvironmentIds], ); useEffect(() => { if ( @@ -138,19 +200,11 @@ export function HomeRouteScreen() { > <> {/* Restore the header after leaving split view; screen options are - shallow-merged. The brand slot also doubles as the connection - status surface while an environment reconnects. */} + shallow-merged. Title/brand stay on HomeHeader (list-mode title + + connection-aware slot) so we do not paint the status twice. */} - navigation.navigate("SettingsSheet", { - screen: "SettingsContent", - params: { screen: "SettingsEnvironments" }, - }), - }), headerShown: true, }} /> @@ -158,12 +212,23 @@ export function HomeRouteScreen() { environments={environments} projects={projectFilterOptions} searchQuery={searchQuery} - selectedEnvironmentId={selectedEnvironmentId} + listMode={listOptions.listMode} + threadGrouping={listOptions.threadGrouping} + selectedEnvironmentIds={selectedEnvironmentIds} selectedProjectKey={selectedProjectKey} + ownershipFilter={listOptions.ownershipFilter} + ownershipRelation={listOptions.ownershipRelation} + hideSettledThreads={hideSettledThreads} projectSortOrder={listOptions.projectSortOrder} threadSortOrder={listOptions.threadSortOrder} - onEnvironmentChange={setSelectedEnvironmentId} + onListModeChange={setListMode} + onThreadGroupingChange={setThreadGrouping} + onClearEnvironments={clearSelectedEnvironments} + onToggleEnvironment={toggleSelectedEnvironmentId} onProjectChange={setSelectedProjectKey} + onOwnershipFilterChange={setOwnershipFilter} + onOwnershipRelationChange={setOwnershipRelation} + onHideSettledThreadsChange={setHideSettledThreads} onOpenEnvironments={() => navigation.navigate("SettingsSheet", { screen: "SettingsContent", @@ -185,6 +250,9 @@ export function HomeRouteScreen() { navigation.navigate("SettingsSheet", { screen: "SettingsContent", @@ -199,9 +267,10 @@ export function HomeRouteScreen() { onUnsettleThread={unsettleThread} onPinThread={pinThread} onUnpinThread={unpinThread} + onClearEnvironments={clearSelectedEnvironments} + onToggleEnvironment={toggleSelectedEnvironmentId} onMoveThread={moveThread} onRegenerateThreadTitle={regenerateThreadTitle} - onEnvironmentChange={setSelectedEnvironmentId} onProjectChange={setSelectedProjectKey} onOpenSettings={() => navigation.navigate("SettingsSheet", { @@ -211,7 +280,15 @@ export function HomeRouteScreen() { } onProjectSortOrderChange={setProjectSortOrder} onSearchQueryChange={setSearchQuery} - onSelectThread={handleSelectThread} + onSelectThread={(thread) => { + // Settled threads are live shells: opening one is plain + // navigation, and sending a message un-settles server-side. + // Warm detail (SQLite/HTTP) before the route mounts so open + // latency overlaps the stack transition. + prefetchEnvironmentThread(thread.environmentId, thread.id); + warmSelectedEnvironmentThread(thread.environmentId, thread.id); + handleSelectThread(thread); + }} onSelectPendingTask={openPendingTask} onDeletePendingTask={confirmDeletePendingTask} onNewThreadOnBranch={(thread) => { @@ -243,9 +320,9 @@ export function HomeRouteScreen() { projectSortOrder={listOptions.projectSortOrder} savedConnectionsById={savedConnectionsById} searchQuery={searchQuery} - selectedEnvironmentId={selectedEnvironmentId} + selectedEnvironmentIds={selectedEnvironmentIds} selectedProjectKey={selectedProjectKey} - threads={threads} + threads={ownershipFilteredThreads} threadSortOrder={listOptions.threadSortOrder} /> diff --git a/apps/mobile/src/features/home/HomeScreen.tsx b/apps/mobile/src/features/home/HomeScreen.tsx index 4e01ef6077da..47cbedb9ba14 100644 --- a/apps/mobile/src/features/home/HomeScreen.tsx +++ b/apps/mobile/src/features/home/HomeScreen.tsx @@ -32,20 +32,23 @@ import { AppText as Text } from "../../components/AppText"; import { EmptyState } from "../../components/EmptyState"; import type { WorkspaceEnvironment, WorkspaceState } from "../../state/workspaceModel"; import type { SavedRemoteConnection } from "../../lib/connection"; -import { scopedProjectKey } from "../../lib/scopedEntities"; +import { scopedProjectKey, scopedThreadKey } from "../../lib/scopedEntities"; import { NATIVE_LIQUID_GLASS_SUPPORTED } from "../../native/native-glass"; + +const PRE_LIQUID_GLASS_BOTTOM_TOOLBAR_HEIGHT = 44; import { mobilePreferencesAtom, updateMobilePreferencesAtom } from "../../state/preferences"; import { useThreadSearch } from "../../state/queries"; +import { environmentServerConfigsAtom } from "../../state/server"; import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; -import { useThreadListV2Enabled } from "../threads/use-thread-list-v2-enabled"; import { usePendingThreadOrder } from "../../state/thread-order"; -import { environmentServerConfigsAtom } from "../../state/server"; import type { PendingNewTask } from "../../state/use-pending-new-tasks"; import { useQueuedThreadKeys } from "../../state/use-thread-outbox"; +import { BoardScreen } from "../board/BoardScreen"; import { PendingTaskListRow, ThreadListGroupHeader, ThreadListRow, + ThreadListSectionHeader, ThreadListShowMoreRow, } from "../threads/thread-list-items"; import { @@ -63,10 +66,12 @@ import { THREAD_LIST_V2_SETTLED_PAGE_COUNT, type ThreadListV2ListItem, } from "../threads/threadListV2"; +import { useThreadListV2Enabled } from "../threads/use-thread-list-v2-enabled"; import { useThreadListV2ShelfPreferences } from "../threads/use-thread-list-v2-shelf-preferences"; import type { HomeListFilterMenuEnvironment } from "./home-list-filter-menu"; import { buildHomeListLayout, + buildHomeRecentListLayout, DEFAULT_GROUP_DISPLAY_STATE, EMPTY_HOME_LIST_LAYOUT, homeListItemsAreEqual, @@ -75,6 +80,13 @@ import { type HomeGroupDisplayState, type HomeListItem, } from "./homeListItems"; +import { + usesFlatThreadGrouping, + usesProjectThreadGrouping, + type HomeListMode, + type HomeThreadGrouping, +} from "./homeListMode"; +import { buildHomeRecentListEntries, buildHomeRecentPendingEntries } from "./homeRecentList"; import { buildHomeProjectScopes, buildHomeThreadGroups, @@ -95,13 +107,26 @@ interface HomeScreenProps { HomeListFilterMenuEnvironment & Pick >; readonly searchQuery: string; - readonly selectedEnvironmentId: EnvironmentId | null; + readonly listMode: HomeListMode; + readonly threadGrouping: HomeThreadGrouping; + readonly selectedEnvironmentIds: readonly EnvironmentId[]; readonly selectedProjectKey: string | null; + /** + * When true, settled threads leave the main inbox: + * - **Threads v2:** always keeps a settled slim shelf (web V2 parity); this + * flag is ignored for the v2 partition. + * - **Classic recency/none:** collapsible-style bottom Settled section + * (web classic Recent shelf parity) — not hard-deleted. + * - **Classic project:** omit from each project group (web project parity). + * Recency/none default on; project grouping defaults off (call site). + */ + readonly hideSettledThreads: boolean; readonly projectSortOrder: HomeProjectSortOrder; readonly threadSortOrder: SidebarThreadSortOrder; readonly projectGroupingMode: SidebarProjectGroupingMode; readonly onSearchQueryChange: (query: string) => void; - readonly onEnvironmentChange: (environmentId: EnvironmentId | null) => void; + readonly onClearEnvironments: () => void; + readonly onToggleEnvironment: (environmentId: EnvironmentId) => void; readonly onProjectChange: (projectKey: string | null) => void; readonly onProjectSortOrderChange: (sortOrder: HomeProjectSortOrder) => void; readonly onThreadSortOrderChange: (sortOrder: SidebarThreadSortOrder) => void; @@ -135,7 +160,6 @@ interface HomeScreenProps { /* ─── Layout constants ───────────────────────────────────────────────── */ const ESTIMATED_THREAD_ROW_HEIGHT = 72; -const PRE_LIQUID_GLASS_BOTTOM_TOOLBAR_HEIGHT = 44; /** * Top spacing between the list and the Android custom header. The Android * header (AndroidHomeHeader) is rendered in-flow above this screen and @@ -218,7 +242,12 @@ export function HomeScreen(props: HomeScreenProps) { ReadonlyMap >(() => new Map()); const preferencesResult = useAtomValue(mobilePreferencesAtom); - const threadListV2Enabled = useThreadListV2Enabled(); + // Grouping changes V2 ordering only; the cards, pin block, and shelves are + // shared across project and recency modes. + // v2 is the default list since #5672; the legacy grouped list is the opt-in. + // The preference itself is upstream's hook — only the list-mode gate is ours. + const threadListV2Preferred = useThreadListV2Enabled(); + const threadListV2Enabled = props.listMode === "threads" && threadListV2Preferred; const queuedThreadKeys = useQueuedThreadKeys(); const savePreferences = useAtomSet(updateMobilePreferencesAtom); const openSwipeableRef = useRef(null); @@ -228,21 +257,16 @@ export function HomeScreen(props: HomeScreenProps) { Platform.OS === "ios" && !NATIVE_LIQUID_GLASS_SUPPORTED ? PRE_LIQUID_GLASS_BOTTOM_TOOLBAR_HEIGHT : 0; - const searchEnvironmentIds = useMemo( - () => - props.selectedEnvironmentId === null - ? props.environments - .filter((environment) => environment.connectionState === "connected") - .map((environment) => environment.environmentId) - : props.environments.some( - (environment) => - environment.environmentId === props.selectedEnvironmentId && - environment.connectionState === "connected", - ) - ? [props.selectedEnvironmentId] - : [], - [props.environments, props.selectedEnvironmentId], - ); + const searchEnvironmentIds = useMemo(() => { + const connectedIds = props.environments + .filter((environment) => environment.connectionState === "connected") + .map((environment) => environment.environmentId); + if (props.selectedEnvironmentIds.length === 0) { + return connectedIds; + } + const selected = new Set(props.selectedEnvironmentIds); + return connectedIds.filter((environmentId) => selected.has(environmentId)); + }, [props.environments, props.selectedEnvironmentIds]); const threadSearch = useThreadSearch(searchEnvironmentIds, props.searchQuery); const threadSearchMatchByKey = useMemo(() => { const matches = new Map(); @@ -317,10 +341,10 @@ export function HomeScreen(props: HomeScreenProps) { () => buildHomeProjectScopes({ projects: props.projects, - environmentId: props.selectedEnvironmentId, + selectedEnvironmentIds: props.selectedEnvironmentIds, projectGroupingMode: props.projectGroupingMode, }), - [props.projectGroupingMode, props.projects, props.selectedEnvironmentId], + [props.projectGroupingMode, props.projects, props.selectedEnvironmentIds], ); const selectedProjectScope = useMemo( () => @@ -384,50 +408,54 @@ export function HomeScreen(props: HomeScreenProps) { [threadListV2Enabled, props.pendingTasks, selectedProjectRefKeys], ); - const projectGroups = useMemo( + const showFlatThreadList = + props.listMode === "threads" && usesFlatThreadGrouping(props.threadGrouping); + const showProjectThreadList = + props.listMode === "threads" && usesProjectThreadGrouping(props.threadGrouping); + + const recentEntries = useMemo( () => - threadListV2Enabled - ? [] - : buildHomeThreadGroups({ + showFlatThreadList && !threadListV2Enabled + ? buildHomeRecentListEntries({ projects: scopedProjects, threads: scopedThreads, - pendingTasks: scopedPendingTasks, - queuedThreadKeys, - environmentId: props.selectedEnvironmentId, + selectedEnvironmentIds: props.selectedEnvironmentIds, + projectRefKeys: selectedProjectRefKeys, searchQuery: props.searchQuery, - matchedThreadKeys, - projectSortOrder: props.projectSortOrder, - threadSortOrder: props.threadSortOrder, - projectGroupingMode: props.projectGroupingMode, - }), + }) + : [], [ - threadListV2Enabled, - queuedThreadKeys, - props.projectGroupingMode, - props.projectSortOrder, props.searchQuery, - props.selectedEnvironmentId, - props.threadSortOrder, - matchedThreadKeys, - scopedPendingTasks, + props.selectedEnvironmentIds, scopedProjects, scopedThreads, + selectedProjectRefKeys, + showFlatThreadList, + threadListV2Enabled, ], ); - - const hasSearchQuery = props.searchQuery.trim().length > 0; - const listLayout = useMemo( + const recentPendingEntries = useMemo( () => - threadListV2Enabled - ? EMPTY_HOME_LIST_LAYOUT - : buildHomeListLayout({ - groups: projectGroups, - displayStates: effectiveGroupDisplayStates, - showAllThreads: hasSearchQuery, - }), - [threadListV2Enabled, projectGroups, effectiveGroupDisplayStates, hasSearchQuery], + showFlatThreadList && !threadListV2Enabled + ? buildHomeRecentPendingEntries({ + pendingTasks: scopedPendingTasks, + selectedEnvironmentIds: props.selectedEnvironmentIds, + projectRefKeys: selectedProjectRefKeys, + searchQuery: props.searchQuery, + }) + : [], + [ + props.searchQuery, + props.selectedEnvironmentIds, + scopedPendingTasks, + selectedProjectRefKeys, + showFlatThreadList, + threadListV2Enabled, + ], ); + const hasSearchQuery = props.searchQuery.trim().length > 0; + const projectByKey = useMemo(() => { const map = new Map(); for (const project of props.projects) { @@ -435,6 +463,13 @@ export function HomeScreen(props: HomeScreenProps) { } return map; }, [props.projects]); + const projectCwdByKey = useMemo(() => { + const map = new Map(); + for (const project of props.projects) { + map.set(scopedProjectKey(project.environmentId, project.id), project.workspaceRoot); + } + return map; + }, [props.projects]); const v2ProjectScopeKey = props.selectedProjectKey; const v2ScopeProjects = useMemo( @@ -449,7 +484,7 @@ export function HomeScreen(props: HomeScreenProps) { props.pendingTasks, props.projects, props.projectSortOrder, - props.selectedEnvironmentId, + props.selectedEnvironmentIds, props.threads, projectScopes, ], @@ -539,12 +574,12 @@ export function HomeScreen(props: HomeScreenProps) { ); const handleDeleteThread = props.onDeleteThread; const handleUnsettleThread = props.onUnsettleThread; - // The settled tail renders in pages; expansion resets when the filter - // context changes so environment/search flips never inherit a deep page. + // Settled shelf/tail paging (v2 always; classic recency/none when hide + // settled shelves history). Expansion resets when filter context changes. const [settledVisibleCount, setSettledVisibleCount] = useState( THREAD_LIST_V2_SETTLED_INITIAL_COUNT, ); - const settledResetKey = `${props.selectedEnvironmentId ?? "all"}:${v2ProjectScopeKey ?? "all"}:${props.searchQuery.trim()}`; + const settledResetKey = `${props.selectedEnvironmentIds.join(",") || "all"}:${v2ProjectScopeKey ?? "all"}:${props.searchQuery.trim()}`; const lastSettledResetKeyRef = useRef(settledResetKey); if (lastSettledResetKeyRef.current !== settledResetKey) { lastSettledResetKeyRef.current = settledResetKey; @@ -567,14 +602,15 @@ export function HomeScreen(props: HomeScreenProps) { // next wake boundary re-runs the partition with a fresh clock so a woken // thread reappears immediately instead of on the next minute tick. const [snoozeWakeTick, bumpSnoozeWakeTick] = useState(0); + const needsSettlementClock = threadListV2Enabled || props.listMode === "threads"; useFocusEffect( useCallback(() => { - if (!threadListV2Enabled) return; + if (!needsSettlementClock) return; // Refresh immediately on enable or focus because the previous value can be hours old. setNowMinute(new Date().toISOString().slice(0, 16)); const id = setInterval(() => setNowMinute(new Date().toISOString().slice(0, 16)), 60_000); return () => clearInterval(id); - }, [threadListV2Enabled]), + }, [needsSettlementClock]), ); // Threads on servers without the settlement capability never classify as // settled (the user could neither un-settle nor pin them). @@ -606,6 +642,186 @@ export function HomeScreen(props: HomeScreenProps) { } return supported; }, [serverConfigs]); + + // Settled classification for menu state + hide filter. Keys are env:threadId. + const settledThreadKeys = useMemo(() => { + if (props.listMode === "board") { + return new Set(); + } + const keys = new Set(); + for (const thread of scopedThreads) { + if (thread.archivedAt !== null) continue; + if (!settlementEnvironmentIds.has(thread.environmentId)) continue; + if (thread.settledOverride === "settled") { + keys.add(scopedThreadKey(thread.environmentId, thread.id)); + } + } + return keys; + }, [props.listMode, scopedThreads, settlementEnvironmentIds]); + + const threadsForProjectList = useMemo(() => { + if (!props.hideSettledThreads) return scopedThreads; + return scopedThreads.filter( + (thread) => !settledThreadKeys.has(scopedThreadKey(thread.environmentId, thread.id)), + ); + }, [props.hideSettledThreads, scopedThreads, settledThreadKeys]); + + const projectGroups = useMemo( + () => + showProjectThreadList && !threadListV2Enabled + ? buildHomeThreadGroups({ + projects: scopedProjects, + threads: threadsForProjectList, + pendingTasks: scopedPendingTasks, + queuedThreadKeys, + selectedEnvironmentIds: props.selectedEnvironmentIds, + searchQuery: props.searchQuery, + matchedThreadKeys, + projectSortOrder: props.projectSortOrder, + threadSortOrder: props.threadSortOrder, + projectGroupingMode: props.projectGroupingMode, + }) + : [], + [ + matchedThreadKeys, + props.projectGroupingMode, + props.projectSortOrder, + props.searchQuery, + props.selectedEnvironmentIds, + props.threadSortOrder, + queuedThreadKeys, + scopedPendingTasks, + scopedProjects, + showProjectThreadList, + threadListV2Enabled, + threadsForProjectList, + ], + ); + + // Classic flat/recency: when hide-settled, active inbox + settled shelf + // (web classic Recent). When hide is off, settled stay mixed into activity + // order like a normal flat list. + const { visibleRecentEntries, classicSettledEntries } = useMemo(() => { + if (!showFlatThreadList) { + return { + visibleRecentEntries: [] as ReadonlyArray<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }>, + classicSettledEntries: [] as ReadonlyArray<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }>, + }; + } + if (!props.hideSettledThreads) { + return { + visibleRecentEntries: recentEntries.map((entry) => ({ + thread: entry.thread, + projectTitle: entry.project.title, + })), + classicSettledEntries: [] as ReadonlyArray<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }>, + }; + } + const active: Array<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }> = []; + const settled: Array<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }> = []; + for (const entry of recentEntries) { + const key = scopedThreadKey(entry.thread.environmentId, entry.thread.id); + const row = { thread: entry.thread, projectTitle: entry.project.title }; + if (settledThreadKeys.has(key)) settled.push(row); + else active.push(row); + } + // History order: most recently settled/ended first (matches v2 tail). + settled.sort((left, right) => { + const leftMs = Date.parse( + left.thread.settledAt ?? left.thread.latestUserMessageAt ?? left.thread.updatedAt ?? "", + ); + const rightMs = Date.parse( + right.thread.settledAt ?? right.thread.latestUserMessageAt ?? right.thread.updatedAt ?? "", + ); + const safeLeft = Number.isNaN(leftMs) ? 0 : leftMs; + const safeRight = Number.isNaN(rightMs) ? 0 : rightMs; + return safeRight - safeLeft || left.thread.id.localeCompare(right.thread.id); + }); + return { visibleRecentEntries: active, classicSettledEntries: settled }; + }, [props.hideSettledThreads, recentEntries, settledThreadKeys, showFlatThreadList]); + + const classicSettledHiddenCount = Math.max(0, classicSettledEntries.length - settledVisibleCount); + const pagedClassicSettledEntries = useMemo( + () => classicSettledEntries.slice(0, settledVisibleCount), + [classicSettledEntries, settledVisibleCount], + ); + + const listLayout = useMemo(() => { + if (threadListV2Enabled) { + return EMPTY_HOME_LIST_LAYOUT; + } + if (showFlatThreadList) { + const activeLayout = buildHomeRecentListLayout({ + pendingTasks: recentPendingEntries.map((entry) => entry.pendingTask), + entries: visibleRecentEntries, + groupByRecency: props.threadGrouping === "recency", + }); + if (pagedClassicSettledEntries.length === 0) { + return activeLayout; + } + // Append Settled shelf under the active inbox (web classic Recent). + const items: HomeListItem[] = activeLayout.items.map((item, index) => { + if (index !== activeLayout.items.length - 1) return item; + if (item.type === "thread") return { ...item, isLast: false }; + if (item.type === "pending-task") return { ...item, isLast: false }; + return item; + }); + const stickyHeaderIndices = [...activeLayout.stickyHeaderIndices]; + stickyHeaderIndices.push(items.length); + items.push({ + type: "section-header", + key: "section:settled-shelf", + title: "Settled", + isFirst: items.length === 0, + }); + for (const [index, entry] of pagedClassicSettledEntries.entries()) { + items.push({ + type: "thread", + key: `thread:${entry.thread.environmentId}:${entry.thread.id}`, + thread: entry.thread, + projectTitle: entry.projectTitle, + isLast: + index === pagedClassicSettledEntries.length - 1 && classicSettledHiddenCount === 0, + }); + } + return { items, stickyHeaderIndices }; + } + if (!showProjectThreadList) { + return { items: [] as HomeListItem[], stickyHeaderIndices: [] as number[] }; + } + return buildHomeListLayout({ + groups: projectGroups, + displayStates: effectiveGroupDisplayStates, + showAllThreads: hasSearchQuery, + }); + }, [ + classicSettledHiddenCount, + effectiveGroupDisplayStates, + hasSearchQuery, + pagedClassicSettledEntries, + projectGroups, + props.threadGrouping, + recentPendingEntries, + showFlatThreadList, + showProjectThreadList, + threadListV2Enabled, + visibleRecentEntries, + ]); const pinReorderEnvironmentIds = useMemo(() => { const supported = new Set(); for (const [environmentId, config] of serverConfigs) { @@ -690,13 +906,14 @@ export function HomeScreen(props: HomeScreenProps) { settledShelfHeaderIndex: null, nextSnoozeWakeAt: null, }; - // Settled threads are live shells; archived threads keep their original - // "hidden from lists" meaning. + // Settled always partition into the slim tail (web Sidebar V2 / classic + // Recent shelf). Hide-settled must not drop that history on mobile. return buildThreadListV2Items({ pendingOrder, threads: props.threads.filter((thread) => thread.archivedAt === null), - environmentId: props.selectedEnvironmentId, + selectedEnvironmentIds: props.selectedEnvironmentIds, projectRefs: v2ScopedProjectGroup === null ? null : v2ScopedProjectGroup.projectRefs, + orderByRecency: props.threadGrouping === "recency", searchQuery: props.searchQuery, matchedThreadKeys, settlementEnvironmentIds, @@ -713,15 +930,16 @@ export function HomeScreen(props: HomeScreenProps) { queuedThreadKeys, nowMinute, snoozeWakeTick, - snoozedShelfExpanded, - settledShelfExpanded, settledVisibleCount, settlementEnvironmentIds, snoozeEnvironmentIds, + snoozedShelfExpanded, + settledShelfExpanded, + matchedThreadKeys, props.searchQuery, - props.selectedEnvironmentId, + props.threadGrouping, + props.selectedEnvironmentIds, props.threads, - matchedThreadKeys, threadListV2Enabled, v2ScopedProjectGroup, ]); @@ -739,17 +957,13 @@ export function HomeScreen(props: HomeScreenProps) { // unchanged: after a clamped fire (wake beyond the 32-bit setTimeout // range) the boundary string is identical and the chain would die. }, [nextSnoozeWakeAt, snoozeWakeTick]); - // Queued tasks are not thread shells, so the v2 partition never sees them; - // they are spliced in below the active block and stay visible and deletable - // while their environment is offline. Same environment scope and search - // filter as the list itself. const v2SearchQuery = props.searchQuery.trim().toLocaleLowerCase(); const v2PendingTasks = useMemo( () => props.pendingTasks.filter( (pendingTask) => - (props.selectedEnvironmentId === null || - pendingTask.environmentId === props.selectedEnvironmentId) && + (props.selectedEnvironmentIds.length === 0 || + props.selectedEnvironmentIds.includes(pendingTask.environmentId)) && (v2ScopedProjectKeys === null || v2ScopedProjectKeys.has( scopedProjectKey(pendingTask.environmentId, pendingTask.projectId), @@ -757,7 +971,7 @@ export function HomeScreen(props: HomeScreenProps) { (v2SearchQuery.length === 0 || pendingTask.title.toLocaleLowerCase().includes(v2SearchQuery)), ), - [props.pendingTasks, props.selectedEnvironmentId, v2ScopedProjectKeys, v2SearchQuery], + [props.pendingTasks, props.selectedEnvironmentIds, v2ScopedProjectKeys, v2SearchQuery], ); const threadListV2Items = useMemo( () => @@ -771,8 +985,16 @@ export function HomeScreen(props: HomeScreenProps) { settledShelfExpanded, settledShelfHeaderIndex: threadListV2Layout.settledShelfHeaderIndex, snoozeLabelNow: `${nowMinute}:00.000Z`, + groupByRecency: props.threadGrouping === "recency", }), - [settledShelfExpanded, snoozedShelfExpanded, threadListV2Layout, v2PendingTasks], + [ + nowMinute, + props.threadGrouping, + settledShelfExpanded, + snoozedShelfExpanded, + threadListV2Layout, + v2PendingTasks, + ], ); const renderV2Item = useCallback( @@ -825,6 +1047,13 @@ export function HomeScreen(props: HomeScreenProps) { /> ); } + if (item.type === "v2-recency-header") { + return ( + + {item.label} + + ); + } const thread = item.item.thread; const movePlanner = item.item.pinned ? threadMovePlanners.pinned : threadMovePlanners.active; const movedId = `${thread.environmentId}:${thread.id}`; @@ -881,6 +1110,9 @@ export function HomeScreen(props: HomeScreenProps) { onPinThread={handlePinThread} onUnpinThread={handleUnpinThread} onMoveThread={handleMoveThread} + projectCwd={ + projectCwdByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)) ?? null + } onSwipeableClose={handleSwipeableClose} onSwipeableWillOpen={handleSwipeableWillOpen} /> @@ -895,6 +1127,7 @@ export function HomeScreen(props: HomeScreenProps) { handleMoveThread, handlePinThread, handleRegenerateThreadTitle, + nowMinute, handleSettleThread, handleSnoozeThread, handleUnpinThread, @@ -905,25 +1138,23 @@ export function HomeScreen(props: HomeScreenProps) { pinningEnvironmentIds, machineByEnvironmentId, pinReorderEnvironmentIds, + snoozeEnvironmentIds, projectByKey, + projectCwdByKey, props.onArchiveThread, - props.onDeletePendingTask, - props.onSelectPendingTask, props.onSelectThread, props.onNewThreadOnBranch, props.savedConnectionsById, + props.searchQuery, serverConfigs, shelfPreferencesLoaded, settlementEnvironmentIds, - snoozeEnvironmentIds, threadListV2Items, threadSearchMatchByKey, titleRegenerationEnvironmentIds, toggleSettledShelf, toggleSnoozedShelf, v2ProjectTitleByProjectKey, - props.searchQuery, - nowMinute, ], ); const v2KeyExtractor = useCallback((item: ThreadListV2ListItem) => item.key, []); @@ -934,7 +1165,9 @@ export function HomeScreen(props: HomeScreenProps) { const v2ExtraData = useMemo( () => ({ projectByKey, + projectCwdByKey, projectTitleByProjectKey: v2ProjectTitleByProjectKey, + queuedThreadKeys, serverConfigs, savedConnectionsById: props.savedConnectionsById, searchQuery: props.searchQuery, @@ -943,8 +1176,10 @@ export function HomeScreen(props: HomeScreenProps) { }), [ projectByKey, + projectCwdByKey, props.searchQuery, props.savedConnectionsById, + queuedThreadKeys, serverConfigs, nowMinute, threadSearchMatchByKey, @@ -954,11 +1189,19 @@ export function HomeScreen(props: HomeScreenProps) { const extraData = useMemo( () => ({ + projectCwdByKey, + queuedThreadKeys, savedConnectionsById: props.savedConnectionsById, searchQuery: props.searchQuery, threadSearchMatchByKey, }), - [props.savedConnectionsById, props.searchQuery, threadSearchMatchByKey], + [ + projectCwdByKey, + props.savedConnectionsById, + props.searchQuery, + queuedThreadKeys, + threadSearchMatchByKey, + ], ); const renderItem = useCallback( @@ -983,6 +1226,8 @@ export function HomeScreen(props: HomeScreenProps) { title={item.group.title} /> ); + case "section-header": + return ; case "pending-task": return ( 1 || + usesFlatThreadGrouping(props.threadGrouping) + ? (props.savedConnectionsById[thread.environmentId]?.environmentLabel ?? null) + : null } environmentMachine={machineByEnvironmentId.get(thread.environmentId)} + projectCwd={ + projectCwdByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)) ?? + null + } isLast={item.isLast} searchMatch={threadSearchMatchByKey.get( threadSearchMatchKey({ @@ -1017,6 +1273,10 @@ export function HomeScreen(props: HomeScreenProps) { }), )} searchQuery={props.searchQuery} + settlementSupported={settlementEnvironmentIds.has(thread.environmentId)} + isSettled={settledThreadKeys.has(threadKey)} + onSettleThread={handleSettleThread} + onUnsettleThread={handleUnsettleThread} onArchiveThread={props.onArchiveThread} onDeleteThread={props.onDeleteThread} onRegenerateThreadTitle={handleRegenerateThreadTitle} @@ -1037,13 +1297,22 @@ export function HomeScreen(props: HomeScreenProps) { onGroupAction={updateGroupDisplay} /> ); + default: { + // Exhaustiveness guard: unknown item types must not throw on open. + const _exhaustive: never = item; + void _exhaustive; + return null; + } } }, [ + handleSettleThread, handleSwipeableClose, handleSwipeableWillOpen, + handleUnsettleThread, handleRegenerateThreadTitle, machineByEnvironmentId, + projectCwdByKey, queuedThreadKeys, props.onArchiveThread, props.onDeletePendingTask, @@ -1052,8 +1321,11 @@ export function HomeScreen(props: HomeScreenProps) { props.onSelectPendingTask, props.onSelectThread, props.onNewThreadOnBranch, - props.searchQuery, props.savedConnectionsById, + props.searchQuery, + props.threadGrouping, + settledThreadKeys, + settlementEnvironmentIds, threadSearchMatchByKey, titleRegenerationEnvironmentIds, updateGroupDisplay, @@ -1069,12 +1341,25 @@ export function HomeScreen(props: HomeScreenProps) { // so the v1 check already covers v2. const hasAnyThreads = props.threads.some((thread) => thread.archivedAt === null) || props.pendingTasks.length > 0; - const hasResults = threadListV2Enabled ? threadListV2Items.length > 0 : projectGroups.length > 0; + const hasResults = threadListV2Enabled + ? threadListV2Items.length > 0 + : showFlatThreadList + ? visibleRecentEntries.length > 0 || recentPendingEntries.length > 0 + : projectGroups.length > 0; const selectedEnvironmentLabel = - props.selectedEnvironmentId === null + props.selectedEnvironmentIds.length === 0 ? null - : (props.savedConnectionsById[props.selectedEnvironmentId]?.environmentLabel ?? - "this environment"); + : props.selectedEnvironmentIds.length === 1 + ? (props.savedConnectionsById[props.selectedEnvironmentIds[0]!]?.environmentLabel ?? + "this environment") + : `${props.selectedEnvironmentIds.length} environments`; + const environmentLabelById = useMemo(() => { + const map = new Map(); + for (const connection of Object.values(props.savedConnectionsById)) { + map.set(connection.environmentId, connection.environmentLabel); + } + return map; + }, [props.savedConnectionsById]); // Connection state surfaces in the header title slot // (WorkspaceConnectionTitle) — nothing renders inside the list, so // reconnects never shift the rows. @@ -1083,7 +1368,9 @@ export function HomeScreen(props: HomeScreenProps) { projectCount: props.projects.length, }); - if (!hasAnyThreads) { + // Board owns its empty chrome; connection-level empty still applies below + // for Recent/Projects when the workspace has no threads at all. + if (!hasAnyThreads && props.listMode !== "board") { return ( ) ) : null; - // Use the v2 project scope for its empty state. Snoozed threads need no - // special empty state: their shelf header is a list row even while collapsed. + // Self-contained: v1's listEmpty keys off projectGroups, which ignores the + // v2 project scope, so it can be null (results elsewhere) while this list + // is empty. Search outranks the scope — "No results" names the actionable + // fact when a query is active. Snoozed threads outrank the rest: "No + // threads yet" over an inbox that is merely all-snoozed reads as data + // loss. Pending tasks render in the header, so the list showing them + // isn't empty in the user's eyes. + const v2SnoozedCount = threadListV2Layout.snoozedCount; const v2ListEmpty = - hasSearchQuery && threadSearch.isPending ? null : hasSearchQuery ? ( - + v2PendingTasks.length > 0 ? null : hasSearchQuery ? ( + v2SnoozedCount > 0 ? ( + // The snoozed threads already passed this search filter: "No + // results" would claim nothing matched when matches are merely + // parked. + + ) : ( + + ) + ) : v2SnoozedCount > 0 ? ( + ) : v2ScopedProjectGroup !== null ? ( + ); + } + if (threadListV2Enabled) { return ( @@ -1227,11 +1562,30 @@ export function HomeScreen(props: HomeScreenProps) { data={listLayout.items} renderItem={renderItem} keyExtractor={keyExtractor} + // Mixed item types (headers, section-headers, threads, show-more) + // must not share recycle pools — missing this crashes / blanks rows + // once shells load (sidebar already passes getItemType). + getItemType={(item) => item.type} itemsAreEqual={homeListItemsAreEqual} drawDistance={500} estimatedItemSize={ESTIMATED_THREAD_ROW_HEIGHT} extraData={extraData} ListHeaderComponent={listHeader} + ListFooterComponent={ + classicSettledHiddenCount > 0 ? ( + ({ opacity: pressed ? 0.6 : 1 })} + > + + Show more ({classicSettledHiddenCount} settled hidden) + + + ) : null + } ListEmptyComponent={listEmpty} style={{ flex: 1 }} automaticallyAdjustsScrollIndicatorInsets={NATIVE_LIQUID_GLASS_SUPPORTED} diff --git a/apps/mobile/src/features/home/WorkspaceConnectionTitle.tsx b/apps/mobile/src/features/home/WorkspaceConnectionTitle.tsx index 9b9333b46c7f..6a62beb0fc26 100644 --- a/apps/mobile/src/features/home/WorkspaceConnectionTitle.tsx +++ b/apps/mobile/src/features/home/WorkspaceConnectionTitle.tsx @@ -1,6 +1,9 @@ -import type { NativeStackNavigationOptions } from "@react-navigation/native-stack"; +import type { + NativeStackHeaderItem, + NativeStackNavigationOptions, +} from "@react-navigation/native-stack"; import { useEffect, useRef, useState, type ReactNode } from "react"; -import { ActivityIndicator, Animated, Pressable, View } from "react-native"; +import { ActivityIndicator, Animated, Platform, Pressable, View } from "react-native"; import { SymbolView } from "../../components/AppSymbol"; import { AppText as Text } from "../../components/AppText"; @@ -9,6 +12,7 @@ import { CompactBrandTitle, getCompactBrandHeaderOptions, } from "../../components/CompactBrandTitle"; +import { NATIVE_LIQUID_GLASS_SUPPORTED } from "../../native/native-glass"; import { useWorkspaceState } from "../../state/workspace"; import { workspaceConnectionStatusPresentation, @@ -164,20 +168,55 @@ export function getConnectionAwareBrandHeaderOptions(opts: { readonly trailingItemCount?: number; readonly onOpenEnvironments: () => void; readonly fallbackTitleStyle?: NativeStackNavigationOptions["headerTitleStyle"]; + /** + * Screens whose native header shows something other than the brand lockup + * (this fork's list-mode titles: Threads / Projects / Board) pass their own + * title here. Without it the returned options overwrite the caller's + * `title`/`headerTitle` with the brand, silently dropping the mode name. + */ + readonly title?: string; + readonly brand?: ReactNode; }): NativeStackNavigationOptions { + const title = opts.title ?? "Threads"; // Leave room for bar margins, title spacing and the 44-point native actions. // Long status labels must not push Settings into UIKit's overflow menu. const maxWidth = Math.max(0, opts.headerWidth - 64 - 44 * (opts.trailingItemCount ?? 1)); + const brand = opts.brand ?? ; + const statusOffset = opts.brand === undefined ? brandTitleOffset() : undefined; + + if (Platform.OS === "ios" && NATIVE_LIQUID_GLASS_SUPPORTED) { + return { + headerTitle: title, + headerTitleStyle: { color: "transparent", fontSize: 18, fontWeight: "800" }, + title, + unstable_headerLeftItems: (): NativeStackHeaderItem[] => [ + { + element: ( + + ), + hidesSharedBackground: true, + type: "custom", + }, + ], + }; + } return { ...getCompactBrandHeaderOptions(opts.fallbackTitleStyle), headerTitle: () => ( } + brand={brand} maxWidth={maxWidth} onPress={opts.onOpenEnvironments} - statusOffset={brandTitleOffset()} + {...(statusOffset === undefined ? {} : { statusOffset })} /> ), + headerTitleStyle: opts.fallbackTitleStyle, + title, }; } diff --git a/apps/mobile/src/features/home/home-list-filter-menu.test.ts b/apps/mobile/src/features/home/home-list-filter-menu.test.ts index 99e3cb36c072..37a747e1c716 100644 --- a/apps/mobile/src/features/home/home-list-filter-menu.test.ts +++ b/apps/mobile/src/features/home/home-list-filter-menu.test.ts @@ -2,24 +2,42 @@ import { describe, expect, it, vi } from "vite-plus/test"; import { buildHomeListFilterMenu } from "./home-list-filter-menu"; +function baseProps( + overrides: Partial[0]> = {}, +): Parameters[0] { + return { + environments: [], + projects: [], + selectedEnvironmentIds: [], + selectedProjectKey: null, + ownershipFilter: "mine", + ownershipRelation: "both", + projectSortOrder: "updated_at", + threadSortOrder: "updated_at", + onClearEnvironments: vi.fn(), + onToggleEnvironment: vi.fn(), + onProjectChange: vi.fn(), + onOwnershipFilterChange: vi.fn(), + onOwnershipRelationChange: vi.fn(), + onProjectSortOrderChange: vi.fn(), + onThreadSortOrderChange: vi.fn(), + ...overrides, + }; +} + describe("buildHomeListFilterMenu", () => { it("adds a project scope submenu that selects and clears the same scope as the chips", () => { const onProjectChange = vi.fn(); - const menu = buildHomeListFilterMenu({ - environments: [], - projects: [ - { key: "environment-1:project-1", label: "Codething" }, - { key: "environment-1:project-2", label: "Website" }, - ], - selectedEnvironmentId: null, - selectedProjectKey: "environment-1:project-1", - projectSortOrder: "updated_at", - threadSortOrder: "updated_at", - onEnvironmentChange: vi.fn(), - onProjectChange, - onProjectSortOrderChange: vi.fn(), - onThreadSortOrderChange: vi.fn(), - }); + const menu = buildHomeListFilterMenu( + baseProps({ + projects: [ + { key: "environment-1:project-1", label: "Codething" }, + { key: "environment-1:project-2", label: "Website" }, + ], + selectedProjectKey: "environment-1:project-1", + onProjectChange, + }), + ); const projectMenu = menu.items.find( (item) => item.type === "submenu" && item.title === "Project", @@ -40,4 +58,93 @@ describe("buildHomeListFilterMenu", () => { expect(onProjectChange).toHaveBeenNthCalledWith(1, null); expect(onProjectChange).toHaveBeenNthCalledWith(2, "environment-1:project-2"); }); + + it("supports multi-select environment toggles", () => { + const onToggleEnvironment = vi.fn(); + const onClearEnvironments = vi.fn(); + const menu = buildHomeListFilterMenu( + baseProps({ + environments: [ + { environmentId: "env-1" as never, label: "Smart" }, + { environmentId: "env-2" as never, label: "t3vm" }, + ], + selectedEnvironmentIds: ["env-1" as never], + onClearEnvironments, + onToggleEnvironment, + }), + ); + + const environmentMenu = menu.items.find( + (item) => item.type === "submenu" && item.title === "Environment", + ); + expect(environmentMenu).toMatchObject({ + type: "submenu", + items: [ + { title: "All environments", state: "off" }, + { title: "Smart", state: "on" }, + { title: "t3vm", state: "off" }, + ], + }); + if (environmentMenu?.type !== "submenu") throw new Error("Expected environment submenu"); + environmentMenu.items[0]?.onPress(); + environmentMenu.items[2]?.onPress(); + expect(onClearEnvironments).toHaveBeenCalledOnce(); + expect(onToggleEnvironment).toHaveBeenCalledWith("env-2"); + }); + + it("offers Anyone, Mine, and Theirs ownership filters", () => { + const onOwnershipFilterChange = vi.fn(); + const menu = buildHomeListFilterMenu( + baseProps({ + ownershipFilter: "mine", + onOwnershipFilterChange, + }), + ); + + const ownershipMenu = menu.items.find( + (item) => item.type === "submenu" && item.title === "Ownership", + ); + expect(ownershipMenu).toMatchObject({ + type: "submenu", + items: [ + { title: "Anyone", state: "off" }, + { title: "Mine", state: "on" }, + { title: "Theirs", state: "off" }, + ], + }); + if (ownershipMenu?.type !== "submenu") throw new Error("Expected ownership submenu"); + ownershipMenu.items[2]?.onPress(); + expect(onOwnershipFilterChange).toHaveBeenCalledWith("theirs"); + }); + + it("offers created / participated / both sub-filters when Mine or Theirs is selected", () => { + const onOwnershipRelationChange = vi.fn(); + const menu = buildHomeListFilterMenu( + baseProps({ + ownershipFilter: "mine", + ownershipRelation: "created", + onOwnershipRelationChange, + }), + ); + + const relationMenu = menu.items.find( + (item) => item.type === "submenu" && item.title === "Mine includes", + ); + expect(relationMenu).toMatchObject({ + type: "submenu", + items: [ + { title: "Created or participated", state: "off" }, + { title: "Created", state: "on" }, + { title: "Participated", state: "off" }, + ], + }); + if (relationMenu?.type !== "submenu") throw new Error("Expected relation submenu"); + relationMenu.items[2]?.onPress(); + expect(onOwnershipRelationChange).toHaveBeenCalledWith("participated"); + + const anyoneMenu = buildHomeListFilterMenu(baseProps({ ownershipFilter: "any" })); + expect( + anyoneMenu.items.some((item) => item.type === "submenu" && item.title === "Mine includes"), + ).toBe(false); + }); }); diff --git a/apps/mobile/src/features/home/home-list-filter-menu.ts b/apps/mobile/src/features/home/home-list-filter-menu.ts index edd0176f8627..0e6f56d0ed8e 100644 --- a/apps/mobile/src/features/home/home-list-filter-menu.ts +++ b/apps/mobile/src/features/home/home-list-filter-menu.ts @@ -1,7 +1,22 @@ import type { EnvironmentId, SidebarThreadSortOrder } from "@t3tools/contracts"; +import { isAllEnvironmentsSelected, isEnvironmentSelected } from "./homeEnvironmentFilter"; +import { + HOME_THREAD_GROUPING_LABELS, + HOME_THREAD_GROUPINGS, + type HomeThreadGrouping, +} from "./homeListMode"; import type { HomeProjectSortOrder } from "./homeThreadList"; -import { PROJECT_SORT_OPTIONS, THREAD_SORT_OPTIONS } from "./home-list-options"; +import { + OWNERSHIP_FILTER_LABELS, + OWNERSHIP_FILTERS, + OWNERSHIP_RELATION_LABELS, + OWNERSHIP_RELATIONS, + PROJECT_SORT_OPTIONS, + THREAD_SORT_OPTIONS, + type OwnershipFilter, + type OwnershipRelation, +} from "./home-list-options"; export interface HomeListFilterMenuEnvironment { readonly environmentId: EnvironmentId; @@ -35,18 +50,35 @@ export interface HomeListFilterMenu { export function buildHomeListFilterMenu(props: { readonly environments: ReadonlyArray; readonly projects: ReadonlyArray; - readonly selectedEnvironmentId: EnvironmentId | null; + readonly selectedEnvironmentIds: readonly EnvironmentId[]; readonly selectedProjectKey: string | null; + readonly ownershipFilter: OwnershipFilter; + readonly ownershipRelation: OwnershipRelation; readonly projectSortOrder: HomeProjectSortOrder; readonly threadSortOrder: SidebarThreadSortOrder; - readonly onEnvironmentChange: (environmentId: EnvironmentId | null) => void; + readonly onClearEnvironments: () => void; + readonly onToggleEnvironment: (environmentId: EnvironmentId) => void; readonly onProjectChange: (projectKey: string | null) => void; + readonly onOwnershipFilterChange: (filter: OwnershipFilter) => void; + readonly onOwnershipRelationChange: (relation: OwnershipRelation) => void; readonly onProjectSortOrderChange: (sortOrder: HomeProjectSortOrder) => void; readonly onThreadSortOrderChange: (sortOrder: SidebarThreadSortOrder) => void; - /** False hides the sort/group submenus. Thread List v2 uses a fixed - creation-order layout, so offering those controls while it silently - ignores them would be a lie; the environment filter still applies. */ + /** + * False hides project/thread sort submenus. Flat recency, Board, and Thread + * List v2 use fixed layouts; the environment multi-filter still applies. + */ readonly listOrganization?: boolean; + /** When false, hide the project scope submenu (Board uses its own control). */ + readonly showProjectFilter?: boolean; + /** + * Threads surface: hide settled threads. When provided, the menu offers a + * toggle (recency/none default on; project defaults off at the call site). + */ + readonly hideSettledThreads?: boolean; + readonly onHideSettledThreadsChange?: (hide: boolean) => void; + /** When set, offers Group by recency / project / nothing. */ + readonly threadGrouping?: HomeThreadGrouping; + readonly onThreadGroupingChange?: (grouping: HomeThreadGrouping) => void; }): HomeListFilterMenu { const items: Array = []; @@ -58,22 +90,47 @@ export function buildHomeListFilterMenu(props: { type: "action", title: "All environments", subtitle: "Show threads from every environment", - state: props.selectedEnvironmentId === null ? "on" : "off", - onPress: () => props.onEnvironmentChange(null), + state: isAllEnvironmentsSelected(props.selectedEnvironmentIds) ? "on" : "off", + onPress: () => props.onClearEnvironments(), }, ...props.environments.map((environment) => ({ type: "action" as const, title: environment.label, - state: - props.selectedEnvironmentId === environment.environmentId - ? ("on" as const) - : ("off" as const), - onPress: () => props.onEnvironmentChange(environment.environmentId), + // When "all" is selected every row is visually on so multi-toggle is clear; + // pressing one leaves "all" and keeps only that environment. + state: isEnvironmentSelected(props.selectedEnvironmentIds, environment.environmentId) + ? ("on" as const) + : ("off" as const), + onPress: () => props.onToggleEnvironment(environment.environmentId), })), ], }); - if (props.projects.length > 0) { + items.push({ + type: "submenu", + title: "Ownership", + items: OWNERSHIP_FILTERS.map((value) => ({ + type: "action" as const, + title: OWNERSHIP_FILTER_LABELS[value], + state: props.ownershipFilter === value ? ("on" as const) : ("off" as const), + onPress: () => props.onOwnershipFilterChange(value), + })), + }); + + if (props.ownershipFilter === "mine" || props.ownershipFilter === "theirs") { + items.push({ + type: "submenu", + title: props.ownershipFilter === "mine" ? "Mine includes" : "Theirs includes", + items: OWNERSHIP_RELATIONS.map((value) => ({ + type: "action" as const, + title: OWNERSHIP_RELATION_LABELS[value], + state: props.ownershipRelation === value ? ("on" as const) : ("off" as const), + onPress: () => props.onOwnershipRelationChange(value), + })), + }); + } + + if (props.showProjectFilter !== false && props.projects.length > 0) { items.push({ type: "submenu", title: "Project", @@ -95,6 +152,29 @@ export function buildHomeListFilterMenu(props: { }); } + if (props.threadGrouping !== undefined && props.onThreadGroupingChange !== undefined) { + items.push({ + type: "submenu", + title: "Group threads", + items: HOME_THREAD_GROUPINGS.map((grouping) => ({ + type: "action" as const, + title: HOME_THREAD_GROUPING_LABELS[grouping], + state: props.threadGrouping === grouping ? ("on" as const) : ("off" as const), + onPress: () => props.onThreadGroupingChange?.(grouping), + })), + }); + } + + if (props.onHideSettledThreadsChange !== undefined && props.hideSettledThreads !== undefined) { + items.push({ + type: "action", + title: "Hide settled", + subtitle: "Move settled threads out of the main list", + state: props.hideSettledThreads ? "on" : "off", + onPress: () => props.onHideSettledThreadsChange?.(!props.hideSettledThreads), + }); + } + if (props.listOrganization !== false) { items.push( { diff --git a/apps/mobile/src/features/home/home-list-options.test.ts b/apps/mobile/src/features/home/home-list-options.test.ts index ac3893956ca7..79da58d80c04 100644 --- a/apps/mobile/src/features/home/home-list-options.test.ts +++ b/apps/mobile/src/features/home/home-list-options.test.ts @@ -4,10 +4,18 @@ import { } from "@t3tools/contracts"; import { describe, expect, it } from "vite-plus/test"; -import { hasCustomHomeListOptions, type HomeListOptions } from "./home-list-options"; +import { + DEFAULT_OWNERSHIP_FILTER, + hasCustomHomeListOptions, + type HomeListOptions, +} from "./home-list-options"; const defaults: HomeListOptions = { - selectedEnvironmentId: null, + selectedEnvironmentIds: [], + ownershipFilter: DEFAULT_OWNERSHIP_FILTER, + ownershipRelation: "both", + listMode: "threads", + threadGrouping: "project", projectSortOrder: DEFAULT_SIDEBAR_PROJECT_SORT_ORDER === "manual" ? "updated_at" @@ -22,10 +30,25 @@ describe("home list options", () => { it("marks environment filters as customized", () => { expect( - hasCustomHomeListOptions({ ...defaults, selectedEnvironmentId: "environment-1" as never }), + hasCustomHomeListOptions({ + ...defaults, + selectedEnvironmentIds: ["environment-1" as never], + }), ).toBe(true); expect( hasCustomHomeListOptions({ ...defaults, selectedProjectKey: "environment-1:project-1" }), ).toBe(true); }); + + it("marks ownership filters as customized", () => { + expect(hasCustomHomeListOptions({ ...defaults, ownershipFilter: "any" })).toBe(true); + expect(hasCustomHomeListOptions({ ...defaults, ownershipFilter: "theirs" })).toBe(true); + expect(hasCustomHomeListOptions({ ...defaults, ownershipRelation: "created" })).toBe(true); + }); + + it("marks non-default thread grouping as customized", () => { + expect(hasCustomHomeListOptions({ ...defaults, threadGrouping: "recency" })).toBe(true); + expect(hasCustomHomeListOptions({ ...defaults, threadGrouping: "none" })).toBe(true); + expect(hasCustomHomeListOptions({ ...defaults, threadGrouping: "project" })).toBe(false); + }); }); diff --git a/apps/mobile/src/features/home/home-list-options.ts b/apps/mobile/src/features/home/home-list-options.ts index 14f842d73e2c..113fc6e56cae 100644 --- a/apps/mobile/src/features/home/home-list-options.ts +++ b/apps/mobile/src/features/home/home-list-options.ts @@ -7,30 +7,96 @@ import { DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, DEFAULT_SIDEBAR_THREAD_SORT_ORDER, } from "@t3tools/contracts"; +import { + DEFAULT_OWNERSHIP_RELATION, + type OwnershipRelation, +} from "@t3tools/client-runtime/state/identity"; import { createContext, createElement, useCallback, useContext, + useEffect, useMemo, + useRef, useState, type PropsWithChildren, type Dispatch, type SetStateAction, } from "react"; +import { resolveSelectedEnvironmentIds, toggleEnvironmentId } from "./homeEnvironmentFilter"; +import { + DEFAULT_HOME_LIST_MODE, + DEFAULT_HOME_THREAD_GROUPING, + type HomeListMode, + type HomeThreadGrouping, +} from "./homeListMode"; import type { HomeProjectSortOrder } from "./homeThreadList"; +export type { OwnershipRelation }; +export { DEFAULT_OWNERSHIP_RELATION }; + export interface HomeListOptions { - readonly selectedEnvironmentId: EnvironmentId | null; + /** + * Multi-select environment filter. Empty means all environments. + * Applies to Threads and Board modes. Persisted on device when + * the provider is given a storage callback. + */ + readonly selectedEnvironmentIds: readonly EnvironmentId[]; + readonly ownershipFilter: OwnershipFilter; + /** + * Sub-filter for mine/theirs: created, participated, or both (default). + * Ignored when ownership is "any". Persisted with ownership filter. + */ + readonly ownershipRelation: OwnershipRelation; + readonly listMode: HomeListMode; + /** Organization of the Threads list (ignored on Board). */ + readonly threadGrouping: HomeThreadGrouping; readonly projectSortOrder: HomeProjectSortOrder; readonly threadSortOrder: SidebarThreadSortOrder; } +export type OwnershipFilter = "any" | "mine" | "theirs"; + +export const OWNERSHIP_FILTERS = [ + "any", + "mine", + "theirs", +] as const satisfies readonly OwnershipFilter[]; + +export const OWNERSHIP_FILTER_LABELS: Record = { + any: "Anyone", + mine: "Mine", + theirs: "Theirs", +}; + +export const OWNERSHIP_RELATIONS = [ + "both", + "created", + "participated", +] as const satisfies readonly OwnershipRelation[]; + +export const OWNERSHIP_RELATION_LABELS: Record = { + both: "Created or participated", + created: "Created", + participated: "Participated", +}; + +export function isOwnershipFilter(value: unknown): value is OwnershipFilter { + return value === "any" || value === "mine" || value === "theirs"; +} + export interface ResolvedHomeListOptions extends HomeListOptions { readonly projectGroupingMode: SidebarProjectGroupingMode; } +export function resolveProjectGroupingMode( + projectGroupingEnabled: boolean | undefined, +): SidebarProjectGroupingMode { + return projectGroupingEnabled === false ? "separate" : "repository"; +} + export const PROJECT_SORT_OPTIONS: ReadonlyArray<{ readonly value: HomeProjectSortOrder; readonly label: string; @@ -47,9 +113,16 @@ export const THREAD_SORT_OPTIONS: ReadonlyArray<{ { value: "created_at", label: "Created at" }, ]; +/** Default ownership filter: Mine (created or participated, plus unattributed). */ +export const DEFAULT_OWNERSHIP_FILTER: OwnershipFilter = "mine"; + function defaultHomeListOptions(): HomeListOptions { return { - selectedEnvironmentId: null, + selectedEnvironmentIds: [], + ownershipFilter: DEFAULT_OWNERSHIP_FILTER, + ownershipRelation: DEFAULT_OWNERSHIP_RELATION, + listMode: DEFAULT_HOME_LIST_MODE, + threadGrouping: DEFAULT_HOME_THREAD_GROUPING, projectSortOrder: DEFAULT_SIDEBAR_PROJECT_SORT_ORDER === "manual" ? "updated_at" @@ -58,6 +131,10 @@ function defaultHomeListOptions(): HomeListOptions { }; } +function environmentIdsKey(ids: readonly EnvironmentId[]): string { + return ids.join("\0"); +} + interface HomeListOptionsContextValue { readonly options: HomeListOptions; readonly setOptions: Dispatch>; @@ -66,14 +143,139 @@ interface HomeListOptionsContextValue { const HomeListOptionsContext = createContext(null); -/** Keeps list preferences stable while the app moves between compact and split shells. */ +/** + * Keeps list preferences stable while the app moves between compact and split + * shells. Optional stored* + store callbacks make filters survive app restarts + * (device preferences). Ownership is included so Mine/Theirs does not reset + * on every launch (especially painful on mobile). + */ export function HomeListOptionsProvider({ children, projectGroupingMode, + /** + * `undefined` = storage not loaded yet (do not hydrate). + * Array (possibly empty) = loaded value to apply once. + */ + storedEnvironmentIds, + onStoreEnvironmentIds, + /** + * `undefined` = storage not loaded yet (do not hydrate). + * Valid grouping = apply once when preferences land. + */ + storedThreadGrouping, + onStoreThreadGrouping, + /** + * `undefined` = storage not loaded yet (do not hydrate). + */ + storedOwnershipFilter, + onStoreOwnershipFilter, + storedOwnershipRelation, + onStoreOwnershipRelation, }: PropsWithChildren<{ readonly projectGroupingMode: SidebarProjectGroupingMode; + readonly storedEnvironmentIds?: readonly EnvironmentId[]; + readonly onStoreEnvironmentIds?: (ids: readonly EnvironmentId[]) => void; + readonly storedThreadGrouping?: HomeThreadGrouping; + readonly onStoreThreadGrouping?: (grouping: HomeThreadGrouping) => void; + readonly storedOwnershipFilter?: OwnershipFilter; + readonly onStoreOwnershipFilter?: (filter: OwnershipFilter) => void; + readonly storedOwnershipRelation?: OwnershipRelation; + readonly onStoreOwnershipRelation?: (relation: OwnershipRelation) => void; }>) { const [options, setOptions] = useState(defaultHomeListOptions); + const envFilterHydratedRef = useRef(false); + const lastPersistedEnvKeyRef = useRef(null); + const threadGroupingHydratedRef = useRef(false); + const lastPersistedThreadGroupingRef = useRef(null); + const ownershipFilterHydratedRef = useRef(false); + const lastPersistedOwnershipFilterRef = useRef(null); + const ownershipRelationHydratedRef = useRef(false); + const lastPersistedOwnershipRelationRef = useRef(null); + + useEffect(() => { + if (envFilterHydratedRef.current) return; + if (storedEnvironmentIds === undefined) return; + if (storedEnvironmentIds.length > 0) { + setOptions((current) => ({ + ...current, + selectedEnvironmentIds: storedEnvironmentIds, + })); + lastPersistedEnvKeyRef.current = environmentIdsKey(storedEnvironmentIds); + } else { + lastPersistedEnvKeyRef.current = ""; + } + envFilterHydratedRef.current = true; + }, [storedEnvironmentIds]); + + useEffect(() => { + if (!envFilterHydratedRef.current) return; + if (!onStoreEnvironmentIds) return; + const key = environmentIdsKey(options.selectedEnvironmentIds); + if (lastPersistedEnvKeyRef.current === key) return; + lastPersistedEnvKeyRef.current = key; + onStoreEnvironmentIds(options.selectedEnvironmentIds); + }, [onStoreEnvironmentIds, options.selectedEnvironmentIds]); + + useEffect(() => { + if (threadGroupingHydratedRef.current) return; + if (storedThreadGrouping === undefined) return; + setOptions((current) => + current.threadGrouping === storedThreadGrouping + ? current + : { ...current, threadGrouping: storedThreadGrouping }, + ); + lastPersistedThreadGroupingRef.current = storedThreadGrouping; + threadGroupingHydratedRef.current = true; + }, [storedThreadGrouping]); + + useEffect(() => { + if (!threadGroupingHydratedRef.current) return; + if (!onStoreThreadGrouping) return; + if (lastPersistedThreadGroupingRef.current === options.threadGrouping) return; + lastPersistedThreadGroupingRef.current = options.threadGrouping; + onStoreThreadGrouping(options.threadGrouping); + }, [onStoreThreadGrouping, options.threadGrouping]); + + useEffect(() => { + if (ownershipFilterHydratedRef.current) return; + if (storedOwnershipFilter === undefined) return; + setOptions((current) => + current.ownershipFilter === storedOwnershipFilter + ? current + : { ...current, ownershipFilter: storedOwnershipFilter }, + ); + lastPersistedOwnershipFilterRef.current = storedOwnershipFilter; + ownershipFilterHydratedRef.current = true; + }, [storedOwnershipFilter]); + + useEffect(() => { + if (!ownershipFilterHydratedRef.current) return; + if (!onStoreOwnershipFilter) return; + if (lastPersistedOwnershipFilterRef.current === options.ownershipFilter) return; + lastPersistedOwnershipFilterRef.current = options.ownershipFilter; + onStoreOwnershipFilter(options.ownershipFilter); + }, [onStoreOwnershipFilter, options.ownershipFilter]); + + useEffect(() => { + if (ownershipRelationHydratedRef.current) return; + if (storedOwnershipRelation === undefined) return; + setOptions((current) => + current.ownershipRelation === storedOwnershipRelation + ? current + : { ...current, ownershipRelation: storedOwnershipRelation }, + ); + lastPersistedOwnershipRelationRef.current = storedOwnershipRelation; + ownershipRelationHydratedRef.current = true; + }, [storedOwnershipRelation]); + + useEffect(() => { + if (!ownershipRelationHydratedRef.current) return; + if (!onStoreOwnershipRelation) return; + if (lastPersistedOwnershipRelationRef.current === options.ownershipRelation) return; + lastPersistedOwnershipRelationRef.current = options.ownershipRelation; + onStoreOwnershipRelation(options.ownershipRelation); + }, [onStoreOwnershipRelation, options.ownershipRelation]); + const value = useMemo( () => ({ options, setOptions, projectGroupingMode }), [options, projectGroupingMode], @@ -91,8 +293,11 @@ export function hasCustomHomeListOptions( ? "updated_at" : DEFAULT_SIDEBAR_PROJECT_SORT_ORDER; return ( - options.selectedEnvironmentId !== null || + options.selectedEnvironmentIds.length > 0 || + options.ownershipFilter !== DEFAULT_OWNERSHIP_FILTER || + options.ownershipRelation !== DEFAULT_OWNERSHIP_RELATION || (options.selectedProjectKey !== null && options.selectedProjectKey !== undefined) || + options.threadGrouping !== DEFAULT_HOME_THREAD_GROUPING || options.projectSortOrder !== defaultProjectSortOrder || options.threadSortOrder !== DEFAULT_SIDEBAR_THREAD_SORT_ORDER ); @@ -103,32 +308,82 @@ export function useHomeListOptions(availableEnvironmentIds: ReadonlySet(defaultHomeListOptions); const options = shared?.options ?? localOptions; const setOptions = shared?.setOptions ?? setLocalOptions; - const selectedEnvironmentId = - options.selectedEnvironmentId !== null && - availableEnvironmentIds.has(options.selectedEnvironmentId) - ? options.selectedEnvironmentId - : null; + const selectedEnvironmentIds = resolveSelectedEnvironmentIds( + options.selectedEnvironmentIds, + availableEnvironmentIds, + ); const availableOptions = - selectedEnvironmentId === options.selectedEnvironmentId + selectedEnvironmentIds === options.selectedEnvironmentIds ? options - : { ...options, selectedEnvironmentId }; + : { ...options, selectedEnvironmentIds }; const resolvedOptions: ResolvedHomeListOptions = { ...availableOptions, projectGroupingMode: shared?.projectGroupingMode ?? "repository", }; - const setSelectedEnvironmentId = useCallback((value: EnvironmentId | null) => { - setOptions((current) => ({ ...current, selectedEnvironmentId: value })); - }, []); - const setProjectSortOrder = useCallback((value: HomeProjectSortOrder) => { - setOptions((current) => ({ ...current, projectSortOrder: value })); - }, []); - const setThreadSortOrder = useCallback((value: SidebarThreadSortOrder) => { - setOptions((current) => ({ ...current, threadSortOrder: value })); - }, []); + const setSelectedEnvironmentIds = useCallback( + (value: readonly EnvironmentId[]) => { + setOptions((current) => ({ ...current, selectedEnvironmentIds: value })); + }, + [setOptions], + ); + const toggleSelectedEnvironmentId = useCallback( + (environmentId: EnvironmentId) => { + setOptions((current) => ({ + ...current, + selectedEnvironmentIds: toggleEnvironmentId(current.selectedEnvironmentIds, environmentId), + })); + }, + [setOptions], + ); + const clearSelectedEnvironments = useCallback(() => { + setOptions((current) => ({ ...current, selectedEnvironmentIds: [] })); + }, [setOptions]); + const setListMode = useCallback( + (value: HomeListMode) => { + setOptions((current) => ({ ...current, listMode: value })); + }, + [setOptions], + ); + const setOwnershipFilter = useCallback( + (value: OwnershipFilter) => { + setOptions((current) => ({ ...current, ownershipFilter: value })); + }, + [setOptions], + ); + const setOwnershipRelation = useCallback( + (value: OwnershipRelation) => { + setOptions((current) => ({ ...current, ownershipRelation: value })); + }, + [setOptions], + ); + const setThreadGrouping = useCallback( + (value: HomeThreadGrouping) => { + setOptions((current) => ({ ...current, threadGrouping: value })); + }, + [setOptions], + ); + const setProjectSortOrder = useCallback( + (value: HomeProjectSortOrder) => { + setOptions((current) => ({ ...current, projectSortOrder: value })); + }, + [setOptions], + ); + const setThreadSortOrder = useCallback( + (value: SidebarThreadSortOrder) => { + setOptions((current) => ({ ...current, threadSortOrder: value })); + }, + [setOptions], + ); return { options: resolvedOptions, - setSelectedEnvironmentId, + setSelectedEnvironmentIds, + toggleSelectedEnvironmentId, + clearSelectedEnvironments, + setOwnershipFilter, + setOwnershipRelation, + setListMode, + setThreadGrouping, setProjectSortOrder, setThreadSortOrder, } as const; diff --git a/apps/mobile/src/features/home/homeEnvironmentFilter.test.ts b/apps/mobile/src/features/home/homeEnvironmentFilter.test.ts new file mode 100644 index 000000000000..deca7d9fe26e --- /dev/null +++ b/apps/mobile/src/features/home/homeEnvironmentFilter.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + isAllEnvironmentsSelected, + isEnvironmentSelected, + matchesEnvironmentFilter, + resolveSelectedEnvironmentIds, + toggleEnvironmentId, +} from "./homeEnvironmentFilter"; + +const envA = "env-a" as never; +const envB = "env-b" as never; +const envC = "env-c" as never; + +describe("homeEnvironmentFilter", () => { + it("treats empty selection as all environments", () => { + expect(isAllEnvironmentsSelected([])).toBe(true); + expect(matchesEnvironmentFilter(envA, [])).toBe(true); + expect(isEnvironmentSelected([], envA)).toBe(true); + }); + + it("restricts matches to the selected set", () => { + expect(matchesEnvironmentFilter(envA, [envA, envB])).toBe(true); + expect(matchesEnvironmentFilter(envC, [envA, envB])).toBe(false); + expect(isEnvironmentSelected([envA], envA)).toBe(true); + expect(isEnvironmentSelected([envA], envB)).toBe(false); + }); + + it("toggles from all → singleton → multi → all", () => { + expect(toggleEnvironmentId([], envA)).toEqual([envA]); + expect(toggleEnvironmentId([envA], envB)).toEqual([envA, envB]); + expect(toggleEnvironmentId([envA, envB], envA)).toEqual([envB]); + expect(toggleEnvironmentId([envB], envB)).toEqual([]); + }); + + it("drops unavailable environment ids", () => { + const available = new Set([envA, envB]); + expect(resolveSelectedEnvironmentIds([envA, envC], available)).toEqual([envA]); + expect(resolveSelectedEnvironmentIds([], available)).toEqual([]); + }); +}); diff --git a/apps/mobile/src/features/home/homeEnvironmentFilter.ts b/apps/mobile/src/features/home/homeEnvironmentFilter.ts new file mode 100644 index 000000000000..9272e4a3dc7a --- /dev/null +++ b/apps/mobile/src/features/home/homeEnvironmentFilter.ts @@ -0,0 +1,55 @@ +import type { EnvironmentId } from "@t3tools/contracts"; + +/** + * Multi-select environment filter used by Recent, Projects, and Board. + * Empty selection means "all environments". + */ +export function matchesEnvironmentFilter( + environmentId: EnvironmentId, + selectedEnvironmentIds: readonly EnvironmentId[], +): boolean { + return selectedEnvironmentIds.length === 0 || selectedEnvironmentIds.includes(environmentId); +} + +/** True when the filter is unrestricted (show every connected environment). */ +export function isAllEnvironmentsSelected( + selectedEnvironmentIds: readonly EnvironmentId[], +): boolean { + return selectedEnvironmentIds.length === 0; +} + +/** Checkbox state for a single environment row in the filter menu. */ +export function isEnvironmentSelected( + selectedEnvironmentIds: readonly EnvironmentId[], + environmentId: EnvironmentId, +): boolean { + return selectedEnvironmentIds.length === 0 || selectedEnvironmentIds.includes(environmentId); +} + +/** + * Toggle one environment in the multi-select set. + * - From "all" (empty), choosing one env becomes a singleton selection. + * - Deselecting the last env returns to "all". + */ +export function toggleEnvironmentId( + selectedEnvironmentIds: readonly EnvironmentId[], + environmentId: EnvironmentId, +): readonly EnvironmentId[] { + if (selectedEnvironmentIds.length === 0) { + return [environmentId]; + } + if (selectedEnvironmentIds.includes(environmentId)) { + return selectedEnvironmentIds.filter((id) => id !== environmentId); + } + return [...selectedEnvironmentIds, environmentId]; +} + +/** Keep only ids that still exist among available connections. */ +export function resolveSelectedEnvironmentIds( + selectedEnvironmentIds: readonly EnvironmentId[], + availableEnvironmentIds: ReadonlySet, +): readonly EnvironmentId[] { + if (selectedEnvironmentIds.length === 0) return selectedEnvironmentIds; + const next = selectedEnvironmentIds.filter((id) => availableEnvironmentIds.has(id)); + return next.length === selectedEnvironmentIds.length ? selectedEnvironmentIds : next; +} diff --git a/apps/mobile/src/features/home/homeListItems.test.ts b/apps/mobile/src/features/home/homeListItems.test.ts index eb1722c73fde..0e36c4fb34b3 100644 --- a/apps/mobile/src/features/home/homeListItems.test.ts +++ b/apps/mobile/src/features/home/homeListItems.test.ts @@ -7,6 +7,7 @@ import { describe, expect, it } from "vite-plus/test"; import { buildHomeListLayout, + buildHomeRecentListLayout, DEFAULT_GROUP_DISPLAY_STATE, HOME_INITIAL_VISIBLE_THREADS, HOME_SHOW_MORE_STEP, @@ -240,4 +241,83 @@ describe("buildHomeListLayout", () => { expect(layout.stickyHeaderIndices).toEqual([0, 8]); expect(layout.items[8]).toMatchObject({ type: "header", isFirst: false }); }); + + it("builds a flat recent layout with project titles", () => { + const layout = buildHomeRecentListLayout({ + pendingTasks: [], + entries: [ + { thread: makeThread("t1", ProjectId.make("alpha")), projectTitle: "Alpha" }, + { thread: makeThread("t2", ProjectId.make("beta")), projectTitle: "Beta" }, + ], + }); + expect(itemTypes(layout.items)).toEqual(["thread", "thread"]); + expect(layout.items[0]).toMatchObject({ type: "thread", projectTitle: "Alpha" }); + expect(layout.stickyHeaderIndices).toEqual([]); + }); + + it("builds recency sections with Last Hour / Older headers when multiple buckets", () => { + const now = new Date(2026, 2, 15, 14, 30, 0); + const lastHourIso = new Date(now.getTime() - 5 * 60_000).toISOString(); + const olderIso = new Date( + new Date(2026, 2, 15).getTime() - 40 * 24 * 60 * 60 * 1000, + ).toISOString(); + const lastHourThread = { + ...makeThread("t-hour", ProjectId.make("alpha")), + updatedAt: lastHourIso, + latestUserMessageAt: lastHourIso, + }; + const olderThread = { + ...makeThread("t-older", ProjectId.make("beta")), + updatedAt: olderIso, + latestUserMessageAt: olderIso, + }; + const layout = buildHomeRecentListLayout({ + pendingTasks: [], + entries: [ + { thread: lastHourThread, projectTitle: "Alpha" }, + { thread: olderThread, projectTitle: "Beta" }, + ], + groupByRecency: true, + now, + }); + expect(itemTypes(layout.items)).toEqual([ + "section-header", + "thread", + "section-header", + "thread", + ]); + expect(layout.items[0]).toMatchObject({ type: "section-header", title: "Last Hour" }); + expect(layout.items[2]).toMatchObject({ type: "section-header", title: "Older" }); + expect(layout.stickyHeaderIndices).toEqual([0, 2]); + }); + + it("omits recency section headers when all threads share one bucket", () => { + const now = new Date(2026, 2, 15, 14, 30, 0); + const lastHourIso = new Date(now.getTime() - 5 * 60_000).toISOString(); + const layout = buildHomeRecentListLayout({ + pendingTasks: [], + entries: [ + { + thread: { + ...makeThread("t1", ProjectId.make("alpha")), + updatedAt: lastHourIso, + latestUserMessageAt: lastHourIso, + }, + projectTitle: "Alpha", + }, + { + thread: { + ...makeThread("t2", ProjectId.make("beta")), + updatedAt: lastHourIso, + latestUserMessageAt: lastHourIso, + }, + projectTitle: "Beta", + }, + ], + groupByRecency: true, + now, + }); + expect(itemTypes(layout.items)).toEqual(["thread", "thread"]); + expect(layout.stickyHeaderIndices).toEqual([]); + }); }); diff --git a/apps/mobile/src/features/home/homeListItems.ts b/apps/mobile/src/features/home/homeListItems.ts index 910ddb5896b7..deb800b1e322 100644 --- a/apps/mobile/src/features/home/homeListItems.ts +++ b/apps/mobile/src/features/home/homeListItems.ts @@ -1,4 +1,8 @@ import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; +import { + groupSortedThreadsByRecency, + shouldShowRecencySectionHeaders, +} from "@t3tools/client-runtime/state/thread-recency-groups"; import type { PendingNewTask } from "../../state/use-pending-new-tasks"; import type { HomeThreadGroup } from "./homeThreadList"; @@ -27,11 +31,21 @@ export interface HomeHeaderListItem { readonly isFirst: boolean; } +/** Non-collapsible calendar section (Today / Yesterday / …). */ +export interface HomeSectionHeaderListItem { + readonly type: "section-header"; + readonly key: string; + readonly title: string; + readonly isFirst: boolean; +} + export interface HomeThreadListItem { readonly type: "thread"; readonly key: string; readonly thread: EnvironmentThreadShell; readonly isLast: boolean; + /** Optional project title for cross-project contexts (recency / flat). */ + readonly projectTitle?: string; } export interface HomePendingTaskListItem { @@ -53,6 +67,7 @@ export interface HomeShowMoreListItem { export type HomeListItem = | HomeHeaderListItem + | HomeSectionHeaderListItem | HomePendingTaskListItem | HomeThreadListItem | HomeShowMoreListItem; @@ -96,6 +111,12 @@ export function homeListItemsAreEqual(previous: HomeListItem, item: HomeListItem previous.collapsed === item.collapsed && previous.isFirst === item.isFirst ); + case "section-header": + return ( + previous.type === "section-header" && + previous.title === item.title && + previous.isFirst === item.isFirst + ); case "pending-task": return ( previous.type === "pending-task" && @@ -106,7 +127,8 @@ export function homeListItemsAreEqual(previous: HomeListItem, item: HomeListItem return ( previous.type === "thread" && previous.thread === item.thread && - previous.isLast === item.isLast + previous.isLast === item.isLast && + previous.projectTitle === item.projectTitle ); case "show-more": return ( @@ -207,3 +229,106 @@ export function buildHomeListLayout(input: { return { items, stickyHeaderIndices }; } + +/** + * Flat / recency Threads layouts: pending tasks first, then threads by activity. + * Each thread row can carry a project title for multi-project context. + * Callers apply hide-settled / project filters before building entries. + * + * When `groupByRecency` is true and more than one non-empty bucket has threads, + * inserts Last Hour / Earlier Today / Yesterday / … section headers. A single + * bucket renders flat (headers would only repeat the obvious). + */ +export function buildHomeRecentListLayout(input: { + readonly pendingTasks: ReadonlyArray; + readonly entries: ReadonlyArray<{ + readonly thread: EnvironmentThreadShell; + readonly projectTitle: string; + }>; + readonly groupByRecency?: boolean; + readonly now?: Date; +}): HomeListLayout { + const items: HomeListItem[] = []; + const stickyHeaderIndices: number[] = []; + + const appendFlatThreads = () => { + const total = input.pendingTasks.length + input.entries.length; + for (const [index, entry] of input.entries.entries()) { + const absoluteIndex = input.pendingTasks.length + index; + items.push({ + type: "thread", + key: `thread:${entry.thread.environmentId}:${entry.thread.id}`, + thread: entry.thread, + projectTitle: entry.projectTitle, + isLast: absoluteIndex === total - 1, + }); + } + }; + + for (const [index, pendingTask] of input.pendingTasks.entries()) { + items.push({ + type: "pending-task", + key: pendingTask.key, + pendingTask, + isLast: + index === input.pendingTasks.length - 1 && + input.entries.length === 0 && + input.groupByRecency !== true, + }); + } + + if (input.groupByRecency !== true) { + appendFlatThreads(); + return { items, stickyHeaderIndices: [] }; + } + + const projectTitleByThreadKey = new Map( + input.entries.map((entry) => [ + `${entry.thread.environmentId}:${entry.thread.id}`, + entry.projectTitle, + ]), + ); + const recencyGroups = groupSortedThreadsByRecency( + input.entries.map((entry) => entry.thread), + input.now, + ); + + // One non-empty bucket (or none): no section headers. + if (!shouldShowRecencySectionHeaders(recencyGroups)) { + // Pending isLast was computed assuming multi-bucket; fix for flat path. + if (input.pendingTasks.length > 0) { + const lastPendingIndex = input.pendingTasks.length - 1; + const lastPending = items[lastPendingIndex]; + if (lastPending?.type === "pending-task") { + items[lastPendingIndex] = { + ...lastPending, + isLast: input.entries.length === 0, + }; + } + } + appendFlatThreads(); + return { items, stickyHeaderIndices: [] }; + } + + for (const [groupIndex, group] of recencyGroups.entries()) { + stickyHeaderIndices.push(items.length); + items.push({ + type: "section-header", + key: `section:${group.id}`, + title: group.label, + isFirst: groupIndex === 0 && input.pendingTasks.length === 0, + }); + + for (const [threadIndex, thread] of group.threads.entries()) { + items.push({ + type: "thread", + key: `thread:${thread.environmentId}:${thread.id}`, + thread, + projectTitle: projectTitleByThreadKey.get(`${thread.environmentId}:${thread.id}`), + isLast: groupIndex === recencyGroups.length - 1 && threadIndex === group.threads.length - 1, + }); + } + } + + return { items, stickyHeaderIndices }; +} diff --git a/apps/mobile/src/features/home/homeListMode.test.ts b/apps/mobile/src/features/home/homeListMode.test.ts new file mode 100644 index 000000000000..bd4744e5d151 --- /dev/null +++ b/apps/mobile/src/features/home/homeListMode.test.ts @@ -0,0 +1,25 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + DEFAULT_HOME_THREAD_GROUPING, + isHomeThreadGrouping, + resolveHomeThreadGrouping, +} from "./homeListMode"; + +describe("home thread grouping", () => { + it("validates recency / project / none", () => { + expect(isHomeThreadGrouping("recency")).toBe(true); + expect(isHomeThreadGrouping("project")).toBe(true); + expect(isHomeThreadGrouping("none")).toBe(true); + expect(isHomeThreadGrouping("recent")).toBe(false); + expect(isHomeThreadGrouping(undefined)).toBe(false); + }); + + it("resolves stored values and defaults when unset", () => { + expect(resolveHomeThreadGrouping(undefined)).toBe(DEFAULT_HOME_THREAD_GROUPING); + expect(resolveHomeThreadGrouping("bogus")).toBe("project"); + expect(resolveHomeThreadGrouping("recency")).toBe("recency"); + expect(resolveHomeThreadGrouping("none")).toBe("none"); + expect(resolveHomeThreadGrouping("project")).toBe("project"); + }); +}); diff --git a/apps/mobile/src/features/home/homeListMode.ts b/apps/mobile/src/features/home/homeListMode.ts new file mode 100644 index 000000000000..ce3b84a6c0e1 --- /dev/null +++ b/apps/mobile/src/features/home/homeListMode.ts @@ -0,0 +1,77 @@ +/** + * Home list presentation modes. Shared by compact home and split sidebar. + * Environment multi-filter applies to every mode. + * + * Threads replaces the former Recent + Projects modes with a single list + * controlled by {@link HomeThreadGrouping}. + */ +export type HomeListMode = "threads" | "board"; + +export const HOME_LIST_MODES = ["threads", "board"] as const satisfies readonly HomeListMode[]; + +export const HOME_LIST_MODE_LABELS: Record = { + threads: "Threads", + board: "Board", +}; + +/** SF Symbol names for header mode buttons (AppSymbol / native bar items). */ +export const HOME_LIST_MODE_ICONS: Record = { + threads: "list.bullet", + board: "square.split.2x1", +}; + +export const HOME_LIST_MODE_TITLES: Record = { + threads: "Threads", + board: "Board", +}; + +export function isHomeListMode(value: unknown): value is HomeListMode { + return value === "threads" || value === "board"; +} + +/** Modes the user can switch to from the current one. */ +export function otherHomeListModes(mode: HomeListMode): readonly HomeListMode[] { + return HOME_LIST_MODES.filter((candidate) => candidate !== mode); +} + +export const DEFAULT_HOME_LIST_MODE: HomeListMode = "threads"; + +/** + * Historical persisted enum. `project` means literal project groups only in + * classic/V1 lists; Thread List V2 exposes it as Default/upstream order. + * See docs/sidebar-v2.md before changing or interpreting these values. + */ +export type HomeThreadGrouping = "recency" | "project" | "none"; + +export const HOME_THREAD_GROUPINGS = [ + "recency", + "project", + "none", +] as const satisfies readonly HomeThreadGrouping[]; + +export const HOME_THREAD_GROUPING_LABELS: Record = { + recency: "Group by recency", + // Persisted as `project` for compatibility: classic lists keep project + // groups, while Thread List V2 uses the upstream default ordering. + project: "Group by default", + none: "Group by nothing", +}; + +export function isHomeThreadGrouping(value: unknown): value is HomeThreadGrouping { + return value === "recency" || value === "project" || value === "none"; +} + +export const DEFAULT_HOME_THREAD_GROUPING: HomeThreadGrouping = "project"; + +/** Stored / preference value → valid grouping (default project when unset). */ +export function resolveHomeThreadGrouping(value: unknown): HomeThreadGrouping { + return isHomeThreadGrouping(value) ? value : DEFAULT_HOME_THREAD_GROUPING; +} + +export function usesProjectThreadGrouping(grouping: HomeThreadGrouping): boolean { + return grouping === "project"; +} + +export function usesFlatThreadGrouping(grouping: HomeThreadGrouping): boolean { + return grouping === "recency" || grouping === "none"; +} diff --git a/apps/mobile/src/features/home/homeRecentList.test.ts b/apps/mobile/src/features/home/homeRecentList.test.ts new file mode 100644 index 000000000000..722d1d1f38eb --- /dev/null +++ b/apps/mobile/src/features/home/homeRecentList.test.ts @@ -0,0 +1,80 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { buildHomeRecentListEntries } from "./homeRecentList"; + +function makeProject(id: string, environmentId = "env-1") { + return { + environmentId: environmentId as never, + id: id as never, + title: id, + workspaceRoot: `/${id}`, + repositoryIdentity: null, + defaultModelSelection: null, + scripts: [], + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + }; +} + +function makeThread( + id: string, + projectId: string, + options: { environmentId?: string; updatedAt?: string; archivedAt?: string | null } = {}, +) { + return { + environmentId: (options.environmentId ?? "env-1") as never, + id: id as never, + projectId: projectId as never, + title: id, + status: "idle" as const, + archivedAt: options.archivedAt ?? null, + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: options.updatedAt ?? "2026-01-02T00:00:00.000Z", + latestUserMessageAt: options.updatedAt ?? "2026-01-02T00:00:00.000Z", + branch: null, + worktreePath: null, + }; +} + +describe("buildHomeRecentListEntries", () => { + const projects = [makeProject("p1", "env-1"), makeProject("p2", "env-2")]; + const threads = [ + makeThread("t1", "p1", { environmentId: "env-1", updatedAt: "2026-01-03T00:00:00.000Z" }), + makeThread("t2", "p2", { environmentId: "env-2", updatedAt: "2026-01-04T00:00:00.000Z" }), + makeThread("t3", "p1", { + environmentId: "env-1", + updatedAt: "2026-01-05T00:00:00.000Z", + archivedAt: "2026-01-05T01:00:00.000Z", + }), + ]; + + it("returns all unarchived threads sorted by recency when no env filter", () => { + const entries = buildHomeRecentListEntries({ + projects, + threads: threads as never, + selectedEnvironmentIds: [], + searchQuery: "", + }); + expect(entries.map((entry) => entry.thread.id)).toEqual(["t2", "t1"]); + }); + + it("filters by multi-select environment ids", () => { + const entries = buildHomeRecentListEntries({ + projects, + threads: threads as never, + selectedEnvironmentIds: ["env-1" as never], + searchQuery: "", + }); + expect(entries.map((entry) => entry.thread.id)).toEqual(["t1"]); + }); + + it("supports selecting multiple environments", () => { + const entries = buildHomeRecentListEntries({ + projects, + threads: threads as never, + selectedEnvironmentIds: ["env-1" as never, "env-2" as never], + searchQuery: "", + }); + expect(entries.map((entry) => entry.thread.id)).toEqual(["t2", "t1"]); + }); +}); diff --git a/apps/mobile/src/features/home/homeRecentList.ts b/apps/mobile/src/features/home/homeRecentList.ts new file mode 100644 index 000000000000..b6ce11991e3c --- /dev/null +++ b/apps/mobile/src/features/home/homeRecentList.ts @@ -0,0 +1,91 @@ +import type { + EnvironmentProject, + EnvironmentThreadShell, +} from "@t3tools/client-runtime/state/shell"; +import { sortThreads } from "@t3tools/client-runtime/state/thread-sort"; +import type { EnvironmentId } from "@t3tools/contracts"; + +import { scopedProjectKey } from "../../lib/scopedEntities"; +import type { PendingNewTask } from "../../state/use-pending-new-tasks"; +import { matchesEnvironmentFilter } from "./homeEnvironmentFilter"; + +export interface HomeRecentListEntry { + readonly thread: EnvironmentThreadShell; + readonly project: EnvironmentProject; +} + +export interface HomeRecentPendingEntry { + readonly pendingTask: PendingNewTask; + readonly projectTitle: string; +} + +/** + * Flat recency list for the Recent home mode: unarchived threads across + * projects, sorted by latest user activity, with env multi-filter applied. + */ +export function buildHomeRecentListEntries(input: { + readonly projects: ReadonlyArray; + readonly threads: ReadonlyArray; + readonly selectedEnvironmentIds: readonly EnvironmentId[]; + readonly projectRefKeys?: ReadonlySet | null; + readonly searchQuery: string; +}): ReadonlyArray { + const projectByKey = new Map(); + for (const project of input.projects) { + if (!matchesEnvironmentFilter(project.environmentId, input.selectedEnvironmentIds)) { + continue; + } + projectByKey.set(scopedProjectKey(project.environmentId, project.id), project); + } + + const query = input.searchQuery.trim().toLocaleLowerCase(); + const candidates: EnvironmentThreadShell[] = []; + for (const thread of input.threads) { + if (thread.archivedAt !== null) continue; + if (!matchesEnvironmentFilter(thread.environmentId, input.selectedEnvironmentIds)) { + continue; + } + const projectKey = scopedProjectKey(thread.environmentId, thread.projectId); + if (input.projectRefKeys != null && !input.projectRefKeys.has(projectKey)) { + continue; + } + if (!projectByKey.has(projectKey)) continue; + if (query.length > 0 && !thread.title.toLocaleLowerCase().includes(query)) { + continue; + } + candidates.push(thread); + } + + return sortThreads(candidates, "updated_at").flatMap((thread) => { + const project = projectByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)); + return project ? [{ thread, project }] : []; + }); +} + +export function buildHomeRecentPendingEntries(input: { + readonly pendingTasks: ReadonlyArray; + readonly selectedEnvironmentIds: readonly EnvironmentId[]; + readonly projectRefKeys?: ReadonlySet | null; + readonly searchQuery: string; +}): ReadonlyArray { + const query = input.searchQuery.trim().toLocaleLowerCase(); + const entries: HomeRecentPendingEntry[] = []; + for (const pendingTask of input.pendingTasks) { + if (!matchesEnvironmentFilter(pendingTask.environmentId, input.selectedEnvironmentIds)) { + continue; + } + const projectKey = scopedProjectKey(pendingTask.environmentId, pendingTask.projectId); + if (input.projectRefKeys != null && !input.projectRefKeys.has(projectKey)) { + continue; + } + const title = pendingTask.projectTitle ?? "Unknown project"; + if (query.length > 0 && !title.toLocaleLowerCase().includes(query)) { + continue; + } + entries.push({ pendingTask, projectTitle: title }); + } + return entries.sort( + (left, right) => + Date.parse(right.pendingTask.createdAt) - Date.parse(left.pendingTask.createdAt), + ); +} diff --git a/apps/mobile/src/features/home/homeThreadList.ts b/apps/mobile/src/features/home/homeThreadList.ts index 895c73bbe266..8fd28f89e020 100644 --- a/apps/mobile/src/features/home/homeThreadList.ts +++ b/apps/mobile/src/features/home/homeThreadList.ts @@ -27,6 +27,7 @@ import * as Order from "effect/Order"; import { scopedProjectKey, scopedThreadKey } from "../../lib/scopedEntities"; import type { PendingNewTask } from "../../state/use-pending-new-tasks"; +import { matchesEnvironmentFilter } from "./homeEnvironmentFilter"; export type HomeProjectSortOrder = Exclude; @@ -51,11 +52,17 @@ function getProjectSortTimestamp( export function buildHomeProjectScopes(input: { readonly projects: ReadonlyArray; - readonly environmentId: EnvironmentId | null; + /** Empty = all environments. Prefer this over the legacy single-id field. */ + readonly selectedEnvironmentIds?: readonly EnvironmentId[]; + /** @deprecated Use selectedEnvironmentIds. Kept for call-site migration. */ + readonly environmentId?: EnvironmentId | null; readonly projectGroupingMode: SidebarProjectGroupingMode; }): ReadonlyArray { - const projects = input.projects.filter( - (project) => input.environmentId === null || project.environmentId === input.environmentId, + const selectedEnvironmentIds = + input.selectedEnvironmentIds ?? + (input.environmentId != null && input.environmentId !== undefined ? [input.environmentId] : []); + const projects = input.projects.filter((project) => + matchesEnvironmentFilter(project.environmentId, selectedEnvironmentIds), ); return buildProjectGroups({ projects, @@ -208,9 +215,11 @@ export function buildHomeThreadGroups(input: { readonly projects: ReadonlyArray; readonly threads: ReadonlyArray; readonly pendingTasks?: ReadonlyArray; + readonly selectedEnvironmentIds?: readonly EnvironmentId[]; + /** @deprecated Use selectedEnvironmentIds. */ + readonly environmentId?: EnvironmentId | null; /** Thread keys with a message waiting in the outbox; kept in the default view. */ readonly queuedThreadKeys?: ReadonlySet; - readonly environmentId: EnvironmentId | null; readonly searchQuery: string; readonly matchedThreadKeys?: ReadonlySet; readonly projectSortOrder: HomeProjectSortOrder; @@ -220,6 +229,9 @@ export function buildHomeThreadGroups(input: { readonly now?: number; }): ReadonlyArray { const now = input.now ?? Date.now(); + const selectedEnvironmentIds = + input.selectedEnvironmentIds ?? + (input.environmentId != null && input.environmentId !== undefined ? [input.environmentId] : []); const groups = new Map(); const groupTitleByKey = new Map(); const groupKeyByProjectKey = new Map(); @@ -241,7 +253,7 @@ export function buildHomeThreadGroups(input: { } for (const pendingTask of input.pendingTasks ?? []) { - if (input.environmentId !== null && pendingTask.environmentId !== input.environmentId) { + if (!matchesEnvironmentFilter(pendingTask.environmentId, selectedEnvironmentIds)) { continue; } @@ -279,7 +291,7 @@ export function buildHomeThreadGroups(input: { if (thread.archivedAt !== null) { continue; } - if (input.environmentId !== null && thread.environmentId !== input.environmentId) { + if (!matchesEnvironmentFilter(thread.environmentId, selectedEnvironmentIds)) { continue; } diff --git a/apps/mobile/src/features/home/threadActionMessages.ts b/apps/mobile/src/features/home/threadActionMessages.ts new file mode 100644 index 000000000000..680fc376c16a --- /dev/null +++ b/apps/mobile/src/features/home/threadActionMessages.ts @@ -0,0 +1,30 @@ +import * as Cause from "effect/Cause"; + +export type ThreadListAction = "archive" | "unarchive" | "delete" | "settle" | "unsettle"; + +const ACTION_VERBS: Record = { + archive: "archived", + unarchive: "unarchived", + delete: "deleted", + settle: "settled", + unsettle: "un-settled", +}; + +export function actionFailureMessage( + action: ThreadListAction, + cause: Cause.Cause, +): string { + const error = Cause.squash(cause); + if (error instanceof Error && error.message.trim().length > 0) { + return error.message; + } + return `The thread could not be ${ACTION_VERBS[action]}.`; +} + +export function actionFailureTitle(action: ThreadListAction): string { + if (action === "archive") return "Could not archive thread"; + if (action === "unarchive") return "Could not unarchive thread"; + if (action === "settle") return "Could not settle thread"; + if (action === "unsettle") return "Could not un-settle thread"; + return "Could not delete thread"; +} diff --git a/apps/mobile/src/features/home/useThreadListActions.ts b/apps/mobile/src/features/home/useThreadListActions.ts index 72e45c9bbb4e..481b29c4a08a 100644 --- a/apps/mobile/src/features/home/useThreadListActions.ts +++ b/apps/mobile/src/features/home/useThreadListActions.ts @@ -1,6 +1,7 @@ import type { ThreadMoveDestination } from "../threads/threadOrder"; import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; import { canSnooze, effectiveSnoozed } from "@t3tools/client-runtime/state/thread-settled"; +import { runArchiveWithWorktreeCleanup } from "@t3tools/client-runtime/state/worktreeCleanup"; import * as Cause from "effect/Cause"; import * as Haptics from "expo-haptics"; import { useCallback, useRef } from "react"; @@ -21,12 +22,19 @@ import { getPendingThreadOrder, threadDropBusyAtom, } from "../../state/thread-order"; +import { vcsEnvironment } from "../../state/vcs"; import { createPendingThreadOrder, createThreadMovePlanner, threadDropLifecycle, } from "../threads/threadOrder"; import { getThreadListV2OrderedSection } from "../threads/threadListV2"; +import { + actionFailureMessage, + actionFailureTitle, + type ThreadListAction, +} from "./threadActionMessages"; +import { presentWorktreeCleanupConfirmation } from "./worktreeCleanupPrompt"; /** Version skew: never send settle/unsettle to a server that predates them (capability defaults false on decode for older servers). */ @@ -67,36 +75,10 @@ function environmentSupportsTitleRegeneration( ); } -type ThreadListAction = "archive" | "unarchive" | "delete" | "settle" | "unsettle"; - -const ACTION_VERBS: Record = { - archive: "archived", - unarchive: "unarchived", - delete: "deleted", - settle: "settled", - unsettle: "un-settled", -}; - -function actionFailureMessage(action: ThreadListAction, cause: Cause.Cause): string { - const error = Cause.squash(cause); - if (error instanceof Error && error.message.trim().length > 0) { - return error.message; - } - return `The thread could not be ${ACTION_VERBS[action]}.`; -} - function selectionHaptic(): void { void Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light); } -function actionFailureTitle(action: ThreadListAction): string { - if (action === "archive") return "Could not archive thread"; - if (action === "unarchive") return "Could not unarchive thread"; - if (action === "settle") return "Could not settle thread"; - if (action === "unsettle") return "Could not un-settle thread"; - return "Could not delete thread"; -} - /** Resolves to true iff the action was dispatched and succeeded. */ function useThreadActionExecutor( onCompleted?: (action: ThreadListAction, thread: EnvironmentThreadShell) => void, @@ -251,13 +233,90 @@ export function useThreadListActions(): { reportFailure: false, }); const snoozeInFlightThreadKeys = useRef(new Set()); + const previewWorktreeCleanup = useAtomCommand(vcsEnvironment.previewWorktreeCleanup, { + reportFailure: false, + }); + const cleanupThreadWorktree = useAtomCommand(vcsEnvironment.cleanupThreadWorktree, { + reportFailure: false, + }); const titleRegenerationInFlightThreadKeys = useRef(new Set()); const archiveThread = useCallback( (thread: EnvironmentThreadShell) => { - void executeAction("archive", thread); + void runArchiveWithWorktreeCleanup({ + // Server-authoritative preview; a failure (old server, transient + // error) degrades to a plain archive without a prompt. A thread + // mid-turn keeps the original archive guard: executeAction re-checks + // and surfaces the alert, so it must not be prompted for cleanup. + previewCandidate: async () => { + if (thread.session?.status === "running" && thread.session.activeTurnId != null) { + return null; + } + const preview = await previewWorktreeCleanup({ + environmentId: thread.environmentId, + input: { threadId: thread.id }, + }); + return preview._tag === "Success" ? preview.value.candidate : null; + }, + removalPolicy: "confirm", + confirmRemoval: ({ displayWorktreePath }) => + presentWorktreeCleanupConfirmation({ + isIos: process.env.EXPO_OS === "ios", + displayWorktreePath, + presentAlert: (buttons) => { + Alert.alert(buttons.title, buttons.message, [ + { text: "Keep", style: "cancel", onPress: buttons.onKeep }, + { text: "Remove", style: "destructive", onPress: buttons.onRemove }, + ]); + }, + presentConfirmDialog: (buttons) => { + showConfirmDialog({ + title: buttons.title, + message: buttons.message, + cancelText: "Keep", + confirmText: "Remove", + destructive: true, + onConfirm: buttons.onRemove, + onCancel: buttons.onKeep, + }); + }, + }), + archive: () => executeAction("archive", thread), + isArchiveSuccess: (archived) => archived, + cleanup: async () => { + const result = await cleanupThreadWorktree({ + environmentId: thread.environmentId, + input: { threadId: thread.id }, + }); + if (result._tag === "Failure") { + const error = Cause.squash(result.cause); + return { + kind: "failed", + message: + error instanceof Error && error.message.trim().length > 0 + ? error.message + : "The worktree could not be removed.", + } as const; + } + return { kind: "done", status: result.value.status } as const; + }, + // Cleanup problems are nonfatal: the archive itself already + // succeeded. + onCleanupFailed: (displayWorktreePath, message) => { + Alert.alert( + "Thread archived, but worktree removal failed", + `Could not remove ${displayWorktreePath}. ${message}`, + ); + }, + onCleanupRetained: (displayWorktreePath) => { + Alert.alert( + "Worktree kept", + `${displayWorktreePath} is still used by another active thread.`, + ); + }, + }); }, - [executeAction], + [cleanupThreadWorktree, executeAction, previewWorktreeCleanup], ); const settleThread = useCallback( async (thread: EnvironmentThreadShell) => (await executeAction("settle", thread)) === true, diff --git a/apps/mobile/src/features/home/worktreeCleanupPrompt.test.ts b/apps/mobile/src/features/home/worktreeCleanupPrompt.test.ts new file mode 100644 index 000000000000..502dd92b8f9d --- /dev/null +++ b/apps/mobile/src/features/home/worktreeCleanupPrompt.test.ts @@ -0,0 +1,102 @@ +import { WorktreeLifecycleError } from "@t3tools/contracts"; +import { ThreadId } from "@t3tools/contracts"; +import * as Cause from "effect/Cause"; +import { describe, expect, it, vi } from "vite-plus/test"; + +import { actionFailureMessage, actionFailureTitle } from "./threadActionMessages"; +import { + buildWorktreeCleanupPrompt, + presentWorktreeCleanupConfirmation, +} from "./worktreeCleanupPrompt"; + +describe("presentWorktreeCleanupConfirmation", () => { + it("uses the native alert on iOS and never the confirm dialog", async () => { + const presentAlert = vi.fn( + (buttons: { readonly onKeep: () => void; readonly onRemove: () => void }) => { + buttons.onRemove(); + }, + ); + const presentConfirmDialog = vi.fn(); + + const confirmation = await presentWorktreeCleanupConfirmation({ + isIos: true, + displayWorktreePath: "feature-1", + presentAlert, + presentConfirmDialog, + }); + + expect(confirmation).toEqual({ kind: "confirmed" }); + expect(presentAlert).toHaveBeenCalledTimes(1); + expect(presentConfirmDialog).not.toHaveBeenCalled(); + }); + + it("uses the confirm dialog host elsewhere", async () => { + const presentAlert = vi.fn(); + const presentConfirmDialog = vi.fn( + (buttons: { readonly onKeep: () => void; readonly onRemove: () => void }) => { + buttons.onKeep(); + }, + ); + + const confirmation = await presentWorktreeCleanupConfirmation({ + isIos: false, + displayWorktreePath: "feature-1", + presentAlert, + presentConfirmDialog, + }); + + expect(confirmation).toEqual({ kind: "declined" }); + expect(presentAlert).not.toHaveBeenCalled(); + expect(presentConfirmDialog).toHaveBeenCalledTimes(1); + }); + + it("resolves declined for Keep and confirmed for Remove", async () => { + const keep = presentWorktreeCleanupConfirmation({ + isIos: true, + displayWorktreePath: "feature-1", + presentAlert: (buttons) => { + buttons.onKeep(); + }, + presentConfirmDialog: () => {}, + }); + await expect(keep).resolves.toEqual({ kind: "declined" }); + + const remove = presentWorktreeCleanupConfirmation({ + isIos: false, + displayWorktreePath: "feature-1", + presentAlert: () => {}, + presentConfirmDialog: (buttons) => { + buttons.onRemove(); + }, + }); + await expect(remove).resolves.toEqual({ kind: "confirmed" }); + }); + + it("names the worktree in the prompt copy", () => { + const prompt = buildWorktreeCleanupPrompt("feature-1"); + expect(prompt.title).toBe("Remove worktree?"); + expect(prompt.message).toContain("feature-1"); + expect(prompt.message).toContain("branch is kept"); + }); +}); + +describe("thread action failure messages", () => { + it("surfaces unarchive restoration errors with the server-provided detail", () => { + const restorationError = new WorktreeLifecycleError({ + operation: "restore", + threadId: ThreadId.make("thread-1"), + detail: + "Failed to recreate the worktree at /wt/feature-1 from branch 'feature-1': branch missing. The thread stays archived.", + }); + expect(actionFailureTitle("unarchive")).toBe("Could not unarchive thread"); + expect(actionFailureMessage("unarchive", Cause.fail(restorationError))).toContain( + "Failed to recreate the worktree", + ); + }); + + it("falls back to a generic message when the cause has no message", () => { + expect(actionFailureMessage("unarchive", Cause.fail(new Error("")))).toBe( + "The thread could not be unarchived.", + ); + }); +}); diff --git a/apps/mobile/src/features/home/worktreeCleanupPrompt.ts b/apps/mobile/src/features/home/worktreeCleanupPrompt.ts new file mode 100644 index 000000000000..3c331e619ffb --- /dev/null +++ b/apps/mobile/src/features/home/worktreeCleanupPrompt.ts @@ -0,0 +1,49 @@ +import type { WorktreeCleanupConfirmation } from "@t3tools/client-runtime/state/worktreeCleanup"; + +export interface WorktreeCleanupPromptButtons { + readonly title: string; + readonly message: string; + readonly onKeep: () => void; + readonly onRemove: () => void; +} + +export function buildWorktreeCleanupPrompt(displayWorktreePath: string): { + readonly title: string; + readonly message: string; +} { + return { + title: "Remove worktree?", + message: `This thread is the last active one linked to the worktree “${displayWorktreePath}”. Remove it when archiving? The branch is kept.`, + }; +} + +/** + * Presents the archive-time cleanup confirmation through the platform's + * surface: the native alert on iOS, the in-app confirm dialog elsewhere. + * Keep archives without cleanup; Remove archives and cleans up. + */ +export function presentWorktreeCleanupConfirmation(input: { + readonly isIos: boolean; + readonly displayWorktreePath: string; + readonly presentAlert: (buttons: WorktreeCleanupPromptButtons) => void; + readonly presentConfirmDialog: (buttons: WorktreeCleanupPromptButtons) => void; +}): Promise> { + const { title, message } = buildWorktreeCleanupPrompt(input.displayWorktreePath); + return new Promise((resolve) => { + const buttons: WorktreeCleanupPromptButtons = { + title, + message, + onKeep: () => { + resolve({ kind: "declined" }); + }, + onRemove: () => { + resolve({ kind: "confirmed" }); + }, + }; + if (input.isIos) { + input.presentAlert(buttons); + return; + } + input.presentConfirmDialog(buttons); + }); +} diff --git a/apps/mobile/src/features/identity/IdentityAvatar.tsx b/apps/mobile/src/features/identity/IdentityAvatar.tsx new file mode 100644 index 000000000000..d640c03a80fe --- /dev/null +++ b/apps/mobile/src/features/identity/IdentityAvatar.tsx @@ -0,0 +1,46 @@ +import { identityAvatar } from "@t3tools/shared/identityAvatar"; +import { View } from "react-native"; + +import { AppText as Text } from "../../components/AppText"; +import { cn } from "../../lib/cn"; + +/** + * Generated initials chip for identity map people (same palette as web). + */ +export function IdentityAvatar(props: { + readonly personId?: string | null | undefined; + readonly username?: string | null | undefined; + readonly name?: string | null | undefined; + readonly size?: "micro" | "sm" | "md"; + readonly className?: string; + readonly highlighted?: boolean; +}) { + const model = identityAvatar({ + personId: props.personId, + username: props.username, + name: props.name, + }); + const size = props.size ?? "micro"; + const box = size === "md" ? "size-7" : size === "sm" ? "size-6" : "size-3.5"; + const text = size === "md" ? "text-[11px]" : size === "sm" ? "text-[10px]" : "text-[8px]"; + + return ( + + + {model.initials} + + + ); +} diff --git a/apps/mobile/src/features/identity/IdentityClaimGate.test.ts b/apps/mobile/src/features/identity/IdentityClaimGate.test.ts new file mode 100644 index 000000000000..00e91298c951 --- /dev/null +++ b/apps/mobile/src/features/identity/IdentityClaimGate.test.ts @@ -0,0 +1,13 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { resolveIdentityClaimCandidate } from "./identityClaimCandidate"; + +describe("resolveIdentityClaimCandidate", () => { + const candidates = [{ environmentId: "first" }, { environmentId: "second" }]; + + it("advances through candidates without wrapping after the final candidate", () => { + expect(resolveIdentityClaimCandidate(candidates, 0)).toBe(candidates[0]); + expect(resolveIdentityClaimCandidate(candidates, 1)).toBe(candidates[1]); + expect(resolveIdentityClaimCandidate(candidates, 2)).toBeUndefined(); + }); +}); diff --git a/apps/mobile/src/features/identity/IdentityClaimGate.tsx b/apps/mobile/src/features/identity/IdentityClaimGate.tsx new file mode 100644 index 000000000000..7b8611208902 --- /dev/null +++ b/apps/mobile/src/features/identity/IdentityClaimGate.tsx @@ -0,0 +1,234 @@ +import { + filterPeopleForTypeahead, + identityClaimRequired, +} from "@t3tools/client-runtime/state/identity"; +import { IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS, IdentityUsername } from "@t3tools/contracts"; +import { useCallback, useEffect, useMemo, useRef, useState } from "react"; +import { ActivityIndicator, Modal, Pressable, TextInput, View } from "react-native"; + +import { AppText as Text } from "../../components/AppText"; +import { useEnvironments, type EnvironmentPresentation } from "../../state/environments"; +import { identityEnvironment } from "../../state/identity"; +import { useEnvironmentQuery } from "../../state/query"; +import { useAtomCommand } from "../../state/use-atom-command"; +import { resolveIdentityClaimCandidate } from "./identityClaimCandidate"; + +/** + * Claim gate for multi-env mobile (e.g. local + t3vm). + * + * - Only **connected** environments are probed (never while reconnecting — + * identity RPCs on a flapping link heat the device and leave a Modal that + * steals all touches). + * - Secondary remotes are ordered before primary so t3vm (map on) wins over + * smart/desktop primary (map off). + * - At most one Modal is shown. + */ +export function IdentityClaimGate() { + const { environments } = useEnvironments(); + const candidates = useMemo(() => { + const connected = environments.filter( + (environment) => environment.connection.phase === "connected", + ); + const secondary = connected.filter( + (environment) => environment.entry.target._tag !== "PrimaryConnectionTarget", + ); + const primary = connected.filter( + (environment) => environment.entry.target._tag === "PrimaryConnectionTarget", + ); + return [...secondary, ...primary]; + }, [environments]); + + const [activeIndex, setActiveIndex] = useState(0); + const candidateKey = candidates.map((environment) => environment.environmentId).join("\0"); + + // A changed connection set starts a fresh probe. Reaching the end of an unchanged + // set stays exhausted instead of wrapping to zero and probing forever. + useEffect(() => { + setActiveIndex(0); + }, [candidateKey]); + + const onSkip = useCallback(() => { + setActiveIndex((index) => index + 1); + }, []); + + const environment = resolveIdentityClaimCandidate(candidates, activeIndex); + if (environment === undefined) { + return null; + } + + // Probe candidates in order: each reports whether it needs a claim; we advance + // past envs that do not (map off / already claimed) without showing a Modal. + return ( + + ); +} + +function IdentityClaimGateBody(props: { + readonly environment: EnvironmentPresentation; + readonly onSkip: () => void; +}) { + const environmentId = props.environment.environmentId; + const target = useMemo(() => ({ environmentId, input: {} as const }), [environmentId]); + const snapshotQuery = useEnvironmentQuery(identityEnvironment.snapshot(target)); + const claimQuery = useEnvironmentQuery(identityEnvironment.sessionClaim(target)); + const claimCommand = useAtomCommand(identityEnvironment.claim, { + label: "identity-claim", + reportFailure: true, + }); + const [query, setQuery] = useState(""); + const [error, setError] = useState(null); + const [submitting, setSubmitting] = useState(false); + const didSkipRef = useRef(false); + + const needsClaim = identityClaimRequired(snapshotQuery.data, claimQuery.data); + + // Finished loading and this env does not need a claim → try next. + useEffect(() => { + if (snapshotQuery.isPending || claimQuery.isPending) { + return; + } + // Snapshot failed or map disabled / already claimed. + if ( + snapshotQuery.error !== null || + snapshotQuery.data === null || + !snapshotQuery.data.enabled || + !needsClaim + ) { + if (didSkipRef.current) { + return; + } + didSkipRef.current = true; + props.onSkip(); + } + }, [ + claimQuery.isPending, + needsClaim, + props.onSkip, + snapshotQuery.data, + snapshotQuery.error, + snapshotQuery.isPending, + ]); + + const suggestions = useMemo(() => { + if (!snapshotQuery.data) return []; + return filterPeopleForTypeahead( + snapshotQuery.data.people, + query, + IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS, + ); + }, [query, snapshotQuery.data]); + + // No modal while loading, erroring, or not required — avoids a blank + // touch-stealing overlay on reconnect. + if (snapshotQuery.isPending || claimQuery.isPending) { + return null; + } + if (!needsClaim || !snapshotQuery.data?.enabled) { + return null; + } + + const submit = async (username: string) => { + const normalized = username.trim().toLowerCase(); + const exact = snapshotQuery.data?.people.find((person) => person.username === normalized); + if (!exact) { + setError("Pick a username from the server map."); + return; + } + setSubmitting(true); + setError(null); + try { + await claimCommand({ + environmentId, + input: { + username: IdentityUsername.make(exact.username), + method: "typeahead", + }, + }); + claimQuery.refresh(); + } catch (cause) { + setError(cause instanceof Error ? cause.message : "Claim failed"); + } finally { + setSubmitting(false); + } + }; + + const envLabel = props.environment.label.trim() || "this environment"; + + return ( + { + // Required claim — keep the modal. + }} + > + + + + Shared environment · {envLabel} + + Who are you? + + {envLabel} uses a closed identity map. Type at least{" "} + {IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS} characters, then choose a map match. + + { + setQuery(value); + setError(null); + }} + onSubmitEditing={() => void submit(query)} + className="mt-4 rounded-lg border border-border bg-background px-3 py-2.5 text-base text-foreground" + testID="identity-claim-input" + /> + {suggestions.length > 0 ? ( + + {suggestions.map((person) => ( + { + setQuery(person.username); + void submit(person.username); + }} + className="border-b border-border px-3 py-2.5 active:bg-subtle" + > + {person.username} + {person.name ? ( + {person.name} + ) : null} + + ))} + + ) : null} + {error ? {error} : null} + void submit(query)} + className="mt-4 items-center rounded-lg bg-primary px-4 py-2.5" + > + {submitting ? ( + + ) : ( + Save identity + )} + + + + + ); +} diff --git a/apps/mobile/src/features/identity/ParticipantStack.tsx b/apps/mobile/src/features/identity/ParticipantStack.tsx new file mode 100644 index 000000000000..ff953e3e2efc --- /dev/null +++ b/apps/mobile/src/features/identity/ParticipantStack.tsx @@ -0,0 +1,152 @@ +import { useAtomValue } from "@effect/atom-react"; +import { + claimPersonIdForEnvironment, + isClaimedNonStarterParticipant, +} from "@t3tools/client-runtime/state/identity"; +import type { ThreadParticipantSummary } from "@t3tools/contracts"; +import { View } from "react-native"; + +import { AppText as Text } from "../../components/AppText"; +import { cn } from "../../lib/cn"; +import { identityClaimPersonIdByEnvironmentAtom } from "../../state/identity"; +import { IdentityAvatar } from "./IdentityAvatar"; + +/** + * Creator micro-avatar + +N for thread list rows (mirrors web ParticipantStack). + * Long-press / accessibility label carries the expanded roster; dense RN lists + * skip hover popovers. + */ +export function ParticipantStack(props: { + readonly environmentId: string; + readonly participants: ReadonlyArray; + readonly channel?: string | null | undefined; + readonly className?: string | undefined; +}) { + const people = props.participants; + const claimPersonIdByEnvironment = useAtomValue(identityClaimPersonIdByEnvironmentAtom); + const claimPersonId = claimPersonIdForEnvironment( + claimPersonIdByEnvironment, + props.environmentId, + ); + const youParticipated = isClaimedNonStarterParticipant({ + claimPersonId, + participants: people, + }); + if (people.length === 0) return null; + + const lead = people[0]!; + const extras = people.slice(1); + const label = + extras.length === 0 + ? `Started by ${lead.username}` + : `Started by ${lead.username}, ${extras.length} other participant${extras.length === 1 ? "" : "s"}`; + const accessibleLabel = youParticipated ? `${label}. You participated` : label; + + return ( + + + + + + {extras.length > 0 ? ( + + + +{extras.length} + + + ) : null} + + ); +} + +export function SourceChannelGlyph(props: { + readonly channel: string | null | undefined; + readonly overlay?: boolean; + readonly className?: string | undefined; +}) { + if (!props.channel) return null; + const short = + props.channel === "desktop" + ? "D" + : props.channel === "web" + ? "W" + : props.channel === "mobile" + ? "M" + : props.channel === "discord" + ? "Δ" + : props.channel === "jira" + ? "J" + : props.channel === "github" + ? "G" + : props.channel.slice(0, 1).toUpperCase(); + return ( + + + {short} + + + ); +} + +/** Optional trailing metadata that never changes a thread title's alignment. */ +export function ThreadIdentityMark(props: { + readonly environmentId: string; + readonly originChannel?: string | null | undefined; + readonly participants?: ReadonlyArray | null | undefined; + readonly className?: string | undefined; +}) { + const participants = props.participants ?? []; + const channel = props.originChannel ?? participants[0]?.firstChannel ?? null; + if (!channel && participants.length === 0) return null; + if (participants.length === 0) { + return ; + } + return ( + + ); +} diff --git a/apps/mobile/src/features/identity/identityClaimCandidate.ts b/apps/mobile/src/features/identity/identityClaimCandidate.ts new file mode 100644 index 000000000000..15fc4fc986a7 --- /dev/null +++ b/apps/mobile/src/features/identity/identityClaimCandidate.ts @@ -0,0 +1,6 @@ +export function resolveIdentityClaimCandidate( + candidates: readonly T[], + activeIndex: number, +): T | undefined { + return candidates[activeIndex]; +} diff --git a/apps/mobile/src/features/identity/ownershipFilterSurface.test.ts b/apps/mobile/src/features/identity/ownershipFilterSurface.test.ts new file mode 100644 index 000000000000..914673c6e650 --- /dev/null +++ b/apps/mobile/src/features/identity/ownershipFilterSurface.test.ts @@ -0,0 +1,31 @@ +import * as NodeFS from "node:fs"; +import * as NodeURL from "node:url"; +import { describe, expect, it } from "vite-plus/test"; + +function readSource(relativePath: string): string { + return NodeFS.readFileSync(NodeURL.fileURLToPath(new URL(relativePath, import.meta.url)), "utf8"); +} + +describe("mobile ownership filter surface", () => { + it("keeps ownership controls wired in both phone and sidebar thread lists", () => { + const homeHeader = readSource("../home/HomeHeader.tsx"); + const homeRoute = readSource("../home/HomeRouteScreen.tsx"); + const sidebar = readSource("../threads/ThreadNavigationSidebar.tsx"); + const preferences = readSource("../../persistence/mobile-preferences.ts"); + const layout = readSource("../layout/AdaptiveWorkspaceLayout.tsx"); + + expect(homeHeader).toContain('title: "Ownership"'); + expect(homeHeader).toContain("onOwnershipFilterChange"); + expect(homeHeader).toContain("onOwnershipRelationChange"); + expect(homeRoute).toContain("ownershipFilteredThreads"); + expect(homeRoute).toContain("relation: listOptions.ownershipRelation"); + expect(sidebar).toContain("threadMatchesMine"); + expect(sidebar).toContain("ownershipFilter: options.ownershipFilter"); + expect(sidebar).toContain("ownershipRelation: options.ownershipRelation"); + // Device persistence — without these, Mine/Theirs resets on every launch. + expect(preferences).toContain("ownershipFilter"); + expect(preferences).toContain("ownershipRelation"); + expect(layout).toContain("storedOwnershipFilter"); + expect(layout).toContain("onStoreOwnershipFilter"); + }); +}); diff --git a/apps/mobile/src/features/identity/participantStackSurface.test.ts b/apps/mobile/src/features/identity/participantStackSurface.test.ts new file mode 100644 index 000000000000..d0666d2b3b93 --- /dev/null +++ b/apps/mobile/src/features/identity/participantStackSurface.test.ts @@ -0,0 +1,40 @@ +import * as NodeFS from "node:fs"; +import * as NodeURL from "node:url"; +import { describe, expect, it } from "vite-plus/test"; + +function readSource(relativePath: string): string { + return NodeFS.readFileSync(NodeURL.fileURLToPath(new URL(relativePath, import.meta.url)), "utf8"); +} + +describe("mobile participation indicator surface", () => { + it("keeps the claimed-participant marker wired across mobile thread lists", () => { + const stack = readSource("./ParticipantStack.tsx"); + const listV1 = readSource("../threads/thread-list-items.tsx"); + const listV2 = readSource("../threads/thread-list-v2-items.tsx"); + const board = readSource("../board/BoardScreen.tsx"); + + expect(stack).toContain('testID={youParticipated ? "you-participated-indicator"'); + expect(stack).toContain("+{extras.length}"); + expect(stack).toContain('"border border-primary bg-primary/15"'); + expect(stack).not.toContain(">✓"); + expect(stack).toContain("highlighted={lead.personId === claimPersonId}"); + const avatar = readSource("./IdentityAvatar.tsx"); + expect(avatar).toContain('props.highlighted && "bg-primary"'); + expect(stack).toContain("isClaimedNonStarterParticipant"); + expect(stack).toContain("You participated"); + expect(stack).toContain("export function ThreadIdentityMark"); + expect(stack).toContain("never changes a thread title's alignment"); + expect(stack).toContain( + " export function dispatchHardwareKeyboardCommand(command: HardwareKeyboardCommand): boolean { const commandHandlers = handlers.get(command); if (!commandHandlers) return false; - for (const handler of [...commandHandlers].toReversed()) { + for (const handler of [...commandHandlers].reverse()) { if (handler() !== false) return true; } return false; diff --git a/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx b/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx index c030e49c2b77..423f17c34b49 100644 --- a/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx +++ b/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx @@ -3,7 +3,7 @@ import type { EnvironmentThreadShell, } from "@t3tools/client-runtime/state/shell"; import { EnvironmentId, ThreadId, type SidebarProjectGroupingMode } from "@t3tools/contracts"; -import { useAtomValue } from "@effect/atom-react"; +import { useAtomSet, useAtomValue } from "@effect/atom-react"; import { useFocusEffect } from "@react-navigation/native"; import { NavigationContext, @@ -41,7 +41,8 @@ import { } from "../../lib/layout"; import { resolveThreadSelectionNavigationAction } from "../../lib/adaptive-navigation"; import { scopedThreadKey } from "../../lib/scopedEntities"; -import { mobilePreferencesAtom } from "../../state/preferences"; +import { mobilePreferencesAtom, updateMobilePreferencesAtom } from "../../state/preferences"; +import { prefetchEnvironmentThread, warmSelectedEnvironmentThread } from "../../state/threads"; import { DEFAULT_MOBILE_PROJECT_GROUPING_SETTINGS, resolveMobileProjectGroupingSettings, @@ -50,8 +51,22 @@ import { parseActiveThreadPath, useHardwareKeyboardCommand, } from "../keyboard/hardwareKeyboardCommands"; +import { + resolveOwnershipFilter, + resolveOwnershipRelation, +} from "../../persistence/mobile-preferences"; import { AndroidHomeFabLayout } from "../home/AndroidHomeFab"; -import { HomeListOptionsProvider } from "../home/home-list-options"; +import { + HomeListOptionsProvider, + resolveProjectGroupingMode, + type OwnershipFilter, + type OwnershipRelation, +} from "../home/home-list-options"; +import { + DEFAULT_HOME_THREAD_GROUPING, + resolveHomeThreadGrouping, + type HomeThreadGrouping, +} from "../home/homeListMode"; import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; import { ThreadNavigationSidebar } from "../threads/ThreadNavigationSidebar"; import { WORKSPACE_PANE_TIMING } from "./workspace-pane-animation"; @@ -200,19 +215,70 @@ export function AdaptiveWorkspaceLayout(props: { readonly pathname: string; }) { const preferencesResult = useAtomValue(mobilePreferencesAtom); + const savePreferences = useAtomSet(updateMobilePreferencesAtom); + const storeEnvironmentIds = useCallback( + (ids: readonly EnvironmentId[]) => { + savePreferences({ selectedEnvironmentIds: [...ids] }); + }, + [savePreferences], + ); + const storeThreadGrouping = useCallback( + (grouping: HomeThreadGrouping) => { + savePreferences({ threadGrouping: grouping }); + }, + [savePreferences], + ); + const storeOwnershipFilter = useCallback( + (filter: OwnershipFilter) => { + savePreferences({ ownershipFilter: filter }); + }, + [savePreferences], + ); + const storeOwnershipRelation = useCallback( + (relation: OwnershipRelation) => { + savePreferences({ ownershipRelation: relation }); + }, + [savePreferences], + ); + if (!AsyncResult.isSuccess(preferencesResult)) { return AsyncResult.isFailure(preferencesResult) ? ( ) : null; } - const groupingSettings = resolveMobileProjectGroupingSettings(preferencesResult.value); + + const storedEnvironmentIds = (preferencesResult.value.selectedEnvironmentIds ?? + []) as readonly EnvironmentId[]; + const storedThreadGrouping = resolveHomeThreadGrouping(preferencesResult.value.threadGrouping); + const storedOwnershipFilter = resolveOwnershipFilter(preferencesResult.value); + const storedOwnershipRelation = resolveOwnershipRelation(preferencesResult.value); + return ( ); } @@ -223,6 +289,14 @@ function AdaptiveWorkspaceLayoutContent( readonly pathname: string; } & { readonly projectGroupingMode: SidebarProjectGroupingMode; + readonly storedEnvironmentIds: readonly EnvironmentId[]; + readonly onStoreEnvironmentIds: (ids: readonly EnvironmentId[]) => void; + readonly storedThreadGrouping: HomeThreadGrouping; + readonly onStoreThreadGrouping: (grouping: HomeThreadGrouping) => void; + readonly storedOwnershipFilter: OwnershipFilter; + readonly onStoreOwnershipFilter: (filter: OwnershipFilter) => void; + readonly storedOwnershipRelation: OwnershipRelation; + readonly onStoreOwnershipRelation: (relation: OwnershipRelation) => void; }, ) { const projectGroupingMode = props.projectGroupingMode; @@ -522,6 +596,9 @@ function AdaptiveWorkspaceLayoutContent( environmentId: String(thread.environmentId), threadId: String(thread.id), }; + // Overlap SQLite/HTTP detail hydrate with navigation / setParams. + prefetchEnvironmentThread(thread.environmentId, thread.id); + warmSelectedEnvironmentThread(thread.environmentId, thread.id); const navigationAction = resolveThreadSelectionNavigationAction({ usesSplitView: layout.usesSplitView, pathname, @@ -546,7 +623,17 @@ function AdaptiveWorkspaceLayoutContent( ); return ( - + {shouldRenderPrimarySidebar && layout.listPaneWidth !== null ? ( diff --git a/apps/mobile/src/features/review/shikiReviewHighlighter.test.ts b/apps/mobile/src/features/review/shikiReviewHighlighter.test.ts index 6d36171d2711..519764f3b02d 100644 --- a/apps/mobile/src/features/review/shikiReviewHighlighter.test.ts +++ b/apps/mobile/src/features/review/shikiReviewHighlighter.test.ts @@ -65,9 +65,18 @@ describe("highlightSourceFile", () => { .join(""), ).toBe(source); expect(highlighted.flat().some((token) => token.color !== null)).toBe(true); + const snippet = await highlighter.highlightCodeSnippet({ + code: source, + language: "ts", + theme: "dark", + }); expect( - await highlighter.highlightCodeSnippet({ code: source, language: "ts", theme: "dark" }), - ).toEqual(highlighted); + snippet + .flat() + .map((token) => token.content) + .join(""), + ).toBe(source); + expect(snippet.flat().some((token) => token.color !== null)).toBe(true); }); }); diff --git a/apps/mobile/src/features/review/shikiReviewHighlighter.ts b/apps/mobile/src/features/review/shikiReviewHighlighter.ts index a2e3fbd4eb0c..beda79b6c715 100644 --- a/apps/mobile/src/features/review/shikiReviewHighlighter.ts +++ b/apps/mobile/src/features/review/shikiReviewHighlighter.ts @@ -203,11 +203,14 @@ function logReviewHighlighterDiagnostic(message: string, details?: Record { attemptedEngine: "native", cause: error, }); - logReviewHighlighterDiagnosticError( + logReviewHighlighterRecoveredFailure( "native engine initialization failed; falling back to javascript", nativeInitializationError, ); diff --git a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx index 77036c212517..a64a106268d3 100644 --- a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx +++ b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx @@ -8,10 +8,19 @@ import { SymbolView } from "../../components/AppSymbol"; import * as Effect from "effect/Effect"; import { AsyncResult } from "effect/unstable/reactivity"; import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react"; -import { Alert, Linking, Platform, Pressable, ScrollView, View } from "react-native"; +import { + ActivityIndicator, + Alert, + Linking, + Platform, + Pressable, + ScrollView, + View, +} from "react-native"; import { useSafeAreaInsets } from "react-native-safe-area-context"; import { + type AtomCommandResult, isAtomCommandInterrupted, reportAtomCommandResult, settleAsyncResult, @@ -50,6 +59,7 @@ import { supportsSharedSettingsSync, } from "@t3tools/client-runtime/state/shared-settings"; import { useThreadListV2Enabled } from "../threads/use-thread-list-v2-enabled"; +import * as Updates from "expo-updates"; import { type AppUpdateCheckState, isAppUpdateCheckAvailable, @@ -767,12 +777,23 @@ function AppSettingsSection() { const variant = (Constants.expoConfig?.extra?.appVariant as string | undefined) ?? "production"; const variantLabel = variant === "production" ? "" : capitalize(variant); const versionLabel = variantLabel ? `${version} · ${variantLabel}` : version; + // Which JS is actually running: the bundle shipped in the binary, or an OTA + // update downloaded on top of it. Surfacing this makes "am I even on the + // right build?" answerable at a glance. + const bundleLabel = Updates.isEnabled + ? Updates.isEmbeddedLaunch + ? "Embedded" + : Updates.updateId + ? `OTA ${Updates.updateId.slice(0, 7)}` + : null + : null; + const updateCheckAvailable = isAppUpdateCheckAvailable(); const busy = updateState === "checking" || updateState === "downloading" || updateState === "restarting"; // "Up to date" is a transient acknowledgement, not a state worth persisting — - // return the version row to its normal, deliberately quiet state. + // drop back to the bundle label so the row keeps answering "what am I running?". useEffect(() => { if (updateState !== "current") return; const timer = setTimeout(() => setUpdateState("idle"), 3000); @@ -819,7 +840,7 @@ function AppSettingsSection() { ? "Restarting…" : updateState === "current" ? "Up to date" - : null; + : bundleLabel; const versionRow = ( @@ -837,6 +858,21 @@ function AppSettingsSection() { {statusLabel} ) : null} + {Updates.isEnabled ? ( + + {busy ? ( + + ) : ( + + )} + + ) : null} ); @@ -846,10 +882,10 @@ function AppSettingsSection() { {updateCheckAvailable ? ( void checkForUpdate()} > {versionRow} diff --git a/apps/mobile/src/features/terminal/terminalMenu.ts b/apps/mobile/src/features/terminal/terminalMenu.ts index 06cb74e9467d..9d5c7c0ee833 100644 --- a/apps/mobile/src/features/terminal/terminalMenu.ts +++ b/apps/mobile/src/features/terminal/terminalMenu.ts @@ -155,7 +155,11 @@ export function resolveProjectScriptTerminalId(input: { } export function projectScriptMenuLabel(script: ProjectScript): string { - return script.runOnWorktreeCreate ? `${script.name} (setup)` : script.name; + const tags: string[] = []; + if (script.runOnWorktreeCreate) tags.push("setup"); + if (script.runOnWorktreeRemove === true) tags.push("teardown"); + if (script.runOnPrMerged === true) tags.push("pr-merged"); + return tags.length > 0 ? `${script.name} (${tags.join(", ")})` : script.name; } export function projectScriptMenuIcon(icon: ProjectScript["icon"]) { diff --git a/apps/mobile/src/features/threads/ComposerQueuedMessages.tsx b/apps/mobile/src/features/threads/ComposerQueuedMessages.tsx new file mode 100644 index 000000000000..68f32707b75e --- /dev/null +++ b/apps/mobile/src/features/threads/ComposerQueuedMessages.tsx @@ -0,0 +1,105 @@ +import type { MessageId } from "@t3tools/contracts"; +import { ActivityIndicator, Pressable, View } from "react-native"; + +import { AppText as Text } from "../../components/AppText"; +import { SymbolView } from "../../components/AppSymbol"; +import { deriveQueuedMessageControls } from "../../lib/threadActivity"; + +export interface ComposerQueueItem { + readonly messageId: MessageId; + readonly text: string; + readonly attachmentCount: number; + readonly deliveryState: "waiting" | "sending" | "queued"; + readonly queueSource: "local" | "server"; +} + +/** + * Server + local outbox follow-ups, sticky above the keyboard composer + * (web QueuedMessageChips parity — not timeline rows). + */ +export function ComposerQueuedMessages(props: { + readonly items: ReadonlyArray; + readonly disabled?: boolean; + readonly onSteer: (messageId: MessageId) => void; + readonly onEdit: (messageId: MessageId, source: "local" | "server") => void; +}) { + if (props.items.length === 0) { + return null; + } + + return ( + + {props.items.map((item) => { + const controls = deriveQueuedMessageControls(item.deliveryState, item.queueSource); + const preview = + item.text.trim().length > 0 + ? item.text.trim() + : item.attachmentCount > 0 + ? `${item.attachmentCount} attachment${item.attachmentCount === 1 ? "" : "s"}` + : "Empty message"; + const statusLabel = + item.deliveryState === "sending" + ? "Sending" + : item.deliveryState === "waiting" + ? "Waiting for connection" + : "Queued"; + + return ( + + + + + {preview} + + + {item.deliveryState === "sending" ? ( + + ) : null} + {statusLabel} + + + {controls.canSteer ? ( + props.onSteer(item.messageId)} + className="min-h-8 justify-center rounded-full px-2" + style={{ opacity: props.disabled ? 0.45 : 1 }} + > + Send now + + ) : null} + {controls.canEdit ? ( + props.onEdit(item.messageId, item.queueSource)} + className="size-8 items-center justify-center rounded-full" + style={{ opacity: props.disabled ? 0.45 : 1 }} + > + + + ) : null} + + ); + })} + + ); +} diff --git a/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx index aab423a3792e..6d0419034ab5 100644 --- a/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx @@ -12,26 +12,32 @@ import { useWorkspaceState } from "../../state/workspace"; import { vcsEnvironment } from "../../state/vcs"; import { checkoutNewTaskBranch } from "./checkout-new-task-branch"; import { NativeStackScreenOptions } from "../../native/StackHeader"; +import type { ComposerDraftWorkspaceSelection } from "../../state/use-composer-drafts"; import { NewTaskDraftScreen } from "./NewTaskDraftScreen"; type NewTaskDraftRouteParams = { readonly environmentId?: string | string[]; readonly projectId?: string | string[]; - readonly branch?: string | null; - readonly worktreePath?: string | null; readonly title?: string | string[]; readonly pendingTaskId?: string | string[]; readonly draftId?: string | string[]; readonly incomingShareId?: string | string[]; + readonly workspaceMode?: string | string[]; + readonly branch?: string | string[] | null; + readonly worktreePath?: string | string[] | null; }; +function firstParam(value: string | string[] | null | undefined): string | undefined { + if (value == null) return undefined; + return Array.isArray(value) ? value[0] : value; +} + export function NewTaskDraftRouteScreen({ route }: StaticScreenProps) { const params = useMemo(() => route.params ?? {}, [route.params]); - const pendingTaskId = Array.isArray(params.pendingTaskId) - ? params.pendingTaskId[0] - : params.pendingTaskId; - const draftId = Array.isArray(params.draftId) ? params.draftId[0] : params.draftId; + const pendingTaskId = firstParam(params.pendingTaskId); + const draftId = firstParam(params.draftId); + const workspaceMode = firstParam(params.workspaceMode); const projects = useProjects(); const { state: catalogState } = useWorkspaceState(); const navigation = useNavigation(); @@ -40,17 +46,27 @@ export function NewTaskDraftRouteScreen({ route }: StaticScreenProps ({ - environmentId: Array.isArray(params.environmentId) - ? params.environmentId[0] - : params.environmentId, - projectId: Array.isArray(params.projectId) ? params.projectId[0] : params.projectId, - branch: params.branch, - worktreePath: params.worktreePath, - }), - [params], - ); + const initialProjectRef = useMemo(() => { + const environmentId = firstParam(params.environmentId); + const projectId = firstParam(params.projectId); + // Workspace-picker routes own branch via initialWorkspaceSelection. Putting + // it on initialProjectRef would force local mode and fight a worktree pick. + const workspacePicker = workspaceMode === "local" || workspaceMode === "worktree"; + return { + environmentId, + projectId, + branch: workspacePicker ? null : (firstParam(params.branch) ?? null), + worktreePath: workspacePicker ? null : (firstParam(params.worktreePath) ?? null), + }; + }, [params, workspaceMode]); + const initialWorkspaceSelection = useMemo(() => { + if (workspaceMode !== "local" && workspaceMode !== "worktree") return undefined; + return { + mode: workspaceMode, + branch: firstParam(params.branch) ?? null, + worktreePath: firstParam(params.worktreePath) ?? null, + }; + }, [params.branch, params.worktreePath, workspaceMode]); const [preparation, setPreparation] = useState<{ request: typeof initialProjectRef; @@ -148,7 +164,7 @@ export function NewTaskDraftRouteScreen({ route }: StaticScreenProps {preparingBranch ? ( @@ -158,11 +174,8 @@ export function NewTaskDraftRouteScreen({ route }: StaticScreenProps diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx index 2dd0000ea605..b2728cd3dbaf 100644 --- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx @@ -78,6 +78,7 @@ import { updateComposerDraftSettings, scheduleUnusedComposerAttachmentCleanup, type ComposerDraft, + type ComposerDraftWorkspaceSelection, waitForComposerDraftsLoaded, } from "../../state/use-composer-drafts"; import { useEnvironmentServerConfig, useProjects } from "../../state/entities"; @@ -143,6 +144,7 @@ export function NewTaskDraftScreen(props: { readonly branch?: string | null; readonly worktreePath?: string | null; }; + readonly initialWorkspaceSelection?: ComposerDraftWorkspaceSelection; /** Queued outbox message id when editing an existing pending task. */ readonly pendingTaskId?: string; /** Existing new-task draft key to resume (a Draft row in the thread list). */ @@ -592,6 +594,33 @@ export function NewTaskDraftScreen(props: { setProject, ]); + const appliedInitialWorkspaceSelectionRef = useRef( + undefined, + ); + useEffect(() => { + const selection = props.initialWorkspaceSelection; + const initialEnvironmentId = props.initialProjectRef?.environmentId; + const initialProjectId = props.initialProjectRef?.projectId; + if ( + !selection || + !flow.draftKey || + !selectedProject || + selectedProject.environmentId !== initialEnvironmentId || + selectedProject.id !== initialProjectId || + appliedInitialWorkspaceSelectionRef.current === selection + ) { + return; + } + appliedInitialWorkspaceSelectionRef.current = selection; + updateComposerDraftSettings(flow.draftKey, { workspaceSelection: selection }); + }, [ + flow.draftKey, + props.initialProjectRef?.environmentId, + props.initialProjectRef?.projectId, + props.initialWorkspaceSelection, + selectedProject, + ]); + useEffect(() => { if (!selectedProject) { loadedBranchesProjectKeyRef.current = null; diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx index 7ea20e49ce52..b0071e380185 100644 --- a/apps/mobile/src/features/threads/ThreadComposer.tsx +++ b/apps/mobile/src/features/threads/ThreadComposer.tsx @@ -5,11 +5,17 @@ import type { MessageId, ModelSelection, OrchestrationThreadShell, + ProviderDriverKind, ProviderInteractionMode, RuntimeMode, ServerConfig as T3ServerConfig, UsageLimitsReport, } from "@t3tools/contracts"; +import { resolveDriverUsage } from "@t3tools/client-runtime/state/aiUsagePresentation"; +import { + parseStandaloneComposerSlashCommand, + replaceTextRange, +} from "@t3tools/shared/composerTrigger"; import { collectProviderUsageLimits, hasProviderUsageLimits, @@ -61,7 +67,8 @@ import { ComposerInlineControl, ComposerToolbarRow, } from "../../components/ComposerToolbar"; -import { ProviderIcon } from "../../components/ProviderIcon"; +import { ProviderUsageIcon } from "../../components/ProviderUsageIcon"; +import { useAiUsageSnapshot } from "../../state/useAiUsageSnapshot"; import type { DraftComposerAttachment, DraftComposerFileAttachment, @@ -74,7 +81,7 @@ import { import { useScaledTextRole } from "../settings/appearance/useScaledTextRole"; import type { RemoteClientConnectionState } from "../../lib/connection"; import { resolveProviderOptionDescriptors } from "../../lib/providerOptions"; -import { ComposerCommandPopover } from "./ComposerCommandPopover"; +import { ComposerCommandPopover, type ComposerCommandItem } from "./ComposerCommandPopover"; import { useComposerCommandMenu } from "./use-composer-command-menu"; import { ComposerDictationCancelAction, @@ -114,11 +121,11 @@ export interface ThreadComposerProps { readonly contentMaxWidth?: number; readonly bottomInset?: number; readonly connectionState: RemoteClientConnectionState; + readonly queueCount: number; readonly environmentLabel: string | null; readonly selectedThread: OrchestrationThreadShell; readonly hasCompactableConversation: boolean; readonly serverConfig: T3ServerConfig | null; - readonly queueCount: number; readonly environmentId: EnvironmentId; readonly projectCwd: string | null; /** Why sending is blocked right now (shown as the send button's label), or null. */ @@ -131,6 +138,7 @@ export interface ThreadComposerProps { readonly onRemoveDraftImage: (imageId: string) => void; readonly onStopThread: () => void; readonly onSendMessage: () => Promise; + readonly onStartNewThread: () => void; /** `/usage-limits` resolves locally; the host decides where the report shows. Null clears it. */ readonly onShowUsageLimits: (report: UsageLimitsReport | null) => void; readonly onUpdateModelSelection: (modelSelection: ModelSelection) => void; @@ -317,7 +325,8 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer ); }, [props.serverConfig, props.selectedThread.modelSelection.instanceId]); const composerOwnerKey = scopedThreadKey(props.environmentId, props.selectedThread.id); - const { onSendMessage, onChangeDraftMessage, onShowUsageLimits } = props; + const { onSendMessage, onChangeDraftMessage, onShowUsageLimits, onStartNewThread, draftMessage } = + props; // T3 owns /usage-limits only where Limits has data for the selected provider; // elsewhere the name stays the provider's own and is sent through untouched. const usageLimitsOffered = @@ -360,6 +369,41 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer onUsageLimits: usageLimitsOffered && props.draftAttachments.length === 0 ? openUsageLimits : undefined, }); + const composerMenuItems = useMemo(() => { + const trigger = composerMenu.trigger; + if (trigger?.kind !== "slash-command") { + return composerMenu.items; + } + const q = trigger.query.toLowerCase(); + if (!"new".includes(q)) { + return composerMenu.items; + } + const newItem: ComposerCommandItem = { + id: "cmd:new", + type: "slash-command", + command: "new", + label: "/new", + description: "Start a new thread here", + }; + return [newItem, ...composerMenu.items.filter((item) => item.id !== "cmd:new")]; + }, [composerMenu.items, composerMenu.trigger]); + + const handleCommandSelect = useCallback( + (item: ComposerCommandItem) => { + const trigger = composerMenu.trigger; + if (!trigger) return; + if (item.type === "slash-command" && item.command === "new") { + const result = replaceTextRange(draftMessage, trigger.rangeStart, trigger.rangeEnd, ""); + composerMenu.onSelectionChange({ start: result.cursor, end: result.cursor }); + onChangeDraftMessage(result.text); + onStartNewThread(); + return; + } + composerMenu.onSelect(item); + }, + [composerMenu, draftMessage, onChangeDraftMessage, onStartNewThread], + ); + const voiceInput = useVoiceInputController({ ownerKey: composerOwnerKey, draftMessage: props.draftMessage, @@ -446,6 +490,11 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer return; } if (voiceInput.blocksSubmission) return; + if (parseStandaloneComposerSlashCommand(draftMessage) === "new") { + onChangeDraftMessage(""); + onStartNewThread(); + return; + } const threadKey = scopedThreadKey(props.environmentId, props.selectedThread.id); if (inFlightThreadIdsRef.current.has(threadKey)) return; inFlightThreadIdsRef.current.add(threadKey); @@ -473,6 +522,9 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer openUsageLimits, usageLimitsOffered, onSendMessage, + draftMessage, + onChangeDraftMessage, + onStartNewThread, props.environmentId, props.environmentLabel, props.selectedThread.id, @@ -498,6 +550,32 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer option.selection.instanceId === currentModelSelection.instanceId && option.selection.model === currentModelSelection.model, ) ?? null; + + const aiUsageSnapshot = useAiUsageSnapshot(props.environmentId); + const threadUsage = useMemo( + () => + currentModelOption + ? resolveDriverUsage( + aiUsageSnapshot, + currentModelOption.providerDriver as ProviderDriverKind, + currentModelSelection.model, + ) + : null, + [aiUsageSnapshot, currentModelOption, currentModelSelection.model], + ); + const currentModelIconNode = ( + + ); + + const currentUsageNote = threadUsage + ? (threadUsage.item.windows + .map((w) => (typeof w.percent === "number" ? `${w.percent}%` : null)) + .find(Boolean) ?? null) + : null; const providerOptionDescriptors = useMemo( () => resolveProviderOptionDescriptors({ @@ -601,10 +679,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer {!voiceInput.isBusy && composerMenu.trigger && composerMenu.items.length > 0 ? ( ) : null} @@ -806,10 +884,12 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer + iconNode={currentModelIconNode} + label={ + currentUsageNote + ? `${currentModelOption?.label ?? currentModelSelection.model} · ${currentUsageNote}` + : (currentModelOption?.label ?? currentModelSelection.model) } - label={currentModelOption?.label ?? currentModelSelection.model} maxWidth="100%" onPress={openSettings} /> diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx index 55cd9e9a6c83..a48fb7919370 100644 --- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx +++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx @@ -81,6 +81,7 @@ import type { PendingUserInputDraftAnswer, ThreadFeedEntry, } from "../../lib/threadActivity"; +import { ComposerQueuedMessages } from "./ComposerQueuedMessages"; import { PendingApprovalCard } from "./PendingApprovalCard"; import { ComposerFeedback } from "./ComposerFeedback"; import { ComposerUsageLimits } from "./ComposerUsageLimits"; @@ -105,7 +106,6 @@ import { } from "./ThreadComposer"; import { ThreadFeed } from "./ThreadFeed"; import type { ThreadContentPresentation } from "./threadContentPresentation"; -import { resolveThreadFeedSubmissionAnchor } from "./thread-feed-live-follow"; export interface ThreadDetailScreenProps { readonly selectedThread: OrchestrationThreadShell; @@ -140,10 +140,12 @@ export interface ThreadDetailScreenProps { readonly threadSyncStatus?: EnvironmentThreadStatus; /** Non-null when older turns exist beyond the loaded window. */ readonly loadEarlier?: { readonly loading: boolean; readonly onLoadEarlier: () => void } | null; + /** A send made now would be held in the steering queue, not open a turn. */ + readonly sendEntersQueue: boolean; + readonly selectedThreadQueueCount: number; readonly environmentId: EnvironmentId; readonly projectWorkspaceRoot: string | null; readonly threadCwd: string | null; - readonly selectedThreadQueueCount: number; readonly queuedMessages: ReadonlyArray; readonly dispatchingMessageId: MessageId | null; readonly serverConfig: T3ServerConfig | null; @@ -158,6 +160,16 @@ export interface ThreadDetailScreenProps { readonly onRemoveDraftImage: (imageId: string) => void; readonly onStopThread: () => void; readonly onSendMessage: () => Promise; + readonly composerQueueItems: ReadonlyArray<{ + readonly messageId: MessageId; + readonly text: string; + readonly attachmentCount: number; + readonly deliveryState: "waiting" | "sending" | "queued"; + readonly queueSource: "local" | "server"; + }>; + readonly onSteerQueuedMessage: (messageId: MessageId) => Promise; + readonly onEditQueuedMessage: (messageId: MessageId, source: "local" | "server") => Promise; + readonly onStartNewThread: () => void; readonly onReconnectEnvironment: () => void; readonly onUpdateThreadModelSelection: (modelSelection: ModelSelection) => void; readonly onUpdateThreadRuntimeMode: (runtimeMode: RuntimeMode) => void; @@ -681,6 +693,8 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread }, [freeze, selectedThreadKey]); useEffect(() => { + // Anchor as soon as the target row exists in the feed — including local + // outbox "Sending" bubbles painted before thread detail has finished loading. if ( submittedMessageId === null || anchorMessageId !== submittedMessageId || @@ -738,11 +752,10 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread selectedThreadKey, ]); + const sendEntersQueue = props.sendEntersQueue; const handleSendMessage = useCallback(async () => { const targetThreadKey = selectedThreadKey; - const hasUserMessage = selectedThreadFeed.some( - (entry) => entry.type === "message" && entry.message.role === "user", - ); + const sendWillQueue = sendEntersQueue; const messageId = await props.onSendMessage(); if (messageId === null || selectedThreadKeyRef.current !== targetThreadKey) { return messageId; @@ -751,27 +764,21 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread // A sent message makes the snapshot stale; a refused send leaves it in place. clearUsageLimitsFor(targetThreadKey); - setSubmittedMessageId(messageId); - setAnchorMessageId( - resolveThreadFeedSubmissionAnchor({ - currentAnchorMessageId: anchorMessageId, - submittedMessageId: messageId, - hasStartedTurn: props.selectedThread.latestTurn !== null, - hasUserMessage, - queuedMessageCount: props.selectedThreadQueueCount, - }), - ); + // A send the server holds in the steering queue stays a composer chip: it + // never becomes a feed row, so moving the feed for it would both yank a + // reader out of history now and leave the anchor armed to fire whenever + // the queue finally drains. + if (!sendWillQueue) { + // Rejoin the physical live edge before the outgoing-row anchor is + // applied. Enabling end maintenance alone is ineffective when the list + // was scrolled into older history. + listRef.current?.scrollToEnd({ animated: false }); + setSubmittedMessageId(messageId); + setAnchorMessageId(messageId); + } composerEditorRef.current?.blur(); return messageId; - }, [ - anchorMessageId, - clearUsageLimitsFor, - props.onSendMessage, - props.selectedThread.latestTurn, - props.selectedThreadQueueCount, - selectedThreadFeed, - selectedThreadKey, - ]); + }, [clearUsageLimitsFor, props.onSendMessage, selectedThreadKey, sendEntersQueue]); const handleEditPendingMessage = useCallback(async (message: QueuedThreadMessage) => { try { @@ -816,6 +823,11 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread }); }, [freeze, scrollMessageToEnd]); + // Fork: upstream's pill is icon-only. The fork's feed chip said "New + // activity" when something arrived while the reader was away, which is the + // difference between "you scrolled up" and "you are missing something". The + // feed reports it now and the pill carries the dot. + const [hasUnreadActivity, setHasUnreadActivity] = useState(false); const showScrollToEndButton = contentPresentationKind === "ready" && !endFollowEnabled; const { themeAppearance, materialYouStyleLayoutActive } = useAppearancePreferences(); const isDarkMode = themeAppearance === "dark"; @@ -897,6 +909,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread usesAutomaticContentInsets={props.usesAutomaticContentInsets} onHeaderMaterialVisibilityChange={props.onHeaderMaterialVisibilityChange} onEndFollowEnabledChange={setEndFollowEnabled} + onUnreadActivityChange={setHasUnreadActivity} skills={selectedProviderSkills} onUseArtifactTemplate={handleUseArtifactTemplate} loadEarlier={props.loadEarlier ?? null} @@ -906,7 +919,13 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread )} - {/* Floating composer — sticks to keyboard via KeyboardStickyView */} + {/* + Pin the composer to the bottom of a full-screen overlay host. + KeyboardStickyView only applies translateY for the IME — it must sit in a + full-height column (not `position: absolute; bottom: 0` on itself), or a + stale keyboard height leaves the input floating mid-thread with the feed + scrolling behind it. + */} {showContent ? ( @@ -1010,6 +1030,19 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread ) : null} ) : null} + {/* Fork: a send held in the steering queue stays a composer chip + rather than becoming a feed row, so it belongs in the overlay + beside the approval cards. */} + { + void props.onSteerQueuedMessage(messageId); + }} + onEdit={(messageId, source) => { + void props.onEditQueuedMessage(messageId, source); + }} + /> {/* Hidden (not unmounted) while a user-input request owns the @@ -1052,6 +1085,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread onRemoveDraftImage={props.onRemoveDraftImage} onStopThread={props.onStopThread} onSendMessage={handleSendMessage} + onStartNewThread={props.onStartNewThread} onShowUsageLimits={showUsageLimits} onUpdateModelSelection={props.onUpdateThreadModelSelection} onUpdateRuntimeMode={props.onUpdateThreadRuntimeMode} diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx index 8874f77bdc28..d99d3e29bb83 100644 --- a/apps/mobile/src/features/threads/ThreadFeed.tsx +++ b/apps/mobile/src/features/threads/ThreadFeed.tsx @@ -253,6 +253,8 @@ export interface ThreadFeedProps { readonly usesAutomaticContentInsets?: boolean; readonly onHeaderMaterialVisibilityChange?: (visible: boolean) => void; readonly onEndFollowEnabledChange?: (enabled: boolean) => void; + /** Fork: something arrived while the reader was away from the live edge. */ + readonly onUnreadActivityChange?: (hasUnread: boolean) => void; readonly skills?: ReadonlyArray; readonly onUseArtifactTemplate?: (template: CodexArtifactTemplate) => void; /** Non-null when older turns exist beyond the loaded window. */ @@ -1456,6 +1458,7 @@ function renderFeedEntry( const styles = isUser ? markdownStyles.user : markdownStyles.assistant; const timestampLabel = formatMessageTime(isUser ? message.createdAt : message.updatedAt); const attachments = message.attachments ?? []; + const previewAttachments = entry.previewAttachments ?? []; const hasReviewCommentContext = message.text.includes(" ); })} + {previewAttachments.map((attachment) => ( + + ))} @@ -1981,8 +1992,17 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { // momentum; scroll events only break follow inside that session, so MVCP // compensations and programmatic scrolls never strand a follower. const userScrollSessionRef = useRef(false); + // Fork: the scroll-to-latest pill reports whether anything arrived while the + // reader was away, so returning to the live edge always clears it. + const hasUnreadActivityRef = useRef(false); const setEndFollow = useCallback( (enabled: boolean) => { + if (enabled) { + if (hasUnreadActivityRef.current) { + hasUnreadActivityRef.current = false; + props.onUnreadActivityChange?.(false); + } + } if (endFollowEnabledRef.current === enabled) { return; } @@ -1990,7 +2010,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { setEndFollowEnabled(enabled); props.onEndFollowEnabledChange?.(enabled); }, - [props.onEndFollowEnabledChange], + [props.onEndFollowEnabledChange, props.onUnreadActivityChange], ); const transitionEndFollow = useCallback( (event: ThreadFeedLiveFollowEvent) => { @@ -2419,6 +2439,23 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { } }, [clearUserScrollSettle, props.submittedMessageId, transitionEndFollow]); + // Mark unread only for activity that lands while follow is broken; a thread + // switch re-arms follow above and clears the flag through setEndFollow. + const observedActivityRef = useRef({ feed: props.feed, latestTurn: props.latestTurn }); + useEffect(() => { + const previous = observedActivityRef.current; + observedActivityRef.current = { feed: props.feed, latestTurn: props.latestTurn }; + if ( + (previous.feed !== props.feed || previous.latestTurn !== props.latestTurn) && + !endFollowEnabledRef.current + ) { + if (!hasUnreadActivityRef.current) { + hasUnreadActivityRef.current = true; + props.onUnreadActivityChange?.(true); + } + } + }, [props.feed, props.latestTurn]); + const expandedWorkGroupIds = useMemo(() => { const ids = new Set(); for (const [groupId, expanded] of Object.entries(expandedWorkGroups)) { @@ -2450,11 +2487,25 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { props.latestTurn, ], ); - // The empty↔filled key below remounts the list and resets its imperative - // content-inset override. Seed the fresh instance synchronously with the - // current overlay height before the scroll integration's next reaction; - // on Android the declarative contentInset floor covers this same window. - const listMountKey = `${feedThreadKey}:${presentedFeed.length === 0 ? "empty" : "filled"}`; + // The empty↔filled key remounts the list and resets its imperative + // content-inset override. The key goes filled once per thread open and + // stays there. Toggling it back on a feed that briefly empties during + // sync remounts mid-read. Keyed on the environment-scoped key, not the + // bare thread id: two environments can hold the same id. Count presented + // rows (including pending outbox messages) so the first queued send is + // treated as a filled timeline. + // Seed the fresh instance synchronously with the current overlay height + // before the scroll integration's next reaction; on Android the + // declarative contentInset floor covers this same window. + const listMountThreadKeyRef = useRef(feedThreadKey); + const sawFilledFeedRef = useRef(presentedFeed.length > 0); + if (listMountThreadKeyRef.current !== feedThreadKey) { + listMountThreadKeyRef.current = feedThreadKey; + sawFilledFeedRef.current = presentedFeed.length > 0; + } else if (presentedFeed.length > 0) { + sawFilledFeedRef.current = true; + } + const listMountKey = `${feedThreadKey}:${sawFilledFeedRef.current ? "filled" : "empty"}`; useLayoutEffect(() => { const bottom = props.contentInsetEndAdjustment.value; if (bottom > 0) { @@ -2854,6 +2905,9 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { }, } } + // maintainVisibleContentPosition also keeps the viewport anchored + // when older history prepends at the top. Disable it while following + // the live edge so a pending-message insert does not fight end pinning. maintainVisibleContentPosition={ endFollowEnabled && !disclosureToggleSettling ? false : maintainVisibleContentPosition } @@ -2912,6 +2966,8 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { onMomentumScrollBegin={handleMomentumScrollBegin} onMomentumScrollEnd={handleMomentumScrollEnd} scrollEventThrottle={16} + // Under automatic insets the spacer is UIKit's job, but the + // older-history spinner still belongs at the top of the content. ListHeaderComponent={ <> {usesNativeAutomaticInsets ? null : } @@ -2934,7 +2990,24 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { }} /> + {presentedFeed.length === 0 && props.loadEarlier != null ? ( + // The window can derive zero visible entries while older history + // exists — give the user an explicit affordance instead of the + // empty-state placeholder. + + + {props.loadEarlier.loading ? ( + + ) : ( + + Load earlier turns + + )} + + + ) : null} {presentedFeed.length === 0 && + props.loadEarlier == null && props.activeWorkStartedAt === null && props.contentPresentation.kind === "ready" ? ( diff --git a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx index dce02cac1d4b..e6080d27736e 100644 --- a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx +++ b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx @@ -4,13 +4,18 @@ import type { EnvironmentProject, EnvironmentThreadShell, } from "@t3tools/client-runtime/state/shell"; +import { + claimPersonIdForEnvironment, + threadMatchesMine, +} from "@t3tools/client-runtime/state/identity"; import { threadSearchMatchKey, type EnvironmentThreadSearchMatch, } from "@t3tools/client-runtime/state/thread-search"; import { LegendList } from "@legendapp/list/react-native"; import type { MenuAction } from "@react-native-menu/menu"; -import { useAtomValue } from "@effect/atom-react"; +import { useAtomSet, useAtomValue } from "@effect/atom-react"; +import { AsyncResult } from "effect/unstable/reactivity"; import { type EnvironmentId, resolveEnvironmentMachineKind } from "@t3tools/contracts"; import { useCallback, useEffect, useMemo, useRef, useState } from "react"; import type { LayoutChangeEvent } from "react-native"; @@ -21,15 +26,21 @@ import { useSafeAreaInsets } from "react-native-safe-area-context"; import type { SearchBarCommands } from "react-native-screens"; import { AppText as Text } from "../../components/AppText"; -import { CompactBrandTitle } from "../../components/CompactBrandTitle"; import { ControlPillMenu } from "../../components/ControlPill"; import { SymbolView } from "../../components/AppSymbol"; import { NATIVE_LIQUID_GLASS_SUPPORTED } from "../../native/native-glass"; import { NativeStackScreenOptions } from "../../native/StackHeader"; import { scopedProjectKey, scopedThreadKey } from "../../lib/scopedEntities"; +import { useUniwindTheme } from "../../lib/useUniwindTheme"; import { useProjects, useThreadShells } from "../../state/entities"; -import { useThreadSearch } from "../../state/queries"; +import { identityClaimPersonIdByEnvironmentAtom } from "../../state/identity"; +import { + resolveHideSettledOnProjects, + resolveHideSettledOnRecent, +} from "../../persistence/mobile-preferences"; +import { mobilePreferencesAtom, updateMobilePreferencesAtom } from "../../state/preferences"; import { useThreadListV2Enabled } from "./use-thread-list-v2-enabled"; +import { useThreadSearch } from "../../state/queries"; import { useThreadListV2ShelfPreferences } from "./use-thread-list-v2-shelf-preferences"; import { usePendingThreadOrder } from "../../state/thread-order"; import { environmentServerConfigsAtom } from "../../state/server"; @@ -38,15 +49,19 @@ import { useQueuedThreadKeys } from "../../state/use-thread-outbox"; import { useWorkspaceState } from "../../state/workspace"; import { useSavedRemoteConnections } from "../../state/use-remote-environment-registry"; import { useHardwareKeyboardCommand } from "../keyboard/hardwareKeyboardCommands"; +import { BoardScreen } from "../board/BoardScreen"; import { + DEFAULT_OWNERSHIP_FILTER, hasCustomHomeListOptions, PROJECT_SORT_OPTIONS, THREAD_SORT_OPTIONS, useHomeListOptions, } from "../home/home-list-options"; import { buildHomeListFilterMenu } from "../home/home-list-filter-menu"; +import { matchesEnvironmentFilter } from "../home/homeEnvironmentFilter"; import { buildHomeListLayout, + buildHomeRecentListLayout, DEFAULT_GROUP_DISPLAY_STATE, EMPTY_HOME_LIST_LAYOUT, homeListItemsAreEqual, @@ -55,6 +70,14 @@ import { type HomeGroupDisplayState, type HomeListItem, } from "../home/homeListItems"; +import { buildHomeRecentListEntries, buildHomeRecentPendingEntries } from "../home/homeRecentList"; +import { + HOME_LIST_MODE_TITLES, + HOME_THREAD_GROUPING_LABELS, + HOME_THREAD_GROUPINGS, + usesFlatThreadGrouping, + usesProjectThreadGrouping, +} from "../home/homeListMode"; import { buildHomeProjectScopes, buildHomeThreadGroups } from "../home/homeThreadList"; import { SwipeableScrollGateProvider, useSwipeableScrollGate } from "../home/thread-swipe-actions"; import { usePendingTaskListActions } from "../home/usePendingTaskListActions"; @@ -71,6 +94,7 @@ import { PendingTaskListRow, ThreadListGroupHeader, ThreadListRow, + ThreadListSectionHeader, ThreadListShowMoreRow, } from "./thread-list-items"; import { @@ -152,6 +176,7 @@ function ThreadNavigationSidebarPane( const mutedColor = materialTheme["--color-foreground-muted"]; const insets = useSafeAreaInsets(); + const backgroundColor = useUniwindTheme()["--color-drawer"]; const projects = useProjects(); const threads = useThreadShells(); const { environments: workspaceEnvironments, state: catalogState } = useWorkspaceState(); @@ -172,7 +197,9 @@ function ThreadNavigationSidebarPane( moveThread, regenerateThreadTitle, } = useThreadListActions(); - const threadListV2Enabled = useThreadListV2Enabled(); + const threadListV2Preferred = useThreadListV2Enabled(); + const preferencesResult = useAtomValue(mobilePreferencesAtom); + const savePreferences = useAtomSet(updateMobilePreferencesAtom); const pendingTasks = usePendingNewTasks(); const queuedThreadKeys = useQueuedThreadKeys(); const { openPendingTask, confirmDeletePendingTask } = usePendingTaskListActions(); @@ -190,23 +217,28 @@ function ThreadNavigationSidebarPane( () => new Set(environments.map((environment) => environment.environmentId)), [environments], ); - const { options, setSelectedEnvironmentId, setProjectSortOrder, setThreadSortOrder } = - useHomeListOptions(availableEnvironmentIds); - const searchEnvironmentIds = useMemo( - () => - options.selectedEnvironmentId === null - ? workspaceEnvironments - .filter((environment) => environment.connectionState === "connected") - .map((environment) => environment.environmentId) - : workspaceEnvironments.some( - (environment) => - environment.environmentId === options.selectedEnvironmentId && - environment.connectionState === "connected", - ) - ? [options.selectedEnvironmentId] - : [], - [options.selectedEnvironmentId, workspaceEnvironments], - ); + const { + options, + toggleSelectedEnvironmentId, + clearSelectedEnvironments, + setOwnershipFilter, + setOwnershipRelation, + setListMode, + setThreadGrouping, + setProjectSortOrder, + setThreadSortOrder, + } = useHomeListOptions(availableEnvironmentIds); + const claimPersonIdByEnvironment = useAtomValue(identityClaimPersonIdByEnvironmentAtom); + const searchEnvironmentIds = useMemo(() => { + const connectedIds = workspaceEnvironments + .filter((environment) => environment.connectionState === "connected") + .map((environment) => environment.environmentId); + if (options.selectedEnvironmentIds.length === 0) { + return connectedIds; + } + const selected = new Set(options.selectedEnvironmentIds); + return connectedIds.filter((environmentId) => selected.has(environmentId)); + }, [options.selectedEnvironmentIds, workspaceEnvironments]); const threadSearch = useThreadSearch(searchEnvironmentIds, props.searchQuery); const threadSearchMatchByKey = useMemo(() => { const matches = new Map(); @@ -221,15 +253,42 @@ function ThreadNavigationSidebarPane( () => new Set(threadSearch.matches.map(threadSearchMatchKey)), [threadSearch.matches], ); + // Grouping changes V2 ordering only; it must never swap in a different row + // renderer or remove pinning / shelves. + // v2 is the default list since #5672; legacyThreadListEnabled is the opt-out. + // Must match HomeScreen, or this surface and Home disagree about the list. + const threadListV2Enabled = options.listMode === "threads" && threadListV2Preferred; + const hideSettledOnRecent = AsyncResult.isSuccess(preferencesResult) + ? resolveHideSettledOnRecent(preferencesResult.value) + : true; + const hideSettledOnProjects = AsyncResult.isSuccess(preferencesResult) + ? resolveHideSettledOnProjects(preferencesResult.value) + : false; + const hideSettledThreads = + options.threadGrouping === "project" ? hideSettledOnProjects : hideSettledOnRecent; + const setHideSettledThreads = useCallback( + (hide: boolean) => { + if (options.threadGrouping === "project") { + savePreferences({ hideSettledOnProjects: hide }); + return; + } + savePreferences({ hideSettledOnRecent: hide }); + }, + [options.threadGrouping, savePreferences], + ); + const showFlatThreadList = + options.listMode === "threads" && usesFlatThreadGrouping(options.threadGrouping); + const showProjectThreadList = + options.listMode === "threads" && usesProjectThreadGrouping(options.threadGrouping); const [selectedProjectKey, setSelectedProjectKey] = useState(null); const projectScopes = useMemo( () => buildHomeProjectScopes({ projects, - environmentId: options.selectedEnvironmentId, + selectedEnvironmentIds: options.selectedEnvironmentIds, projectGroupingMode: options.projectGroupingMode, }), - [options.projectGroupingMode, options.selectedEnvironmentId, projects], + [options.projectGroupingMode, options.selectedEnvironmentIds, projects], ); const projectFilterOptions = useMemo( () => @@ -293,14 +352,30 @@ function ThreadNavigationSidebarPane( ); const scopedThreads = useMemo( () => - threadListV2Enabled - ? [] - : selectedProjectRefs === null - ? threads - : threads.filter((thread) => - selectedProjectRefs.has(scopedProjectKey(thread.environmentId, thread.projectId)), + threads.filter( + (thread) => + (selectedProjectRefs === null || + selectedProjectRefs.has(scopedProjectKey(thread.environmentId, thread.projectId))) && + threadMatchesMine({ + claimPersonId: claimPersonIdForEnvironment( + claimPersonIdByEnvironment, + thread.environmentId, + ), + originPersonId: thread.originSource?.personId ?? null, + participantPersonIds: (thread.participantSummaries ?? []).map( + (participant) => participant.personId, ), - [threadListV2Enabled, selectedProjectRefs, threads], + mode: options.ownershipFilter, + relation: options.ownershipRelation, + }), + ), + [ + claimPersonIdByEnvironment, + options.ownershipFilter, + options.ownershipRelation, + selectedProjectRefs, + threads, + ], ); const scopedPendingTasks = useMemo( () => @@ -315,33 +390,53 @@ function ThreadNavigationSidebarPane( ), [threadListV2Enabled, pendingTasks, selectedProjectRefs], ); - const groups = useMemo( + const recentEntries = useMemo( () => - threadListV2Enabled - ? [] - : buildHomeThreadGroups({ + showFlatThreadList && !threadListV2Enabled + ? buildHomeRecentListEntries({ projects: scopedProjects, threads: scopedThreads, - pendingTasks: scopedPendingTasks, - queuedThreadKeys, - environmentId: options.selectedEnvironmentId, + selectedEnvironmentIds: options.selectedEnvironmentIds, + projectRefKeys: selectedProjectRefs, searchQuery: props.searchQuery, - matchedThreadKeys, - projectSortOrder: options.projectSortOrder, - threadSortOrder: options.threadSortOrder, - projectGroupingMode: options.projectGroupingMode, - }), + }) + : [], [ - threadListV2Enabled, - queuedThreadKeys, - matchedThreadKeys, - options, + options.selectedEnvironmentIds, props.searchQuery, - scopedPendingTasks, scopedProjects, scopedThreads, + selectedProjectRefs, + showFlatThreadList, + threadListV2Enabled, ], ); + const recentPendingEntries = useMemo( + () => + showFlatThreadList && !threadListV2Enabled + ? buildHomeRecentPendingEntries({ + pendingTasks: scopedPendingTasks, + selectedEnvironmentIds: options.selectedEnvironmentIds, + projectRefKeys: selectedProjectRefs, + searchQuery: props.searchQuery, + }) + : [], + [ + options.selectedEnvironmentIds, + props.searchQuery, + scopedPendingTasks, + selectedProjectRefs, + showFlatThreadList, + threadListV2Enabled, + ], + ); + const environmentLabelById = useMemo(() => { + const map = new Map(); + for (const connection of Object.values(savedConnectionsById)) { + map.set(connection.environmentId, connection.environmentLabel); + } + return map; + }, [savedConnectionsById]); const [groupDisplayStates, setGroupDisplayStates] = useState< ReadonlyMap >(() => new Map()); @@ -356,17 +451,13 @@ function ThreadNavigationSidebarPane( }); }, []); const hasSearchQuery = props.searchQuery.trim().length > 0; - const listLayout = useMemo( - () => - threadListV2Enabled - ? EMPTY_HOME_LIST_LAYOUT - : buildHomeListLayout({ - groups, - displayStates: groupDisplayStates, - showAllThreads: hasSearchQuery, - }), - [threadListV2Enabled, groups, groupDisplayStates, hasSearchQuery], - ); + const projectCwdByKey = useMemo(() => { + const map = new Map(); + for (const project of projects) { + map.set(scopedProjectKey(project.environmentId, project.id), project.workspaceRoot); + } + return map; + }, [projects]); const projectByKey = useMemo(() => { const map = new Map(); for (const project of projects) { @@ -382,7 +473,7 @@ function ThreadNavigationSidebarPane( const [settledVisibleCount, setSettledVisibleCount] = useState( THREAD_LIST_V2_SETTLED_INITIAL_COUNT, ); - const settledResetKey = `${options.selectedEnvironmentId ?? "all"}:${selectedProjectKey ?? "all"}:${props.searchQuery.trim()}`; + const settledResetKey = `${options.selectedEnvironmentIds.join(",") || "all"}:${selectedProjectKey ?? "all"}:${props.searchQuery.trim()}`; const lastSettledResetKeyRef = useRef(settledResetKey); if (lastSettledResetKeyRef.current !== settledResetKey) { lastSettledResetKeyRef.current = settledResetKey; @@ -405,13 +496,14 @@ function ThreadNavigationSidebarPane( // next wake boundary re-runs the partition with a fresh clock so a woken // thread reappears immediately instead of on the next minute tick. const [snoozeWakeTick, bumpSnoozeWakeTick] = useState(0); + const needsSettlementClock = threadListV2Enabled || options.listMode === "threads"; useEffect(() => { - if (!threadListV2Enabled) return; + if (!needsSettlementClock) return; // Refresh immediately because the mount-time value can be hours old. setNowMinute(new Date().toISOString().slice(0, 16)); const id = setInterval(() => setNowMinute(new Date().toISOString().slice(0, 16)), 60_000); return () => clearInterval(id); - }, [threadListV2Enabled]); + }, [needsSettlementClock]); // Threads on servers without the settlement capability never classify as // settled (the user could neither un-settle nor pin them). const serverConfigs = useAtomValue(environmentServerConfigsAtom); @@ -442,6 +534,178 @@ function ThreadNavigationSidebarPane( } return supported; }, [serverConfigs]); + + const settledThreadKeys = useMemo(() => { + if (options.listMode === "board") { + return new Set(); + } + const keys = new Set(); + for (const thread of scopedThreads) { + if (thread.archivedAt !== null) continue; + if (!settlementEnvironmentIds.has(thread.environmentId)) continue; + if (thread.settledOverride === "settled") { + keys.add(scopedThreadKey(thread.environmentId, thread.id)); + } + } + return keys; + }, [options.listMode, scopedThreads, settlementEnvironmentIds]); + + const threadsForProjectList = useMemo(() => { + if (!hideSettledThreads) return scopedThreads; + return scopedThreads.filter( + (thread) => !settledThreadKeys.has(scopedThreadKey(thread.environmentId, thread.id)), + ); + }, [hideSettledThreads, scopedThreads, settledThreadKeys]); + + // Classic flat/recency: hide-settled → active inbox + settled shelf + // (web classic Recent). Project mode still omits via threadsForProjectList. + const { visibleRecentEntries, classicSettledEntries } = useMemo(() => { + if (!showFlatThreadList) { + return { + visibleRecentEntries: [] as ReadonlyArray<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }>, + classicSettledEntries: [] as ReadonlyArray<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }>, + }; + } + if (!hideSettledThreads) { + return { + visibleRecentEntries: recentEntries.map((entry) => ({ + thread: entry.thread, + projectTitle: entry.project.title, + })), + classicSettledEntries: [] as ReadonlyArray<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }>, + }; + } + const active: Array<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }> = []; + const settled: Array<{ + thread: (typeof recentEntries)[number]["thread"]; + projectTitle: string; + }> = []; + for (const entry of recentEntries) { + const key = scopedThreadKey(entry.thread.environmentId, entry.thread.id); + const row = { thread: entry.thread, projectTitle: entry.project.title }; + if (settledThreadKeys.has(key)) settled.push(row); + else active.push(row); + } + settled.sort((left, right) => { + const leftMs = Date.parse( + left.thread.settledAt ?? left.thread.latestUserMessageAt ?? left.thread.updatedAt ?? "", + ); + const rightMs = Date.parse( + right.thread.settledAt ?? right.thread.latestUserMessageAt ?? right.thread.updatedAt ?? "", + ); + const safeLeft = Number.isNaN(leftMs) ? 0 : leftMs; + const safeRight = Number.isNaN(rightMs) ? 0 : rightMs; + return safeRight - safeLeft || left.thread.id.localeCompare(right.thread.id); + }); + return { visibleRecentEntries: active, classicSettledEntries: settled }; + }, [hideSettledThreads, recentEntries, settledThreadKeys, showFlatThreadList]); + + const classicSettledHiddenCount = Math.max(0, classicSettledEntries.length - settledVisibleCount); + const pagedClassicSettledEntries = useMemo( + () => classicSettledEntries.slice(0, settledVisibleCount), + [classicSettledEntries, settledVisibleCount], + ); + + const groups = useMemo( + () => + showProjectThreadList && !threadListV2Enabled + ? buildHomeThreadGroups({ + projects: scopedProjects, + threads: threadsForProjectList, + pendingTasks: scopedPendingTasks, + selectedEnvironmentIds: options.selectedEnvironmentIds, + searchQuery: props.searchQuery, + matchedThreadKeys, + projectSortOrder: options.projectSortOrder, + threadSortOrder: options.threadSortOrder, + projectGroupingMode: options.projectGroupingMode, + }) + : [], + [ + matchedThreadKeys, + options, + props.searchQuery, + scopedPendingTasks, + scopedProjects, + showProjectThreadList, + threadListV2Enabled, + threadsForProjectList, + ], + ); + + const listLayout = useMemo(() => { + if (threadListV2Enabled) { + return EMPTY_HOME_LIST_LAYOUT; + } + if (showFlatThreadList) { + const activeLayout = buildHomeRecentListLayout({ + pendingTasks: recentPendingEntries.map((entry) => entry.pendingTask), + entries: visibleRecentEntries, + groupByRecency: options.threadGrouping === "recency", + }); + if (pagedClassicSettledEntries.length === 0) { + return activeLayout; + } + const items: HomeListItem[] = activeLayout.items.map((item, index) => { + if (index !== activeLayout.items.length - 1) return item; + if (item.type === "thread") return { ...item, isLast: false }; + if (item.type === "pending-task") return { ...item, isLast: false }; + return item; + }); + const stickyHeaderIndices = [...activeLayout.stickyHeaderIndices]; + stickyHeaderIndices.push(items.length); + items.push({ + type: "section-header", + key: "section:settled-shelf", + title: "Settled", + isFirst: items.length === 0, + }); + for (const [index, entry] of pagedClassicSettledEntries.entries()) { + items.push({ + type: "thread", + key: `thread:${entry.thread.environmentId}:${entry.thread.id}`, + thread: entry.thread, + projectTitle: entry.projectTitle, + isLast: + index === pagedClassicSettledEntries.length - 1 && classicSettledHiddenCount === 0, + }); + } + return { items, stickyHeaderIndices }; + } + if (!showProjectThreadList) { + return { items: [] as HomeListItem[], stickyHeaderIndices: [] as number[] }; + } + return buildHomeListLayout({ + groups, + displayStates: groupDisplayStates, + showAllThreads: hasSearchQuery, + }); + }, [ + classicSettledHiddenCount, + groupDisplayStates, + groups, + hasSearchQuery, + options.threadGrouping, + pagedClassicSettledEntries, + recentPendingEntries, + showFlatThreadList, + showProjectThreadList, + threadListV2Enabled, + visibleRecentEntries, + ]); + const pinReorderEnvironmentIds = useMemo(() => { const supported = new Set(); for (const [environmentId, config] of serverConfigs) { @@ -526,11 +790,14 @@ function ThreadNavigationSidebarPane( settledShelfHeaderIndex: null, nextSnoozeWakeAt: null, }; + // Always partition settled into the slim tail (web V2 / classic Recent + // shelf). Hide-settled must not erase that history on mobile. return buildThreadListV2Items({ pendingOrder, - threads: threads.filter((thread) => thread.archivedAt === null), - environmentId: options.selectedEnvironmentId, + threads: scopedThreads.filter((thread) => thread.archivedAt === null), + selectedEnvironmentIds: options.selectedEnvironmentIds, projectRefs: selectedProjectScope === null ? null : selectedProjectScope.projectRefs, + orderByRecency: options.threadGrouping === "recency", searchQuery: props.searchQuery, matchedThreadKeys, settlementEnvironmentIds, @@ -547,17 +814,17 @@ function ThreadNavigationSidebarPane( queuedThreadKeys, nowMinute, snoozeWakeTick, - snoozedShelfExpanded, - settledShelfExpanded, - props.selectedThreadKey, - options.selectedEnvironmentId, + options.selectedEnvironmentIds, + options.threadGrouping, props.searchQuery, - matchedThreadKeys, settledVisibleCount, settlementEnvironmentIds, snoozeEnvironmentIds, + snoozedShelfExpanded, + settledShelfExpanded, + props.selectedThreadKey, threadListV2Enabled, - threads, + scopedThreads, selectedProjectScope, ]); // Re-partition the moment the earliest snooze expires (clamped to the @@ -575,7 +842,17 @@ function ThreadNavigationSidebarPane( // range) the boundary string is identical and the chain would die. }, [nextSnoozeWakeAt, snoozeWakeTick]); const listItems = useMemo(() => { - if (!threadListV2Enabled) return listLayout.items; + if (!threadListV2Enabled) { + if (classicSettledHiddenCount <= 0) return listLayout.items; + return [ + ...listLayout.items, + { + type: "v2-show-more" as const, + key: "classic-settled-show-more", + hiddenCount: classicSettledHiddenCount, + }, + ]; + } // Queued offline tasks are not thread shells, so the v2 item builder // never sees them; the shared splice puts them below the active block // (mirrors the compact Home v2 list) where they stay visible and @@ -584,8 +861,7 @@ function ThreadNavigationSidebarPane( const v2SearchQuery = props.searchQuery.trim().toLocaleLowerCase(); const v2PendingTasks = pendingTasks.filter( (pendingTask) => - (options.selectedEnvironmentId === null || - pendingTask.environmentId === options.selectedEnvironmentId) && + matchesEnvironmentFilter(pendingTask.environmentId, options.selectedEnvironmentIds) && (selectedProjectRefs === null || selectedProjectRefs.has( scopedProjectKey(pendingTask.environmentId, pendingTask.projectId), @@ -603,8 +879,9 @@ function ThreadNavigationSidebarPane( settledShelfExpanded, settledShelfHeaderIndex: threadListV2Layout.settledShelfHeaderIndex, snoozeLabelNow: `${nowMinute}:00.000Z`, + groupByRecency: options.threadGrouping === "recency", }); - if (settledShelfExpanded && threadListV2Layout.hiddenSettledCount > 0) { + if (threadListV2Layout.hiddenSettledCount > 0) { items.push({ type: "v2-show-more", key: "v2-show-more", @@ -613,17 +890,20 @@ function ThreadNavigationSidebarPane( } return items; }, [ + classicSettledHiddenCount, listLayout.items, - nowMinute, - options.selectedEnvironmentId, + options.selectedEnvironmentIds, + options.threadGrouping, pendingTasks, props.searchQuery, selectedProjectRefs, - settledShelfExpanded, - snoozedShelfExpanded, threadListV2Enabled, threadListV2Layout, + nowMinute, + settledShelfExpanded, + snoozedShelfExpanded, ]); + const listOrganization = showProjectThreadList && !threadListV2Enabled; const listMenuActions = useMemo( () => [ { @@ -634,19 +914,20 @@ function ThreadNavigationSidebarPane( id: "environment:all", title: "All environments", subtitle: "Show threads from every environment", - state: options.selectedEnvironmentId === null ? "on" : "off", + state: options.selectedEnvironmentIds.length === 0 ? "on" : "off", }, ...environments.map((environment) => ({ id: `environment:${environment.environmentId}`, title: environment.label, state: - options.selectedEnvironmentId === environment.environmentId + options.selectedEnvironmentIds.length === 0 || + options.selectedEnvironmentIds.includes(environment.environmentId) ? ("on" as const) : ("off" as const), })), ], }, - ...(projectFilterOptions.length === 0 + ...(projectFilterOptions.length === 0 || options.listMode === "board" ? [] : ([ { @@ -667,12 +948,28 @@ function ThreadNavigationSidebarPane( ], }, ] satisfies MenuAction[])), - // v2 lays the list out in fixed creation order — offering sort/group - // controls it silently ignores would be a lie. Environment still - // scopes the v2 partition, so it stays. - ...(threadListV2Enabled - ? [] - : ([ + ...(options.listMode === "threads" + ? ([ + { + id: "grouping", + title: "Group threads", + subactions: HOME_THREAD_GROUPINGS.map((grouping) => ({ + id: `grouping:${grouping}`, + title: HOME_THREAD_GROUPING_LABELS[grouping], + state: options.threadGrouping === grouping ? ("on" as const) : ("off" as const), + })), + }, + { + id: "hide-settled", + title: "Hide settled", + state: hideSettledThreads ? ("on" as const) : ("off" as const), + }, + ] satisfies MenuAction[]) + : []), + // Sort controls only apply in project classic layout. v2/recency/flat/Board + // use fixed order; environment multi-filter still scopes every mode. + ...(listOrganization + ? ([ { id: "project-sort", title: "Sort projects", @@ -691,22 +988,45 @@ function ThreadNavigationSidebarPane( state: options.threadSortOrder === option.value ? "on" : "off", })), }, - ] satisfies MenuAction[])), + ] satisfies MenuAction[]) + : []), + ], + [ + environments, + hideSettledThreads, + listOrganization, + options.listMode, + options.projectSortOrder, + options.selectedEnvironmentIds, + options.threadGrouping, + options.threadSortOrder, + projectFilterOptions, + selectedProjectKey, ], - [environments, options, projectFilterOptions, selectedProjectKey, threadListV2Enabled], ); const handleListMenuAction = useCallback( ({ nativeEvent }: { readonly nativeEvent: { readonly event: string } }) => { const event = nativeEvent.event; if (event === "environment:all") { - setSelectedEnvironmentId(null); + clearSelectedEnvironments(); return; } if (event.startsWith("environment:")) { const environment = environments.find( (candidate) => String(candidate.environmentId) === event.slice("environment:".length), ); - if (environment) setSelectedEnvironmentId(environment.environmentId); + if (environment) toggleSelectedEnvironmentId(environment.environmentId); + return; + } + if (event === "hide-settled") { + setHideSettledThreads(!hideSettledThreads); + return; + } + if (event.startsWith("grouping:")) { + const grouping = event.slice("grouping:".length); + if (grouping === "recency" || grouping === "project" || grouping === "none") { + setThreadGrouping(grouping); + } return; } if (event === "project:all") { @@ -736,11 +1056,15 @@ function ThreadNavigationSidebarPane( } }, [ + clearSelectedEnvironments, environments, + hideSettledThreads, projectFilterOptions, + setHideSettledThreads, setProjectSortOrder, - setSelectedEnvironmentId, + setThreadGrouping, setThreadSortOrder, + toggleSelectedEnvironmentId, ], ); @@ -785,20 +1109,18 @@ function ThreadNavigationSidebarPane( () => ({ selectedThreadKey: props.selectedThreadKey ?? "", projectByKey, + projectCwdByKey, projectTitleByProjectKey, savedConnectionsById, serverConfigs, - snoozePresetMinute: nowMinute, - threadSearchMatchByKey, }), [ props.selectedThreadKey, projectByKey, + projectCwdByKey, projectTitleByProjectKey, savedConnectionsById, serverConfigs, - nowMinute, - threadSearchMatchByKey, ], ); const sidebarItemsAreEqual = useCallback( @@ -828,17 +1150,22 @@ function ThreadNavigationSidebarPane( if (previous.type === "v2-settled-shelf" && item.type === "v2-settled-shelf") { return previous.count === item.count && previous.expanded === item.expanded; } + if (previous.type === "v2-recency-header" && item.type === "v2-recency-header") { + return previous.key === item.key && previous.label === item.label; + } if ( previous.type === "v2-thread" || previous.type === "v2-show-more" || previous.type === "v2-pending" || previous.type === "v2-snoozed-shelf" || previous.type === "v2-settled-shelf" || + previous.type === "v2-recency-header" || item.type === "v2-thread" || item.type === "v2-show-more" || item.type === "v2-pending" || item.type === "v2-snoozed-shelf" || - item.type === "v2-settled-shelf" + item.type === "v2-settled-shelf" || + item.type === "v2-recency-header" ) { return false; } @@ -949,12 +1276,19 @@ function ThreadNavigationSidebarPane( onPinThread={pinThread} onUnpinThread={unpinThread} onMoveThread={moveThread} + projectCwd={projectCwdByKey.get(scopeKey) ?? null} onSwipeableClose={handleSwipeableClose} onSwipeableWillOpen={handleSwipeableWillOpen} simultaneousSwipeGesture={sidebarScrollGesture} /> ); } + case "v2-recency-header": + return ( + + {item.label} + + ); case "v2-snoozed-shelf": return ( ); + case "section-header": + return ; case "pending-task": return ( 1 || showFlatThreadList + ? (savedConnectionsById[thread.environmentId]?.environmentLabel ?? null) + : null } environmentMachine={machineByEnvironmentId.get(thread.environmentId)} + projectCwd={ + projectCwdByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)) ?? + null + } isLast={item.isLast} searchMatch={threadSearchMatchByKey.get( threadSearchMatchKey({ @@ -1041,10 +1385,14 @@ function ThreadNavigationSidebarPane( }), )} searchQuery={props.searchQuery} - selected={ - scopedThreadKey(thread.environmentId, thread.id) === props.selectedThreadKey - } + selected={threadKey === props.selectedThreadKey} fullSwipeWidth={props.width - 20} + settlementSupported={settlementEnvironmentIds.has(thread.environmentId)} + isSettled={settledThreadKeys.has(threadKey)} + onSettleThread={(target) => { + void settleThread(target); + }} + onUnsettleThread={unsettleThread} onArchiveThread={archiveThread} onDeleteThread={confirmDeleteThread} onRegenerateThreadTitle={regenerateThreadTitle} @@ -1066,6 +1414,8 @@ function ThreadNavigationSidebarPane( onGroupAction={updateGroupDisplay} /> ); + default: + return null; } }, [ @@ -1087,11 +1437,13 @@ function ThreadNavigationSidebarPane( pinThread, pinningEnvironmentIds, projectByKey, + projectCwdByKey, projectTitleByProjectKey, regenerateThreadTitle, props.onNewThreadInProject, props.onNewThreadOnBranch, props.searchQuery, + showFlatThreadList, props.selectedThreadKey, props.width, savedConnectionsById, @@ -1101,6 +1453,7 @@ function ThreadNavigationSidebarPane( titleRegenerationEnvironmentIds, settleThread, settlementEnvironmentIds, + settledThreadKeys, showMoreSettled, sidebarScrollGesture, snoozeEnvironmentIds, @@ -1109,16 +1462,22 @@ function ThreadNavigationSidebarPane( toggleSettledShelf, toggleSnoozedShelf, unpinThread, + threadSearchMatchByKey, unsettleThread, - unsnoozeThread, updateGroupDisplay, ], ); - // v2 ignores the sort/group options, so only the environment filter can - // light the "customized" state while the beta is on. - const filterCustomized = threadListV2Enabled - ? options.selectedEnvironmentId !== null || selectedProjectKey !== null - : hasCustomHomeListOptions({ ...options, selectedProjectKey }); + // Outside project classic layout only env/project/grouping filters can + // light the "customized" state (sort options are hidden). + const filterCustomized = + options.selectedEnvironmentIds.length > 0 || + options.ownershipFilter !== DEFAULT_OWNERSHIP_FILTER || + options.ownershipRelation !== "both" || + selectedProjectKey !== null || + options.threadGrouping !== "project" || + (options.listMode === "threads" && + hideSettledThreads !== (options.threadGrouping !== "project")) || + (listOrganization && hasCustomHomeListOptions({ ...options, selectedProjectKey })); const filterIcon = filterCustomized ? "line.3.horizontal.decrease.circle.fill" : "line.3.horizontal.decrease.circle"; @@ -1127,49 +1486,103 @@ function ThreadNavigationSidebarPane( buildHomeListFilterMenu({ environments, projects: projectFilterOptions, - selectedEnvironmentId: options.selectedEnvironmentId, + selectedEnvironmentIds: options.selectedEnvironmentIds, selectedProjectKey, + ownershipFilter: options.ownershipFilter, + ownershipRelation: options.ownershipRelation, projectSortOrder: options.projectSortOrder, threadSortOrder: options.threadSortOrder, - onEnvironmentChange: setSelectedEnvironmentId, + onClearEnvironments: clearSelectedEnvironments, + onToggleEnvironment: toggleSelectedEnvironmentId, onProjectChange: setSelectedProjectKey, + onOwnershipFilterChange: setOwnershipFilter, + onOwnershipRelationChange: setOwnershipRelation, onProjectSortOrderChange: setProjectSortOrder, onThreadSortOrderChange: setThreadSortOrder, - listOrganization: !threadListV2Enabled, + listOrganization, + showProjectFilter: options.listMode !== "board", + threadGrouping: options.listMode === "threads" ? options.threadGrouping : undefined, + onThreadGroupingChange: options.listMode === "threads" ? setThreadGrouping : undefined, + ...(options.listMode === "threads" + ? { + hideSettledThreads, + onHideSettledThreadsChange: setHideSettledThreads, + } + : {}), }), [ + clearSelectedEnvironments, environments, - options, + hideSettledThreads, + listOrganization, + options.listMode, + options.ownershipFilter, + options.ownershipRelation, + options.projectSortOrder, + options.selectedEnvironmentIds, + options.threadGrouping, + options.threadSortOrder, projectFilterOptions, selectedProjectKey, + setHideSettledThreads, + setOwnershipFilter, + setOwnershipRelation, setProjectSortOrder, - setSelectedEnvironmentId, + setThreadGrouping, setThreadSortOrder, - threadListV2Enabled, + toggleSelectedEnvironmentId, ], ); + const boardContent = + options.listMode === "board" ? ( + + ) : null; const nativeHeaderItems = useMemo( () => createSidebarHeaderItems({ filterIcon, filterMenu, + listMode: options.listMode, + onListModeChange: setListMode, onOpenSettings: props.onOpenSettings, }), - [filterIcon, filterMenu, props.onOpenSettings], + [filterIcon, filterMenu, options.listMode, props.onOpenSettings, setListMode], ); - // Snoozed threads need no special case: the shelf header is a list row - // even while collapsed. + // "No threads yet" over an inbox that is merely all-snoozed reads as + // data loss; name the snoozed threads instead. + const snoozedCount = threadListV2Layout.snoozedCount; const listEmpty = ( {catalogState.isLoadingConnections ? "Loading threads…" : props.searchQuery.trim().length > 0 - ? threadSearch.isPending - ? "Searching thread messages…" + ? snoozedCount > 0 + ? // Snoozed matches passed this same search filter — "No + // matching threads" would misreport them as nonexistent. + snoozedCount === 1 + ? "1 matching thread snoozed" + : "All matching threads snoozed" : "No matching threads" - : selectedProjectScope !== null - ? `No threads in ${selectedProjectScope.title}` - : "No threads yet"} + : snoozedCount > 0 + ? snoozedCount === 1 + ? "1 thread snoozed" + : `${snoozedCount} threads snoozed` + : selectedProjectScope !== null + ? `No threads in ${selectedProjectScope.title}` + : "No threads yet"} ); @@ -1177,38 +1590,132 @@ function ThreadNavigationSidebarPane( return ( <> + {HOME_LIST_MODE_TITLES[options.listMode]} + + ), }), - headerSearchBarOptions: { - ref: searchBarRef, - autoCapitalize: "none", - hideNavigationBar: false, - // Keep the search bar pinned under the title — UIKit's default - // hidesSearchBarWhenScrolling collapses it on scroll. - hideWhenScrolling: false, - obscureBackground: false, - placeholder: "Search", - placement: "stacked", - onCancelButtonPress: () => { - props.onSearchQueryChange(""); - }, - onChangeText: (event) => { - props.onSearchQueryChange(event.nativeEvent.text); - }, - }, + // Board columns are not one UIKit-inset scroll view — solid bar + // so cards never underlap the glass nav (same as Board route / home). + ...(NATIVE_LIQUID_GLASS_SUPPORTED + ? options.listMode === "board" + ? { + headerTransparent: false, + headerStyle: { + backgroundColor: backgroundColor as unknown as string, + }, + scrollEdgeEffects: undefined, + } + : { + headerTransparent: true, + headerStyle: { backgroundColor: "transparent" }, + } + : {}), + headerSearchBarOptions: + options.listMode === "board" + ? undefined + : { + ref: searchBarRef, + autoCapitalize: "none", + hideNavigationBar: false, + // Keep the search bar pinned under the title — UIKit's default + // hidesSearchBarWhenScrolling collapses it on scroll. + hideWhenScrolling: false, + obscureBackground: false, + placeholder: "Search", + placement: "stacked", + onCancelButtonPress: () => { + props.onSearchQueryChange(""); + }, + onChangeText: (event) => { + props.onSearchQueryChange(event.nativeEvent.text); + }, + }, unstable_headerRightItems: () => nativeHeaderItems, }} /> + {boardContent !== null ? ( + boardContent + ) : ( + + + item.type} + itemsAreEqual={sidebarItemsAreEqual} + keyExtractor={(item) => item.key} + renderItem={renderListItem} + automaticallyAdjustsScrollIndicatorInsets={NATIVE_LIQUID_GLASS_SUPPORTED} + contentInsetAdjustmentBehavior={ + NATIVE_LIQUID_GLASS_SUPPORTED ? "automatic" : "never" + } + contentContainerStyle={[ + styles.threadListContent, + { + paddingBottom: Math.max(insets.bottom, 16) + 16, + paddingTop: 6, + }, + ]} + keyboardDismissMode="on-drag" + keyboardShouldPersistTaps="handled" + {...scrollGateHandlers} + recycleItems + scrollEventThrottle={16} + showsVerticalScrollIndicator={false} + style={styles.threadList} + ListEmptyComponent={listEmpty} + /> + + + )} + + + ); + } + + return ( + + + {boardContent !== null ? ( + + {boardContent} + + ) : ( item.key} renderItem={renderListItem} - automaticallyAdjustsScrollIndicatorInsets={NATIVE_LIQUID_GLASS_SUPPORTED} - contentInsetAdjustmentBehavior={ - NATIVE_LIQUID_GLASS_SUPPORTED ? "automatic" : "never" - } contentContainerStyle={[ styles.threadListContent, materialYouStyleLayoutActive ? { paddingHorizontal: 0 } : null, { - paddingBottom: Math.max(insets.bottom, 16) + 16, - paddingTop: 6, + paddingBottom: + Platform.OS === "android" + ? Math.max(insets.bottom, 16) + 88 - insets.bottom + : 16 + insets.bottom, + paddingTop: materialYouStyleLayoutActive ? 6 : topListInset, }, ]} keyboardDismissMode="on-drag" @@ -1243,65 +1749,7 @@ function ThreadNavigationSidebarPane( /> - - - ); - } - - return ( - - - - - item.type} - itemsAreEqual={sidebarItemsAreEqual} - keyExtractor={(item) => item.key} - renderItem={renderListItem} - contentContainerStyle={[ - styles.threadListContent, - materialYouStyleLayoutActive ? { paddingHorizontal: 0 } : null, - { - paddingBottom: - Platform.OS === "android" - ? Math.max(insets.bottom, 16) + 88 - insets.bottom - : 16 + insets.bottom, - paddingTop: materialYouStyleLayoutActive ? 6 : topListInset, - }, - ]} - keyboardDismissMode="on-drag" - keyboardShouldPersistTaps="handled" - {...scrollGateHandlers} - recycleItems - scrollEventThrottle={16} - showsVerticalScrollIndicator={false} - style={styles.threadList} - ListEmptyComponent={listEmpty} - /> - - + )} {/* Title slot doubles as the connection status surface: while an - environment reconnects, the brand fades to a status label in - place (no layout shift in the list below). */} + environment reconnects, the title fades to a status label in + place (no layout shift in the list below). Upstream's brand is + the literal "Threads"; this fork's large title tracks list mode, + so it is passed through rather than hardcoded. */} - - + + {HOME_LIST_MODE_TITLES[options.listMode]} + } /> - + - - - - {materialYouStyleLayoutActive && props.searchQuery.length > 0 ? ( - props.onSearchQueryChange("")} - > - - - ) : null} - + > + + + {materialYouStyleLayoutActive && props.searchQuery.length > 0 ? ( + props.onSearchQueryChange("")} + > + + + ) : null} + + )} ); diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx index 0ff42a077b04..bf9cf3c99927 100644 --- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx +++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx @@ -346,6 +346,24 @@ function ThreadRouteContent( [knownTerminalSessions, selectedThreadProject?.workspaceRoot], ); const selectedThreadDetailWorktreePath = selectedThreadDetail?.worktreePath ?? null; + const handleStartNewThread = useCallback(() => { + if (!selectedThread || !selectedThreadProject) return; + const worktreePath = resolvePreferredThreadWorktreePath({ + threadShellWorktreePath: selectedThread.worktreePath ?? null, + threadDetailWorktreePath: selectedThreadDetailWorktreePath, + }); + navigation.navigate("NewTaskSheet", { + screen: "NewTaskDraft", + params: { + environmentId: String(selectedThread.environmentId), + projectId: String(selectedThread.projectId), + title: selectedThreadProject.title, + workspaceMode: "local", + branch: selectedThread.branch ?? undefined, + worktreePath: worktreePath ?? undefined, + }, + }); + }, [navigation, selectedThread, selectedThreadDetailWorktreePath, selectedThreadProject]); const handleReconnectEnvironment = useCallback(() => { if (!environmentId) { return; @@ -837,22 +855,25 @@ function ThreadRouteContent( }); const serverConfig = routeEnvironmentRuntime?.serverConfig ?? null; const renderThreadRouteBody = (showActionControls: boolean) => ( - <> + // A real flex host (not a fragment) keeps the thread body filling the + // screen so the absolute composer overlay anchors to the true bottom. + - + ); return ( diff --git a/apps/mobile/src/features/threads/floating-working-control.tsx b/apps/mobile/src/features/threads/floating-working-control.tsx index 89cf39e89e39..f898fabc96c6 100644 --- a/apps/mobile/src/features/threads/floating-working-control.tsx +++ b/apps/mobile/src/features/threads/floating-working-control.tsx @@ -64,6 +64,7 @@ export function FloatingWorkingControl(props: { readonly colorScheme: "light" | "dark"; readonly status: FloatingWorkingStatus | null; readonly showScrollToEnd: boolean; + readonly hasUnreadActivity?: boolean; readonly onScrollToEnd: () => void; }) { const { width: windowWidth } = useWindowDimensions(); @@ -181,7 +182,11 @@ export function FloatingWorkingControl(props: { style={arrowTransformStyle} > - + @@ -202,7 +207,9 @@ export function FloatingWorkingControl(props: { style={[arrowTransformStyle, arrowContentStyle]} > - + ) : ( void }) { +function ScrollToEndButton(props: { + readonly disabled?: boolean; + readonly hasUnreadActivity?: boolean; + readonly onPress: () => void; +}) { return ( void; + readonly listMode: HomeListMode; + readonly onListModeChange: (mode: HomeListMode) => void; } function FallbackHeaderButton(props: { readonly accessibilityLabel: string; - readonly icon: "gearshape" | "square.and.pencil"; + readonly icon: string; readonly onPress: () => void; }) { return ( @@ -19,7 +28,7 @@ function FallbackHeaderButton(props: { onPress={props.onPress} > + {alternateModes.map((mode) => ( + props.onListModeChange(mode)} + /> + ))} void; readonly onOpenSettings: () => void; }): NativeStackHeaderItem[] { + const alternateModes = otherHomeListModes(input.listMode); return [ withNativeGlassHeaderItem({ type: "menu", @@ -52,6 +60,15 @@ export function createSidebarHeaderItems(input: { items: toNativeHeaderMenuItems(input.filterMenu.items), }, }), + ...alternateModes.map((mode) => + withNativeGlassHeaderItem({ + type: "button" as const, + label: "", + accessibilityLabel: HOME_LIST_MODE_LABELS[mode], + icon: sfSymbolIcon(HOME_LIST_MODE_ICONS[mode]), + onPress: () => input.onListModeChange(mode), + }), + ), withNativeGlassHeaderItem({ type: "button", label: "", diff --git a/apps/mobile/src/features/threads/sidebar-navigation-shell.tsx b/apps/mobile/src/features/threads/sidebar-navigation-shell.tsx index e9e204e47770..5860b505ce10 100644 --- a/apps/mobile/src/features/threads/sidebar-navigation-shell.tsx +++ b/apps/mobile/src/features/threads/sidebar-navigation-shell.tsx @@ -6,7 +6,6 @@ import { import type { ReactNode } from "react"; import { Platform } from "react-native"; -import { getCompactBrandHeaderOptions } from "../../components/CompactBrandTitle"; import { NATIVE_LIQUID_GLASS_SUPPORTED } from "../../native/native-glass"; import { nativeHeaderScrollEdgeEffects } from "../../native/StackHeader"; import { useMobileNavigationTheme } from "../../lib/useMobileNavigationTheme"; @@ -32,9 +31,10 @@ const SIDEBAR_SCREEN_OPTIONS: SidebarScreenOptions = { headerShadowVisible: false, headerShown: true, headerStyle: NATIVE_LIQUID_GLASS_SUPPORTED ? { backgroundColor: "transparent" } : undefined, - ...getCompactBrandHeaderOptions({ fontSize: 18, fontWeight: "800" }), + headerTitleStyle: { fontSize: 18, fontWeight: "800" }, headerTransparent: NATIVE_LIQUID_GLASS_SUPPORTED, scrollEdgeEffects: NATIVE_LIQUID_GLASS_SUPPORTED ? SCROLL_EDGE_EFFECTS : undefined, + title: "Threads", unstable_navigationItemStyle: NATIVE_LIQUID_GLASS_SUPPORTED ? "editor" : undefined, }; diff --git a/apps/mobile/src/features/threads/thread-list-items.tsx b/apps/mobile/src/features/threads/thread-list-items.tsx index cad6181e9623..c704ff5ce492 100644 --- a/apps/mobile/src/features/threads/thread-list-items.tsx +++ b/apps/mobile/src/features/threads/thread-list-items.tsx @@ -17,19 +17,31 @@ import { AppText as Text } from "../../components/AppText"; import { ControlPillMenu } from "../../components/ControlPill"; import { EnvironmentMachineSymbol } from "../../components/EnvironmentMachineSymbol"; import { ProjectFavicon } from "../../components/ProjectFavicon"; +import { ProviderUsageIcon } from "../../components/ProviderUsageIcon"; import { cn } from "../../lib/cn"; -import { HOME_HORIZONTAL_INSET } from "../../lib/layoutMetrics"; import { relativeTime } from "../../lib/time"; import { themeColorWithAlpha } from "../../lib/mobileTheme"; import { useUniwindTheme } from "../../lib/useUniwindTheme"; +import { useEnvironmentServerConfig } from "../../state/entities"; +import { scopedThreadKey } from "../../lib/scopedEntities"; +import { prefetchEnvironmentThread } from "../../state/threads"; +import { useAiUsageSnapshot } from "../../state/useAiUsageSnapshot"; import type { PendingNewTask } from "../../state/use-pending-new-tasks"; import { useThreadPr, type ThreadPrPresentation } from "../../state/use-thread-pr"; +import { composerDraftsAtom, hasComposerDraftMessage } from "../../state/use-composer-drafts"; import type { HomeGroupDisplayAction } from "../home/homeListItems"; import { ThreadSwipeable } from "../home/thread-swipe-actions"; import { buildThreadTitleRegenerationMenuItems } from "./thread-title-regeneration-menu"; +import { ThreadIdentityMark } from "../identity/ParticipantStack"; import { QueuedMessageIcon } from "./queued-message-icon"; -import { resolveThreadStatus } from "./threadPresentation"; +import { resolveSettledRowTimestamp, resolveThreadStatus } from "./threadPresentation"; import { ThreadSearchMatchExcerpt } from "./thread-search-match"; +import { + hasUsageMarker, + resolveDriverUsage, +} from "@t3tools/client-runtime/state/aiUsagePresentation"; +import type { ProviderDriverKind } from "@t3tools/contracts"; +import { useAtomValue } from "@effect/atom-react"; /** * Shared presentation for the thread lists: the compact (phone) Home list and @@ -40,9 +52,15 @@ import { ThreadSearchMatchExcerpt } from "./thread-search-match"; export type ThreadListVariant = "compact" | "sidebar"; /** Left inset that aligns compact secondary rows with the title column. */ -export const THREAD_LIST_COMPACT_INSET = HOME_HORIZONTAL_INSET; +export const THREAD_LIST_COMPACT_INSET = 20; const SIDEBAR_ROW_RADIUS = 12; +const MONO_FONT = Platform.select({ + ios: "Menlo", + android: "monospace", + default: "monospace", +}); + function pullRequestTintColor( pr: Pick, colorScheme: "light" | "dark", @@ -86,6 +104,39 @@ function PullRequestIcon(props: { readonly size: number; readonly color: string ); } +/* ─── Section header (Needs attention) ───────────────────────────────── */ + +/** + * Non-collapsible section label for the cross-project Needs attention block. + */ +export const ThreadListSectionHeader = memo(function ThreadListSectionHeader(props: { + readonly variant: ThreadListVariant; + readonly title: string; +}) { + const compact = props.variant === "compact"; + return ( + + + {props.title} + + + ); +}); + /* ─── Project group header ───────────────────────────────────────────── */ export const ThreadListGroupHeader = memo(function ThreadListGroupHeader(props: { @@ -200,20 +251,32 @@ export const ThreadListShowMoreRow = memo(function ThreadListShowMoreRow(props: readonly variant: ThreadListVariant; readonly hiddenCount: number; readonly canShowLess: boolean; - readonly groupKey: string; - readonly onGroupAction: (key: string, action: HomeGroupDisplayAction) => void; + /** When set with `onGroupAction`, show-more / show-less dispatch group actions. */ + readonly groupKey?: string; + readonly onGroupAction?: (key: string, action: HomeGroupDisplayAction) => void; + /** + * Binary expand/collapse for Needs attention (preview ↔ all). When provided, + * overrides group-key based actions. + */ + readonly onToggleExpanded?: () => void; }) { const showsMore = props.hiddenCount > 0; const compact = props.variant === "compact"; - const { groupKey, onGroupAction } = props; - const handleShowMore = useCallback( - () => onGroupAction(groupKey, "show-more"), - [groupKey, onGroupAction], - ); - const handleShowLess = useCallback( - () => onGroupAction(groupKey, "show-less"), - [groupKey, onGroupAction], - ); + const { groupKey, onGroupAction, onToggleExpanded } = props; + const handleShowMore = useCallback(() => { + if (onToggleExpanded) { + onToggleExpanded(); + return; + } + if (groupKey && onGroupAction) onGroupAction(groupKey, "show-more"); + }, [groupKey, onGroupAction, onToggleExpanded]); + const handleShowLess = useCallback(() => { + if (onToggleExpanded) { + onToggleExpanded(); + return; + } + if (groupKey && onGroupAction) onGroupAction(groupKey, "show-less"); + }, [groupKey, onGroupAction, onToggleExpanded]); const button = (label: string, icon: "chevron.down" | "chevron.up", onPress: () => void) => ( void; readonly onArchiveThread: (thread: EnvironmentThreadShell) => void; readonly onDeleteThread: (thread: EnvironmentThreadShell) => void; + /** When set with settlementSupported, long-press can settle/unsettle. */ + readonly settlementSupported?: boolean; + readonly isSettled?: boolean; + readonly onSettleThread?: (thread: EnvironmentThreadShell) => void; + readonly onUnsettleThread?: (thread: EnvironmentThreadShell) => void; readonly onNewThreadOnBranch: (thread: EnvironmentThreadShell) => void; readonly onRegenerateThreadTitle: (thread: EnvironmentThreadShell) => void; readonly titleRegenerationSupported: boolean; @@ -490,14 +591,23 @@ export const ThreadListRow = memo(function ThreadListRow(props: { onSelectThread, onArchiveThread, onDeleteThread, + onSettleThread, + onUnsettleThread, onRegenerateThreadTitle, onNewThreadOnBranch, } = props; + const settlementSupported = props.settlementSupported === true; + const isSettled = props.isSettled === true; const status = resolveThreadStatus(thread); - const pr = useThreadPr(thread); + const threadKey = scopedThreadKey(thread.environmentId, thread.id); + const composerDrafts = useAtomValue(composerDraftsAtom); + const hasDraft = hasComposerDraftMessage(composerDrafts[threadKey]); + const pr = useThreadPr(thread, props.projectCwd); const timestamp = relativeTime( thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt, ); + // Settled rows label by when the work ENDED, matching the shelf sort. + const settledTimestamp = relativeTime(resolveSettledRowTimestamp(thread)); const threadAccessibilityLabel = [ thread.title, pr?.accessibilityLabel, @@ -505,10 +615,30 @@ export const ThreadListRow = memo(function ThreadListRow(props: { ] .filter(Boolean) .join(", "); - const subtitleParts = [props.environmentLabel, thread.branch].filter((part): part is string => - Boolean(part), + const subtitleParts = [props.projectTitle, props.environmentLabel, thread.branch].filter( + (part): part is string => Boolean(part), ); + const serverConfig = useEnvironmentServerConfig(thread.environmentId); + const aiUsageSnapshot = useAiUsageSnapshot(thread.environmentId); + const threadUsage = useMemo(() => { + if (!serverConfig) return null; + const providerEntry = serverConfig.providers.find( + (p) => p.instanceId === thread.modelSelection.instanceId, + ); + if (!providerEntry) return null; + return resolveDriverUsage( + aiUsageSnapshot, + providerEntry.driver as ProviderDriverKind, + thread.modelSelection.model, + ); + }, [serverConfig, aiUsageSnapshot, thread.modelSelection]); + const showUsageDot = threadUsage ? hasUsageMarker(threadUsage.marker) : false; + const providerDriverForIcon = serverConfig + ? (serverConfig.providers.find((p) => p.instanceId === thread.modelSelection.instanceId) + ?.driver ?? null) + : null; + const backgroundColor = compact ? screenColor : drawerColor; const effectiveSelectedBackground = materialYouStyleLayoutActive ? materialSelectedBackgroundColor @@ -534,31 +664,12 @@ export const ThreadListRow = memo(function ThreadListRow(props: { const handleDelete = useCallback(() => onDeleteThread(thread), [onDeleteThread, thread]); const handleArchive = useCallback(() => onArchiveThread(thread), [onArchiveThread, thread]); + const handleSettle = useCallback(() => onSettleThread?.(thread), [onSettleThread, thread]); + const handleUnsettle = useCallback(() => onUnsettleThread?.(thread), [onUnsettleThread, thread]); const handleRegenerateTitle = useCallback( () => onRegenerateThreadTitle(thread), [onRegenerateThreadTitle, thread], ); - const menuActions = useMemo( - () => [ - ...(thread.branch - ? [ - { - id: "new-thread-on-branch", - title: - Platform.OS === "ios" ? "New thread on branch" : `New thread on ${thread.branch}`, - image: "square.and.pencil", - }, - ] - : []), - THREAD_ROW_MENU_ACTIONS[0]!, - ...buildThreadTitleRegenerationMenuItems({ - supported: props.titleRegenerationSupported, - isRegenerating: thread.titleRegeneration != null, - }), - THREAD_ROW_MENU_ACTIONS[1]!, - ], - [props.titleRegenerationSupported, thread.branch, thread.titleRegeneration], - ); const primaryAction = useMemo( () => ({ accessibilityLabel: `Archive ${thread.title}`, @@ -568,14 +679,52 @@ export const ThreadListRow = memo(function ThreadListRow(props: { }), [handleArchive, thread.title], ); + const menuActions = useMemo( + () => + buildThreadRowMenuActions({ + settlementSupported, + isSettled, + newThreadOnBranch: thread.branch + ? [ + { + id: "new-thread-on-branch", + title: + Platform.OS === "ios" ? "New thread on branch" : `New thread on ${thread.branch}`, + image: "square.and.pencil", + }, + ] + : [], + titleRegeneration: buildThreadTitleRegenerationMenuItems({ + supported: props.titleRegenerationSupported, + isRegenerating: thread.titleRegeneration != null, + }), + }), + [ + isSettled, + props.titleRegenerationSupported, + settlementSupported, + thread.branch, + thread.titleRegeneration, + ], + ); const handleMenuAction = useCallback( ({ nativeEvent }: { readonly nativeEvent: { readonly event: string } }) => { if (nativeEvent.event === "new-thread-on-branch") onNewThreadOnBranch(thread); + if (nativeEvent.event === "settle") handleSettle(); + if (nativeEvent.event === "unsettle") handleUnsettle(); if (nativeEvent.event === "archive") handleArchive(); if (nativeEvent.event === "regenerate-title") handleRegenerateTitle(); if (nativeEvent.event === "delete") handleDelete(); }, - [handleArchive, handleDelete, handleRegenerateTitle, onNewThreadOnBranch, thread], + [ + handleArchive, + handleDelete, + handleRegenerateTitle, + handleSettle, + handleUnsettle, + onNewThreadOnBranch, + thread, + ], ); const statusPill = effectiveStatus ? ( @@ -663,13 +812,119 @@ export const ThreadListRow = memo(function ThreadListRow(props: { ) : null; + // Project-grouped lists already show a favicon in the group header, so the + // slim row only leads with one where it also carries project context + // (recency / flat / Needs attention) — the same rule the subtitle uses. + const showSettledFavicon = Boolean(props.projectTitle) && props.projectCwd !== null; + + /** + * Settled threads are history, not inbox: they collapse to a single dimmed + * line so the active work above stays scannable. Status pill, subtitle, + * PR badge, provider icon and chevron all drop — a settled row is a title, + * a time, and a way back in. Matches the Thread List v2 settled tail + * (thread-list-v2-items.tsx) and web's settled shelf (Sidebar.tsx), so + * settled history reads the same in every list mode on every client. + */ + const settledRowContent = (close: () => void) => ( + setHovered(true)} + onHoverOut={compact ? undefined : () => setHovered(false)} + onPressIn={() => { + prefetchEnvironmentThread(thread.environmentId, thread.id); + }} + onPress={() => { + close(); + onSelectThread(thread); + }} + style={ + compact + ? ({ pressed }) => ({ opacity: pressed ? 0.7 : 1 }) + : ({ pressed }) => ({ + backgroundColor: selected + ? selectedBackgroundColor + : pressed || hovered + ? effectivePressedBackground + : backgroundColor, + borderRadius: SIDEBAR_ROW_RADIUS, + cursor: "pointer", + }) + } + > + + {showSettledFavicon ? ( + + + + ) : null} + + + + {thread.title} + + {hasDraft ? ( + + ) : null} + + {props.searchMatch ? ( + + ) : null} + + + {settledTimestamp} + + + + ); + const rowContent = (close: () => void) => - compact ? ( + isSettled ? ( + settledRowContent(close) + ) : compact ? ( { + prefetchEnvironmentThread(thread.environmentId, thread.id); + }} style={ materialYouStyleLayoutActive ? { @@ -686,19 +941,39 @@ export const ThreadListRow = memo(function ThreadListRow(props: { - - {thread.title} - + + {providerDriverForIcon ? ( + + ) : null} + + {thread.title} + + + {hasDraft ? ( + + ) : null} + {props.hasQueuedMessages ? ( @@ -744,6 +1019,9 @@ export const ThreadListRow = memo(function ThreadListRow(props: { accessibilityState={{ selected }} onHoverIn={() => setHovered(true)} onHoverOut={() => setHovered(false)} + onPressIn={() => { + prefetchEnvironmentThread(thread.environmentId, thread.id); + }} onPress={() => { close(); onSelectThread(thread); @@ -764,19 +1042,39 @@ export const ThreadListRow = memo(function ThreadListRow(props: { > - - {thread.title} - + + {providerDriverForIcon ? ( + + ) : null} + + {thread.title} + + + {hasDraft ? ( + + ) : null} + {props.hasQueuedMessages ? ( diff --git a/apps/mobile/src/features/threads/thread-list-v2-items.tsx b/apps/mobile/src/features/threads/thread-list-v2-items.tsx index a234147471c6..46f6ac2dc15d 100644 --- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx +++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx @@ -1,4 +1,3 @@ -import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; import { appAtomRegistry } from "../../state/atom-registry"; import { threadArrangementOpenAtom } from "../../state/thread-order"; import type { ThreadMoveDestination } from "./threadOrder"; @@ -27,7 +26,12 @@ import { relativeTime } from "../../lib/time"; import { useUniwindTheme } from "../../lib/useUniwindTheme"; import type { PendingNewTask } from "../../state/use-pending-new-tasks"; import { useThreadPr } from "../../state/use-thread-pr"; +import { prefetchEnvironmentThread } from "../../state/threads"; +import { composerDraftsAtom, hasComposerDraftMessage } from "../../state/use-composer-drafts"; +import { scopedThreadKey } from "../../lib/scopedEntities"; import { ThreadSwipeable } from "../home/thread-swipe-actions"; +import { ThreadIdentityMark } from "../identity/ParticipantStack"; +import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; import { buildThreadTitleRegenerationMenuItems } from "./thread-title-regeneration-menu"; import { resolveThreadListV2SnoozeMenuSelection, @@ -38,6 +42,7 @@ import { } from "./threadListV2"; import { QueuedMessageIcon } from "./queued-message-icon"; import { ThreadSearchMatchExcerpt } from "./thread-search-match"; +import { useAtomValue } from "@effect/atom-react"; /** * Thread List v2 renders one flat native list: rich edge-to-edge rows for @@ -408,6 +413,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { readonly canMoveDown?: boolean; readonly onSwipeableWillOpen: (methods: SwipeableMethods) => void; readonly onSwipeableClose: (methods: SwipeableMethods) => void; + readonly projectCwd?: string | null; readonly searchMatch?: EnvironmentThreadSearchMatch; readonly searchQuery?: string; readonly simultaneousSwipeGesture?: ComponentProps< @@ -434,7 +440,10 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { const snoozedRow = props.snoozed === true; const pinnedRow = props.pinned === true; - const pr = useThreadPr(thread); + const pr = useThreadPr(thread, props.projectCwd ?? props.project?.workspaceRoot ?? null); + const threadKey = scopedThreadKey(thread.environmentId, thread.id); + const composerDrafts = useAtomValue(composerDraftsAtom); + const hasDraft = hasComposerDraftMessage(composerDrafts[threadKey]); const { materialYouStyleLayoutActive } = useAppearancePreferences(); const theme = useUniwindTheme(); @@ -765,19 +774,32 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { {statusLabel?.label ?? timeLabel} - - {thread.title} - + + + {thread.title} + + + {hasDraft ? ( + + ) : null} + {props.searchMatch ? ( { + prefetchEnvironmentThread(thread.environmentId, thread.id); + }} onPress={() => { close(); onSelectThread(thread); @@ -973,6 +998,9 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { accessibilityRole="button" accessibilityState={{ selected }} className={sidebarPane || materialYouStyleLayoutActive ? undefined : "bg-screen"} + onPressIn={() => { + prefetchEnvironmentThread(thread.environmentId, thread.id); + }} onPress={() => { close(); onSelectThread(thread); @@ -1011,19 +1039,33 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { ) : null} - - {thread.title} - + + + {thread.title} + + + {hasDraft ? ( + + ) : null} + {props.searchMatch ? ( { }); describe("buildThreadListV2Items", () => { + it("keeps upstream order by default and changes only card ordering for recency", () => { + const threads = [ + makeThread({ + id: ThreadId.make("newer-created"), + title: "Newer created", + createdAt: "2026-06-01T12:00:00.000Z", + latestUserMessageAt: "2026-06-01T13:00:00.000Z", + }), + makeThread({ + id: ThreadId.make("older-created-more-recent"), + title: "Older created, more recent", + createdAt: "2026-06-01T08:00:00.000Z", + latestUserMessageAt: "2026-06-01T18:00:00.000Z", + }), + ]; + + const defaultOrder = buildThreadListV2Items({ threads, searchQuery: "", now: NOW }); + const recency = buildThreadListV2Items({ + threads, + searchQuery: "", + now: NOW, + orderByRecency: true, + }); + + expect(defaultOrder.items.map((item) => item.thread.id)).toEqual([ + "newer-created", + "older-created-more-recent", + ]); + expect(recency.items.map((item) => item.thread.id)).toEqual([ + "older-created-more-recent", + "newer-created", + ]); + expect( + recency.items.map(({ variant, pinned, snoozed }) => ({ variant, pinned, snoozed })), + ).toEqual( + defaultOrder.items.map(({ variant, pinned, snoozed }) => ({ variant, pinned, snoozed })), + ); + }); + it("places a persisted settled thread in the settled shelf", () => { const thread = makeThread({ id: ThreadId.make("linked-merged"), @@ -1012,6 +1051,69 @@ describe("buildThreadListV2ListItems", () => { ]); }); + it("adds recency headers to unpinned active and settled sections; pins stay above", () => { + const now = "2026-06-02T12:00:00.000Z"; + const groupedLayout = buildThreadListV2Items({ + threads: [ + makeThread({ + id: ThreadId.make("pinned"), + title: "pinned", + pinnedAt: now, + latestUserMessageAt: "2026-05-20T10:00:00.000Z", + }), + makeThread({ + id: ThreadId.make("active-recent"), + title: "active recent", + latestUserMessageAt: "2026-06-02T11:30:00.000Z", + }), + makeThread({ + id: ThreadId.make("active-yesterday"), + title: "active yesterday", + latestUserMessageAt: "2026-06-01T10:00:00.000Z", + }), + makeThread({ + id: ThreadId.make("settled-recent"), + title: "settled recent", + settledOverride: "settled", + settledAt: now, + latestUserMessageAt: "2026-06-02T11:15:00.000Z", + }), + makeThread({ + id: ThreadId.make("settled-yesterday"), + title: "settled yesterday", + settledOverride: "settled", + settledAt: now, + latestUserMessageAt: "2026-06-01T09:00:00.000Z", + }), + ], + environmentId: null, + searchQuery: "", + now, + orderByRecency: true, + }); + const items = buildThreadListV2ListItems({ + items: groupedLayout.items, + pendingTasks: [], + settledCount: groupedLayout.settledCount, + settledShelfHeaderIndex: groupedLayout.settledShelfHeaderIndex, + groupByRecency: true, + snoozeLabelNow: now, + }); + + expect(items.map((item) => item.key)).toEqual([ + `v2-thread:${environmentId}:pinned`, + "v2-recency-header:active:last_hour", + `v2-thread:${environmentId}:active-recent`, + "v2-recency-header:active:yesterday", + `v2-thread:${environmentId}:active-yesterday`, + "v2-settled-shelf", + "v2-recency-header:settled:last_hour", + `v2-thread:${environmentId}:settled-recent`, + "v2-recency-header:settled:yesterday", + `v2-thread:${environmentId}:settled-yesterday`, + ]); + }); + it("places queued tasks before a collapsed snoozed shelf", () => { const snoozedLayout = buildThreadListV2Items({ threads: [ diff --git a/apps/mobile/src/features/threads/threadListV2.ts b/apps/mobile/src/features/threads/threadListV2.ts index e1cb8e9ece7f..3e5f8fcf850f 100644 --- a/apps/mobile/src/features/threads/threadListV2.ts +++ b/apps/mobile/src/features/threads/threadListV2.ts @@ -9,12 +9,17 @@ import { import type { SnoozePreset } from "@t3tools/client-runtime/state/thread-settled"; import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; import { threadSearchMatchKey } from "@t3tools/client-runtime/state/thread-search"; +import { + groupSortedThreadsByRecency, + shouldShowRecencySectionHeaders, +} from "@t3tools/client-runtime/state/thread-recency-groups"; import { sortActiveThreadsByOrderKey, resolveSettledThreadTimestamp, sortPinnedThreadsByOrderKey, } from "@t3tools/client-runtime/state/thread-sort"; import type { EnvironmentId, ProjectId } from "@t3tools/contracts"; +import { threadMatchesAttributeQuery } from "@t3tools/shared/threadAttributeSearch"; import type { PendingNewTask } from "../../state/use-pending-new-tasks"; @@ -157,6 +162,17 @@ function parseTimestampMs(isoDate: string): number { return Number.isNaN(parsed) ? 0 : parsed; } +/** First VALID timestamp wins: a present-yet-malformed string falls through + to the next candidate rather than sinking the row to the epoch. */ +function firstValidTimestampMs(...candidates: ReadonlyArray): number { + for (const candidate of candidates) { + if (candidate == null) continue; + const parsed = Date.parse(candidate); + if (!Number.isNaN(parsed)) return parsed; + } + return 0; +} + /** The active order shared by web and native: new/reopened rows, then the saved arrangement. Activity does not move a thread. */ export function sortThreadsForListV2< @@ -268,11 +284,19 @@ export interface ThreadListV2SettledShelfListItem { readonly expanded: boolean; } +export interface ThreadListV2RecencyHeaderListItem { + readonly type: "v2-recency-header"; + readonly key: string; + readonly label: string; + readonly section: "active" | "settled"; +} + export type ThreadListV2ListItem = | ThreadListV2ThreadListItem | ThreadListV2PendingListItem | ThreadListV2SnoozedShelfListItem - | ThreadListV2SettledShelfListItem; + | ThreadListV2SettledShelfListItem + | ThreadListV2RecencyHeaderListItem; /** * Builds the shared mobile order: active → pending → snoozed shelf → settled. @@ -289,16 +313,21 @@ export function buildThreadListV2ListItems(input: { readonly settledShelfExpanded?: boolean; readonly settledShelfHeaderIndex?: number | null; readonly snoozeLabelNow?: string; + /** Adds activity buckets inside active and settled sections. Pinned cards + remain above the active buckets. */ + readonly groupByRecency?: boolean; }): ThreadListV2ListItem[] { - const threadItems = input.items.map((item): ThreadListV2ListItem => ({ - type: "v2-thread", - key: `v2-thread:${item.thread.environmentId}:${item.thread.id}`, - item, - snoozeWakeLabelText: - item.snoozed && item.thread.snoozedUntil != null && input.snoozeLabelNow !== undefined - ? snoozeWakeLabel(item.thread.snoozedUntil, { now: input.snoozeLabelNow }) - : undefined, - })); + const threadItems: ThreadListV2ThreadListItem[] = input.items.map( + (item): ThreadListV2ThreadListItem => ({ + type: "v2-thread", + key: `v2-thread:${item.thread.environmentId}:${item.thread.id}`, + item, + snoozeWakeLabelText: + item.snoozed && item.thread.snoozedUntil != null && input.snoozeLabelNow !== undefined + ? snoozeWakeLabel(item.thread.snoozedUntil, { now: input.snoozeLabelNow }) + : undefined, + }), + ); const pendingItems = input.pendingTasks.map((pendingTask, index): ThreadListV2ListItem => ({ type: "v2-pending", key: `v2-${pendingTask.key}`, @@ -311,7 +340,41 @@ export function buildThreadListV2ListItems(input: { const settledShelfHeaderIndex = input.settledShelfHeaderIndex ?? null; const activeEnd = snoozedShelfHeaderIndex ?? settledShelfHeaderIndex ?? threadItems.length; const snoozedEnd = settledShelfHeaderIndex ?? threadItems.length; - const result: ThreadListV2ListItem[] = [...threadItems.slice(0, activeEnd), ...pendingItems]; + const addRecencyHeaders = ( + items: ReadonlyArray, + section: "active" | "settled", + ): ThreadListV2ListItem[] => { + if (input.groupByRecency !== true) return [...items]; + const groups = groupSortedThreadsByRecency( + items.map((item) => item.item.thread), + input.snoozeLabelNow === undefined ? undefined : new Date(input.snoozeLabelNow), + ); + if (!shouldShowRecencySectionHeaders(groups)) return [...items]; + const itemByKey = new Map( + items.map((item) => [`${item.item.thread.environmentId}:${item.item.thread.id}`, item]), + ); + return groups.flatMap((group) => [ + { + type: "v2-recency-header" as const, + key: `v2-recency-header:${section}:${group.id}`, + label: group.label, + section, + }, + ...group.threads.flatMap((thread) => { + const item = itemByKey.get(`${thread.environmentId}:${thread.id}`); + return item === undefined ? [] : [item]; + }), + ]); + }; + const activeItems = threadItems.slice(0, activeEnd); + const pinnedEnd = activeItems.findIndex((item) => !item.item.pinned); + const pinnedItems = pinnedEnd < 0 ? activeItems : activeItems.slice(0, pinnedEnd); + const unpinnedActiveItems = pinnedEnd < 0 ? [] : activeItems.slice(pinnedEnd); + const result: ThreadListV2ListItem[] = [ + ...pinnedItems, + ...addRecencyHeaders(unpinnedActiveItems, "active"), + ...pendingItems, + ]; if (snoozedShelfHeaderIndex !== null && snoozedCount > 0) { result.push({ type: "v2-snoozed-shelf", @@ -328,23 +391,35 @@ export function buildThreadListV2ListItems(input: { count: settledCount, expanded: input.settledShelfExpanded !== false, }); - result.push(...threadItems.slice(settledShelfHeaderIndex)); + result.push(...addRecencyHeaders(threadItems.slice(settledShelfHeaderIndex), "settled")); } return result; } /** * Partitions visible threads into the active card block (saved order) and - * the settled recency tail, matching the web v2 list. + * the settled recency tail, matching the web Sidebar V2 list (and classic + * Recent hide-settled shelf: history is shelved, never dropped). Callers must + * not pass settledLimit: 0 to emulate "hide settled" — use paging only. + * The server stamps settledOverride for the tail. */ export function buildThreadListV2Items(input: { readonly pendingOrder?: PendingThreadOrder | null; readonly threads: ReadonlyArray; - readonly environmentId: EnvironmentId | null; + /** + * Multi-select environment filter. Empty = all environments. + * Prefer this over the legacy single-id field. + */ + readonly selectedEnvironmentIds?: readonly EnvironmentId[]; + /** @deprecated Use selectedEnvironmentIds. Kept for call-site migration. */ + readonly environmentId?: EnvironmentId | null; readonly projectRefs?: ReadonlyArray<{ readonly environmentId: EnvironmentId; readonly projectId: ProjectId; }> | null; + /** Default/false preserves upstream creation order. Recency changes only + active and pinned card order; lifecycle sections and variants stay put. */ + readonly orderByRecency?: boolean; readonly searchQuery: string; readonly matchedThreadKeys?: ReadonlySet; /** Environments whose server supports thread.settle/unsettle. Threads on @@ -383,9 +458,22 @@ export function buildThreadListV2Items(input: { }), ); const query = input.searchQuery.trim().toLocaleLowerCase(); + const selectedEnvironmentIds = + input.selectedEnvironmentIds ?? + (input.environmentId != null && input.environmentId !== undefined ? [input.environmentId] : []); const projectKeys = input.projectRefs ? new Set(input.projectRefs.map((ref) => `${ref.environmentId}:${ref.projectId}`)) : null; + const orderActiveThreads = (threads: ReadonlyArray) => { + const upstreamOrder = sortThreadsForListV2(threads); + if (input.orderByRecency !== true) return upstreamOrder; + return upstreamOrder.sort( + (left, right) => + firstValidTimestampMs(right.latestUserMessageAt, right.updatedAt, right.createdAt) - + firstValidTimestampMs(left.latestUserMessageAt, left.updatedAt, left.createdAt) || + left.id.localeCompare(right.id), + ); + }; const pinned: EnvironmentThreadShell[] = []; const active: EnvironmentThreadShell[] = []; @@ -394,13 +482,26 @@ export function buildThreadListV2Items(input: { let nextSnoozeWakeAt: string | null = null; for (const thread of input.threads) { // Callers pass live shells. The server stamps settledOverride for the tail. - if (input.environmentId !== null && thread.environmentId !== input.environmentId) continue; + if ( + selectedEnvironmentIds.length > 0 && + !selectedEnvironmentIds.includes(thread.environmentId) + ) { + continue; + } if (projectKeys !== null && !projectKeys.has(`${thread.environmentId}:${thread.projectId}`)) { continue; } if ( query.length > 0 && - !thread.title.toLocaleLowerCase().includes(query) && + !threadMatchesAttributeQuery( + { + title: thread.title, + branch: thread.branch, + originSource: thread.originSource ?? null, + participantSummaries: thread.participantSummaries ?? [], + }, + query, + ) && !threadPullRequestSearchTerms(thread).some((term) => term.toLocaleLowerCase().includes(query), ) && @@ -438,7 +539,7 @@ export function buildThreadListV2Items(input: { } } - const orderedActive = applyPendingThreadOrder(sortThreadsForListV2(active), "active", pending); + const orderedActive = applyPendingThreadOrder(orderActiveThreads(active), "active", pending); const orderedSnoozed = [...snoozed].sort( (left, right) => parseTimestampMs(left.snoozedUntil ?? "") - parseTimestampMs(right.snoozedUntil ?? ""), @@ -470,6 +571,8 @@ export function buildThreadListV2Items(input: { ); const items: ThreadListV2Item[] = []; + // Pins carry an explicit user order (#5581); only the unpinned rows follow + // the fork's grouping preference. for (const thread of applyPendingThreadOrder( sortPinnedThreadsByOrderKey(pinned), "pinned", diff --git a/apps/mobile/src/features/threads/threadPresentation.test.ts b/apps/mobile/src/features/threads/threadPresentation.test.ts new file mode 100644 index 000000000000..8e853ae6f4f5 --- /dev/null +++ b/apps/mobile/src/features/threads/threadPresentation.test.ts @@ -0,0 +1,48 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { resolveSettledRowTimestamp } from "./threadPresentation"; + +const base = { + settledAt: null as string | null, + latestUserMessageAt: null as string | null, + updatedAt: "2026-01-01T00:00:00.000Z", + createdAt: "2025-12-01T00:00:00.000Z", +}; + +describe("resolveSettledRowTimestamp", () => { + it("prefers the explicit settle stamp", () => { + expect( + resolveSettledRowTimestamp({ + ...base, + settledAt: "2026-02-02T00:00:00.000Z", + latestUserMessageAt: "2026-01-15T00:00:00.000Z", + }), + ).toBe("2026-02-02T00:00:00.000Z"); + }); + + it("falls back to last user activity for auto-settled threads", () => { + expect( + resolveSettledRowTimestamp({ ...base, latestUserMessageAt: "2026-01-15T00:00:00.000Z" }), + ).toBe("2026-01-15T00:00:00.000Z"); + }); + + it("falls back to updatedAt when the thread has no user message", () => { + expect(resolveSettledRowTimestamp(base)).toBe("2026-01-01T00:00:00.000Z"); + }); + + it("orders rows the same way the settled shelf sorts them", () => { + // The shelf sorts by settledAt ?? latestUserMessageAt ?? updatedAt, so a + // freshly settled old thread must label ahead of a stale newer one. + const settledRecently = { + ...base, + settledAt: "2026-03-01T00:00:00.000Z", + latestUserMessageAt: "2025-06-01T00:00:00.000Z", + }; + const touchedRecently = { ...base, latestUserMessageAt: "2026-02-01T00:00:00.000Z" }; + + expect( + Date.parse(resolveSettledRowTimestamp(settledRecently)) > + Date.parse(resolveSettledRowTimestamp(touchedRecently)), + ).toBe(true); + }); +}); diff --git a/apps/mobile/src/features/threads/threadPresentation.ts b/apps/mobile/src/features/threads/threadPresentation.ts index dcff521342c6..717146555ad3 100644 --- a/apps/mobile/src/features/threads/threadPresentation.ts +++ b/apps/mobile/src/features/threads/threadPresentation.ts @@ -2,6 +2,21 @@ import type { StatusTone } from "../../components/StatusPill"; import type { OrchestrationLatestTurn, OrchestrationSession } from "@t3tools/contracts"; import { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; +/** + * The timestamp a settled row labels by: the settle stamp when the server + * recorded one (explicit settles), otherwise last activity. Mirrors the + * settled-shelf sort in HomeScreen / ThreadNavigationSidebar (and web's + * `resolveSettledTimestamp`) so a shelf reads in the order it is sorted. + */ +export function resolveSettledRowTimestamp( + thread: Pick< + EnvironmentThreadShell, + "settledAt" | "latestUserMessageAt" | "updatedAt" | "createdAt" + >, +): string { + return thread.settledAt ?? thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt; +} + export type ThreadStatusKind = | "pending-approval" | "awaiting-input" @@ -62,6 +77,24 @@ export function resolveThreadStatus( }; } + // Plan Ready outranks Working (same as web) so implement is obvious once a + // plan is captured even if the agent turn has not settled yet. + if ( + thread.interactionMode === "plan" && + thread.hasActionableProposedPlan && + !thread.hasPendingUserInput + ) { + return { + kind: "plan-ready", + label: "Plan Ready", + pillClassName: "bg-adaptive-violet-500-a12-a16", + textClassName: "text-adaptive-violet-700-300", + iconColor: "#bf5af2", + iconBackground: "rgba(191,90,242,0.22)", + pulse: false, + }; + } + if (thread.session?.status === "running") { return { kind: "working", diff --git a/apps/mobile/src/features/usage/usageProviders.ts b/apps/mobile/src/features/usage/usageProviders.ts index 2576ac21fb07..db38f9f0b8f5 100644 --- a/apps/mobile/src/features/usage/usageProviders.ts +++ b/apps/mobile/src/features/usage/usageProviders.ts @@ -5,23 +5,46 @@ import { useAppearancePreferences } from "../settings/appearance/AppearancePrefe * Series and table order. The chart stacks providers from the bottom in this * order, so it also fixes which band sits on top of the bars. */ -export const PROVIDER_ORDER: readonly UsageProviderKind[] = ["codex", "claude", "grok"]; +export const PROVIDER_ORDER = [ + "codex", + "claude", + "grok", + "kimi", +] as const satisfies readonly UsageProviderKind[]; + +/** + * A provider added to `UsageProviderKind` but not to {@link PROVIDER_ORDER} + * would still appear in the summary rows (those come from `merged.providers`) + * while silently vanishing from the daily columns, chart bands, legends and + * skeletons, all of which iterate this order. The `Record` maps below are + * exhaustive by their own type; this makes the order exhaustive too, so the + * omission is a compile error rather than a missing column nobody notices. + */ +type AssertNoUnorderedProvider = T; +export type UsageProviderOrderIsExhaustive = AssertNoUnorderedProvider< + Exclude +>; export const PROVIDER_LABEL: Record = { claude: "Claude Code", codex: "Codex", grok: "Grok Build", + kimi: "Kimi", }; /** - * Claude's brand orange holds in both themes; Codex and Grok are neutrals and - * must flip with the theme or their bars vanish against the matching background. + * Claude's and Kimi's brand oranges hold in both themes; Codex and Grok are + * neutrals and must flip with the theme or their bars vanish against the + * matching background. + */ export function useProviderColors(): Record { const { themeAppearance: scheme } = useAppearancePreferences(); + const dark = scheme === "dark"; return { claude: "#d97757", - codex: scheme === "dark" ? "#e6e6e6" : "#3c3c43", - grok: scheme === "dark" ? "#a1a1aa" : "#52525b", + codex: dark ? "#e6e6e6" : "#3c3c43", + grok: dark ? "#a1a1aa" : "#52525b", + kimi: "#ff6a3d", }; } diff --git a/apps/mobile/src/lib/composerImages.test.ts b/apps/mobile/src/lib/composerImages.test.ts index 40e00a271f76..732595c63623 100644 --- a/apps/mobile/src/lib/composerImages.test.ts +++ b/apps/mobile/src/lib/composerImages.test.ts @@ -3,6 +3,9 @@ import { PROVIDER_SEND_TURN_MAX_ATTACHMENTS } from "@t3tools/contracts"; const files = new Map(); +const requestMediaLibraryPermissionsAsync = vi.fn(); +const launchImageLibraryAsync = vi.fn(); + vi.mock("expo-file-system", () => ({ File: class { readonly uri: string; @@ -32,11 +35,100 @@ vi.mock("expo-file-system", () => ({ }, })); +vi.mock("expo-image-picker", () => ({ + requestMediaLibraryPermissionsAsync, + launchImageLibraryAsync, +})); + vi.mock("./uuid", () => ({ uuidv4: () => "attachment-id", })); -import { convertPastedImagesToAttachments, isOwnedPastedImageUri } from "./composerImages"; +import { + convertPastedImagesToAttachments, + isOwnedPastedImageUri, + pickComposerImages, +} from "./composerImages"; + +describe("pickComposerImages", () => { + beforeEach(() => { + requestMediaLibraryPermissionsAsync.mockReset(); + launchImageLibraryAsync.mockReset(); + }); + + it("opens the system image library without requesting media-library permission", async () => { + launchImageLibraryAsync.mockResolvedValue({ + canceled: false, + assets: [ + { + uri: "file:///tmp/photo.png", + fileName: "photo.png", + mimeType: "image/png", + base64: "aGVsbG8=", + fileSize: 5, + }, + ], + }); + + const result = await pickComposerImages({ existingCount: 0 }); + + expect(requestMediaLibraryPermissionsAsync).not.toHaveBeenCalled(); + expect(launchImageLibraryAsync).toHaveBeenCalledWith( + expect.objectContaining({ + mediaTypes: ["images"], + allowsMultipleSelection: true, + base64: true, + }), + ); + expect(result).toEqual({ + images: [ + expect.objectContaining({ + id: "attachment-id", + type: "image", + name: "photo.png", + mimeType: "image/png", + sizeBytes: 5, + dataUrl: "data:image/png;base64,aGVsbG8=", + previewUri: "file:///tmp/photo.png", + }), + ], + error: null, + }); + }); + + it("returns no images when the user cancels the picker", async () => { + launchImageLibraryAsync.mockResolvedValue({ + canceled: true, + assets: null, + }); + + await expect(pickComposerImages({ existingCount: 0 })).resolves.toEqual({ + images: [], + error: null, + }); + expect(requestMediaLibraryPermissionsAsync).not.toHaveBeenCalled(); + }); + + it("returns a structured error when the image library fails to open", async () => { + launchImageLibraryAsync.mockRejectedValue(new Error("picker unavailable")); + + await expect(pickComposerImages({ existingCount: 0 })).resolves.toEqual({ + images: [], + error: "picker unavailable", + }); + expect(requestMediaLibraryPermissionsAsync).not.toHaveBeenCalled(); + }); + + it("rejects picks when the attachment limit is already full", async () => { + await expect( + pickComposerImages({ existingCount: PROVIDER_SEND_TURN_MAX_ATTACHMENTS }), + ).resolves.toEqual({ + images: [], + error: `You can attach up to ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments per message.`, + }); + expect(launchImageLibraryAsync).not.toHaveBeenCalled(); + }); +}); describe("native pasted image cleanup", () => { beforeEach(() => { diff --git a/apps/mobile/src/lib/composerImages.ts b/apps/mobile/src/lib/composerImages.ts index 16faaedd96c2..6453dbbadb41 100644 --- a/apps/mobile/src/lib/composerImages.ts +++ b/apps/mobile/src/lib/composerImages.ts @@ -317,6 +317,11 @@ export async function pickComposerMedia(input: { }; } + // Do not call requestMediaLibraryPermissionsAsync(). The app ships with + // photosPermission: false (no NSPhotoLibraryUsageDescription), and modern + // system pickers (PHPicker / Android photo picker) do not need library + // access. Requesting permission without a usage string hard-crashes iOS. + // // The picker covers the Android activity, which reports the app as // backgrounded; the guard keeps background-triggered restarts away mid-pick. const endHandoff = beginForegroundHandoff(); @@ -333,7 +338,10 @@ export async function pickComposerMedia(input: { } catch (error) { return { attachments: [], - error: error instanceof Error ? error.message : "Could not open the photo library.", + error: + error instanceof Error + ? error.message + : "Could not open the photo library to attach images.", }; } finally { endHandoff(); diff --git a/apps/mobile/src/lib/markdownNodeKey.test.ts b/apps/mobile/src/lib/markdownNodeKey.test.ts new file mode 100644 index 000000000000..ddc4ea584a8e --- /dev/null +++ b/apps/mobile/src/lib/markdownNodeKey.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from "vite-plus/test"; +import type { MarkdownNode } from "react-native-nitro-markdown/headless"; + +import { + markdownNodeKey, + markdownTableCellKey, + markdownTableRowKey, +} from "../../modules/t3-markdown-text/src/markdownNodeKey"; + +describe("markdownNodeKey", () => { + it("keeps sibling keys unique when beg/end spans collide", () => { + const cell = (index: number): MarkdownNode => + ({ + type: "table_cell", + beg: 0, + end: 0, + children: [{ type: "text", content: `c${index}` }], + }) as MarkdownNode; + + const keys = [0, 1, 2].map((index) => markdownNodeKey(cell(index), index)); + // Never the pre-fix shape `table_cell:0:0` (type:beg:end with shared spans). + expect(keys).toEqual(["table_cell:i0:b0:e0", "table_cell:i1:b0:e0", "table_cell:i2:b0:e0"]); + expect(new Set(keys).size).toBe(3); + expect(keys.some((key) => key === "table_cell:0:0")).toBe(false); + }); + + it("still differs by type and index when spans are missing", () => { + expect(markdownNodeKey({ type: "paragraph" }, 0)).toBe("paragraph:i0:bna:ena"); + expect(markdownNodeKey({ type: "paragraph" }, 1)).toBe("paragraph:i1:bna:ena"); + }); +}); + +describe("markdownTableCellKey", () => { + it("uses row/col coordinates so table grids never collide on parser spans", () => { + expect(markdownTableRowKey(0)).toBe("table:r0"); + expect(markdownTableCellKey(0, 0)).toBe("table:r0:c0"); + expect(markdownTableCellKey(0, 1)).toBe("table:r0:c1"); + expect(markdownTableCellKey(1, 0)).toBe("table:r1:c0"); + expect(new Set([markdownTableCellKey(0, 0), markdownTableCellKey(0, 1)]).size).toBe(2); + }); +}); diff --git a/apps/mobile/src/lib/queuedAttachmentRecall.test.ts b/apps/mobile/src/lib/queuedAttachmentRecall.test.ts new file mode 100644 index 000000000000..eebe4ba7b00b --- /dev/null +++ b/apps/mobile/src/lib/queuedAttachmentRecall.test.ts @@ -0,0 +1,153 @@ +import { PROVIDER_SEND_TURN_MAX_ATTACHMENTS } from "@t3tools/contracts"; +import { describe, expect, it, vi } from "vite-plus/test"; + +// `./uuid` pulls in expo-crypto (and through it react-native), which cannot be +// loaded in this environment; the sibling composer-image test mocks it the same way. +let recalledIdCounter = 0; +vi.mock("./uuid", () => ({ + uuidv4: () => `recalled-${(recalledIdCounter += 1)}`, +})); + +import { + describeQueuedAttachmentCapacity, + formatMissingAttachmentsError, + recallQueuedAttachments, + type QueuedAttachmentRecallDeps, + type RecallableQueuedAttachment, +} from "./queuedAttachmentRecall"; + +const attachment = ( + overrides: Partial = {}, +): RecallableQueuedAttachment => ({ + id: "attachment-1", + name: "screenshot.png", + mimeType: "image/png", + sizeBytes: 4, + ...overrides, +}); + +const deps = (overrides: Partial = {}): QueuedAttachmentRecallDeps => ({ + urlById: new Map([["attachment-1", "https://assets.test/attachment-1"]]), + fetchDataUrl: async () => "data:image/png;base64,cG5nIQ==", + ...overrides, +}); + +describe("recallQueuedAttachments", () => { + it("rebuilds a draft attachment carrying the bytes inline", async () => { + const result = await recallQueuedAttachments([attachment()], deps()); + + expect(result.missing).toEqual([]); + expect(result.images).toHaveLength(1); + const image = result.images[0]!; + expect(image.type).toBe("image"); + expect(image.name).toBe("screenshot.png"); + expect(image.mimeType).toBe("image/png"); + expect(image.sizeBytes).toBe(4); + expect(image.dataUrl).toBe("data:image/png;base64,cG5nIQ=="); + expect(image.previewUri).toBe("data:image/png;base64,cG5nIQ=="); + }); + + it("gives the recalled draft a fresh id so it outlives the removed queue entry", async () => { + const result = await recallQueuedAttachments([attachment()], deps()); + + expect(result.images[0]!.id).not.toBe("attachment-1"); + expect(result.images[0]!.id).toMatch(/^recalled-/); + }); + + it("reads each attachment from its own signed url", async () => { + const requested: string[] = []; + const result = await recallQueuedAttachments( + [attachment(), attachment({ id: "attachment-2", name: "diagram.png" })], + deps({ + urlById: new Map([ + ["attachment-1", "https://assets.test/one"], + ["attachment-2", "https://assets.test/two"], + ]), + fetchDataUrl: async (url: string) => { + requested.push(url); + return "data:image/png;base64,eA=="; + }, + }), + ); + + expect(requested).toEqual(["https://assets.test/one", "https://assets.test/two"]); + expect(result.images.map((image) => image.name)).toEqual(["screenshot.png", "diagram.png"]); + }); + + it("reports an attachment whose url has not resolved instead of dropping it silently", async () => { + const result = await recallQueuedAttachments([attachment()], deps({ urlById: new Map() })); + + expect(result.images).toEqual([]); + expect(result.missing).toEqual(["screenshot.png"]); + }); + + it("keeps the readable attachments when one read fails", async () => { + const result = await recallQueuedAttachments( + [attachment(), attachment({ id: "attachment-2", name: "broken.png" })], + deps({ + urlById: new Map([ + ["attachment-1", "https://assets.test/one"], + ["attachment-2", "https://assets.test/two"], + ]), + fetchDataUrl: async (url: string) => { + if (url.endsWith("two")) throw new Error("gone"); + return "data:image/png;base64,eA=="; + }, + }), + ); + + expect(result.images.map((image) => image.name)).toEqual(["screenshot.png"]); + expect(result.missing).toEqual(["broken.png"]); + }); + + it("returns nothing for a queued message with no attachments", async () => { + const result = await recallQueuedAttachments([], deps()); + + expect(result).toEqual({ images: [], missing: [] }); + }); +}); + +describe("formatMissingAttachmentsError", () => { + it("stays silent when everything was restored", () => { + expect(formatMissingAttachmentsError([])).toBeNull(); + }); + + it("names the single attachment that was left behind", () => { + expect(formatMissingAttachmentsError(["screenshot.png"])).toBe( + "'screenshot.png' could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.", + ); + }); + + it("counts them once several were left behind", () => { + expect(formatMissingAttachmentsError(["a.png", "b.png"])).toBe( + "2 attachments could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.", + ); + }); +}); + +describe("describeQueuedAttachmentCapacity", () => { + it("allows an edit that fits in the composer", () => { + expect(describeQueuedAttachmentCapacity(3, 2)).toBeNull(); + }); + + it("allows an edit that exactly fills the remaining room", () => { + expect(describeQueuedAttachmentCapacity(3, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 3)).toBeNull(); + }); + + it("refuses an edit that would overflow, rather than restoring only some pictures", () => { + const message = describeQueuedAttachmentCapacity(3, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 2); + + expect(message).toContain(`${PROVIDER_SEND_TURN_MAX_ATTACHMENTS}-image limit`); + expect(message).toContain("Remove some images from the composer first."); + }); + + it("says image, singular, for one attachment", () => { + expect(describeQueuedAttachmentCapacity(1, PROVIDER_SEND_TURN_MAX_ATTACHMENTS)).toContain( + "bring back 1 image,", + ); + }); + + it("never blocks a message with no attachments", () => { + expect(describeQueuedAttachmentCapacity(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS)).toBeNull(); + }); +}); diff --git a/apps/mobile/src/lib/queuedAttachmentRecall.ts b/apps/mobile/src/lib/queuedAttachmentRecall.ts new file mode 100644 index 000000000000..755e3b7576ca --- /dev/null +++ b/apps/mobile/src/lib/queuedAttachmentRecall.ts @@ -0,0 +1,125 @@ +import { PROVIDER_SEND_TURN_MAX_ATTACHMENTS } from "@t3tools/contracts"; + +import type { DraftComposerImageAttachment } from "./composerImages"; +import { uuidv4 } from "./uuid"; + +/** + * Rebuilding composer attachments when a server-queued message is edited. + * + * Server-queued attachments carry only `{id, name, mimeType, sizeBytes}`; the + * bytes live on the server. Composer drafts need the bytes inline as a data + * URL, so editing has to read each attachment back through its signed asset + * URL first. Locally-queued (outbox) messages already hold their data URLs and + * skip all of this. + * + * Callers must do this *before* removing the queued message. The removal is + * what makes the edit destructive: once the queued entry is gone, its + * attachment files are pruned server-side and a failed fetch has no second + * chance — so a caller that cannot restore everything must leave the message + * queued rather than remove it. + */ + +export interface RecallableQueuedAttachment { + readonly id: string; + readonly name: string; + readonly mimeType: string; + readonly sizeBytes: number; +} + +export interface QueuedAttachmentRecallResult { + readonly images: ReadonlyArray; + /** Attachments whose bytes could not be read back, by display name. */ + readonly missing: ReadonlyArray; +} + +export interface QueuedAttachmentRecallDeps { + readonly urlById: ReadonlyMap; + readonly fetchDataUrl: (url: string) => Promise; +} + +export const defaultFetchAttachmentDataUrl = async (url: string): Promise => { + const response = await fetch(url); + if (!response.ok) { + throw new Error(`Attachment request failed with status ${response.status}.`); + } + const blob = await response.blob(); + return await new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onerror = () => { + reject(reader.error ?? new Error("Attachment could not be read.")); + }; + reader.onload = () => { + const result = reader.result; + if (typeof result !== "string") { + reject(new Error("Attachment could not be read.")); + return; + } + resolve(result); + }; + reader.readAsDataURL(blob); + }); +}; + +/** + * Fetches every queued attachment back into a composer-ready draft image. Failures + * are collected rather than thrown so the caller sees the whole picture at + * once: because removing the queued message prunes its files, a caller that + * cannot restore everything must abandon the edit rather than restore part. + */ +export async function recallQueuedAttachments( + attachments: ReadonlyArray, + deps: QueuedAttachmentRecallDeps, +): Promise { + const images: DraftComposerImageAttachment[] = []; + const missing: string[] = []; + + for (const attachment of attachments) { + const url = deps.urlById.get(attachment.id); + if (!url) { + missing.push(attachment.name); + continue; + } + try { + const dataUrl = await deps.fetchDataUrl(url); + images.push({ + // A fresh id keeps the recalled draft independent of the queued entry + // that is about to be removed, matching how picked images are staged. + id: uuidv4(), + type: "image", + name: attachment.name, + mimeType: attachment.mimeType, + sizeBytes: attachment.sizeBytes, + dataUrl, + previewUri: dataUrl, + }); + } catch { + missing.push(attachment.name); + } + } + + return { images, missing }; +} + +export function formatMissingAttachmentsError(missing: ReadonlyArray): string | null { + if (missing.length === 0) return null; + return missing.length === 1 + ? `'${missing[0]}' could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.` + : `${missing.length} attachments could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.`; +} + +/** + * Refuses the edit up front when the composer has no room for the queued + * message's pictures. Restoring only some of them would drop the rest for good, + * since removing the queued message deletes its attachment files server-side. + */ +export function describeQueuedAttachmentCapacity( + queuedCount: number, + draftImageCount: number, +): string | null { + if (queuedCount === 0) return null; + const capacity = Math.max(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - draftImageCount); + if (queuedCount <= capacity) return null; + return `Editing this message would bring back ${queuedCount} image${ + queuedCount === 1 ? "" : "s" + }, past the ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS}-image limit. Remove some images from the composer first.`; +} diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.ts index 46a79b70acd2..d348ced6ad9a 100644 --- a/apps/mobile/src/lib/threadActivity.test.ts +++ b/apps/mobile/src/lib/threadActivity.test.ts @@ -17,7 +17,9 @@ import { agentSpawnSummary, buildPendingUserInputAnswers, buildThreadFeed, + deriveQueuedMessageControls, deriveThreadFeedPresentation, + promoteSteeredQueuedMessages, isPendingUserInputOptionSelected, setPendingUserInputCustomAnswer, togglePendingUserInputOptionSelection, @@ -27,6 +29,29 @@ import { type WorkLogEntry, } from "./threadActivity"; +describe("deriveQueuedMessageControls", () => { + it("allows steering or removing server-queued messages", () => { + expect(deriveQueuedMessageControls("queued", "server")).toEqual({ + canSteer: true, + canEdit: true, + }); + }); + + it("allows discarding an offline local-outbox message", () => { + expect(deriveQueuedMessageControls("waiting", "local")).toEqual({ + canSteer: false, + canEdit: true, + }); + }); + + it("does not claim an in-flight local send can still be cancelled", () => { + expect(deriveQueuedMessageControls("sending", "local")).toEqual({ + canSteer: false, + canEdit: false, + }); + }); +}); + const singleSelectQuestion = { id: "runtime", header: "Runtime", @@ -265,6 +290,8 @@ function makeThread( archivedAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -276,6 +303,40 @@ function makeThread( } describe("buildThreadFeed", () => { + it("shows submitted structured answers in the feed", () => { + const thread = makeThread({ + id: ThreadId.make("thread-input"), + projectId: ProjectId.make("project-input"), + title: "Input thread", + activities: [ + makeActivity({ + id: EventId.make("input-requested"), + kind: "user-input.requested", + summary: "User input requested", + createdAt: "2026-04-01T00:00:01.000Z", + payload: { + requestId: "request-1", + questions: [{ id: "goal", header: "Goal", question: "What is the goal?", options: [] }], + }, + }), + makeActivity({ + id: EventId.make("input-resolved"), + kind: "user-input.resolved", + summary: "User input submitted", + createdAt: "2026-04-01T00:00:02.000Z", + payload: { requestId: "request-1", answers: { goal: "Make it sleep" } }, + }), + ], + }); + + const requested = buildThreadFeed(thread) + .filter((entry) => entry.type === "activity-group") + .flatMap((entry) => entry.activities) + .find((entry) => entry.id === "input-requested"); + expect(requested?.detail).toBe("Make it sleep"); + expect(requested?.getFullDetail()).toContain("What is the goal?\nMake it sleep"); + }); + it("reuses unchanged feed and presentation rows during an assistant text update", () => { const completedTurnId = TurnId.make("completed-turn"); const activeTurnId = TurnId.make("active-turn"); @@ -1833,6 +1894,113 @@ describe("buildThreadFeed", () => { expect(collapsed[1]).toMatchObject({ type: "turn-fold", label: "Worked for 17s" }); }); + it("keeps a queue-drain final assistant answer below the fold when turnId is mis-stamped", () => { + // Mirrors production: previous turn's final lands with the *next* turn's id + // at the same timestamp as the queued user message (see Fix Mobile Thread + // Selection Hangs / turn 15c01839 vs segment:10). + const firstTurnId = TurnId.make("turn-1"); + const secondTurnId = TurnId.make("turn-2"); + const thread = makeThread({ + id: ThreadId.make("thread-queue-drain-fold"), + projectId: ProjectId.make("project-1"), + title: "Queue drain fold", + latestTurn: { + turnId: secondTurnId, + state: "completed", + requestedAt: "2026-04-01T00:00:20.000Z", + startedAt: "2026-04-01T00:00:20.000Z", + completedAt: "2026-04-01T00:00:30.000Z", + assistantMessageId: MessageId.make("assistant-next-final"), + }, + messages: [ + { + id: MessageId.make("user-1"), + role: "user", + text: "Change the icons.", + turnId: null, + streaming: false, + createdAt: "2026-04-01T00:00:00.000Z", + updatedAt: "2026-04-01T00:00:00.000Z", + }, + { + id: MessageId.make("assistant-status"), + role: "assistant", + text: "Replacing the segment bar…", + turnId: firstTurnId, + streaming: false, + createdAt: "2026-04-01T00:00:05.000Z", + updatedAt: "2026-04-01T00:00:05.000Z", + }, + { + id: MessageId.make("assistant-final-misstamped"), + role: "assistant", + text: "Done. No more segment bar.", + // Wrong: stamped with the next turn at drain time. + turnId: secondTurnId, + streaming: false, + createdAt: "2026-04-01T00:00:20.000Z", + updatedAt: "2026-04-01T00:00:20.000Z", + }, + { + id: MessageId.make("user-2"), + role: "user", + text: "Why is the queue in the timeline?", + turnId: null, + streaming: false, + createdAt: "2026-04-01T00:00:20.000Z", + updatedAt: "2026-04-01T00:00:20.000Z", + }, + { + id: MessageId.make("assistant-next-final"), + role: "assistant", + text: "Because we used bubbles.", + turnId: secondTurnId, + streaming: false, + createdAt: "2026-04-01T00:00:28.000Z", + updatedAt: "2026-04-01T00:00:30.000Z", + }, + ], + activities: [ + makeActivity({ + id: EventId.make("tool-1"), + kind: "tool.completed", + tone: "tool", + summary: "Changed files", + createdAt: "2026-04-01T00:00:10.000Z", + turnId: firstTurnId, + payload: { + title: "Changed files", + itemType: "file_change", + status: "completed", + }, + }), + ], + }); + + const feed = buildThreadFeed(thread); + const collapsed = deriveThreadFeedPresentation(feed, thread.latestTurn, new Set()); + const ids = collapsed.map((entry) => entry.id); + // Rehome keeps the mis-stamped final on turn-1; first+terminal fold keeps + // the first assistant visible (as the `::pre` preamble split) and hides + // tools in between. + expect(ids).toContain("assistant-status::pre"); + expect(ids).toContain("assistant-final-misstamped"); + expect(ids).toContain("turn-fold:turn-1"); + expect(ids.indexOf("assistant-final-misstamped")).toBeGreaterThan( + ids.indexOf("turn-fold:turn-1"), + ); + expect(ids).not.toContain("tool-1"); + + const expanded = deriveThreadFeedPresentation(feed, thread.latestTurn, new Set([firstTurnId])); + const expandedIds = expanded.map((entry) => entry.id); + expect(expandedIds).toContain("turn-fold:turn-1"); + expect(expandedIds.some((id) => id.startsWith("assistant-status"))).toBe(true); + expect(expandedIds).toContain("work-toggle:work-group:tool-1"); + expect(expandedIds).toContain("assistant-final-misstamped"); + expect(expandedIds).toContain("user-2"); + expect(expandedIds).toContain("assistant-next-final"); + }); + it("folds assistant messages between the first and terminal messages", () => { const turnId = TurnId.make("turn-1"); const thread = makeThread({ @@ -2716,6 +2884,71 @@ describe("buildThreadFeed", () => { }); }); +describe("promoteSteeredQueuedMessages", () => { + const steeredId = MessageId.make("msg-steered"); + const waitingId = MessageId.make("msg-waiting"); + + function makeQueuedThread() { + return makeThread({ + id: ThreadId.make("thread-steer"), + projectId: ProjectId.make("project-steer"), + title: "Steer thread", + queuedMessages: [ + { + messageId: steeredId, + text: "send this one now", + attachments: [], + queuedAt: "2026-04-01T00:00:05.000Z", + }, + { + messageId: waitingId, + text: "this one waits", + attachments: [], + queuedAt: "2026-04-01T00:00:06.000Z", + }, + ], + }); + } + + it("moves only the steered message into the conversation", () => { + const promoted = promoteSteeredQueuedMessages(makeQueuedThread(), new Set([steeredId])); + + expect(promoted.messages.map((message) => message.id)).toEqual([steeredId]); + expect(promoted.messages[0]).toMatchObject({ role: "user", text: "send this one now" }); + // Still server-queued until the dispatch lands — chip lists drop it because + // it is now in the timeline, not because the queue changed. + expect(promoted.queuedMessages.map((entry) => entry.messageId)).toEqual([steeredId, waitingId]); + }); + + it("reverts by dropping the id, restoring the queue-only view", () => { + const thread = makeQueuedThread(); + + expect(promoteSteeredQueuedMessages(thread, new Set())).toBe(thread); + expect(promoteSteeredQueuedMessages(thread, new Set([steeredId])).messages).toHaveLength(1); + expect(promoteSteeredQueuedMessages(thread, new Set()).messages).toHaveLength(0); + }); + + it("does not duplicate a message the server has already persisted", () => { + const thread = makeQueuedThread(); + const persisted = { + ...thread, + messages: [ + { + id: steeredId, + role: "user" as const, + text: "send this one now", + turnId: TurnId.make("turn-1"), + streaming: false, + createdAt: "2026-04-01T00:00:07.000Z", + updatedAt: "2026-04-01T00:00:07.000Z", + }, + ], + }; + + expect(promoteSteeredQueuedMessages(persisted, new Set([steeredId])).messages).toHaveLength(1); + }); +}); + describe("quiet timeline: nested agents", () => { it.each(["task.updated", "task.progress"] as const)( "does not mark an ordinary task complete when it resumes through %s", diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.ts index b7d5018edd98..ae98f166ad81 100644 --- a/apps/mobile/src/lib/threadActivity.ts +++ b/apps/mobile/src/lib/threadActivity.ts @@ -7,6 +7,7 @@ import { } from "@t3tools/client-runtime/pending-requests"; import { UserInputAttachmentAnswerPayload, isToolLifecycleItemType } from "@t3tools/contracts"; import type { + MessageId, OrchestrationLatestTurn, OrchestrationThread, OrchestrationThreadActivity, @@ -15,6 +16,12 @@ import type { UserInputQuestion, } from "@t3tools/contracts"; import { formatDuration } from "@t3tools/shared/orchestrationTiming"; +import { + compareSteerTimelineSortable, + findMidTurnSteerUserIds, + splitAssistantTextAtSteers, +} from "@t3tools/shared/steerTimeline"; +import { deriveResolvedUserInputTranscripts } from "@t3tools/shared/userInputTranscript"; import { commandDetailRepeatsCommand, extractCommandOutputText, @@ -39,6 +46,8 @@ import { commandProgramName } from "@t3tools/client-runtime/work-log/command-lab import * as Arr from "effect/Array"; import * as Order from "effect/Order"; +import type { DraftComposerImageAttachment } from "./composerImages"; + export type { PendingApproval, PendingUserInput } from "@t3tools/client-runtime/pending-requests"; export interface PendingUserInputDraftAnswer { @@ -118,6 +127,7 @@ export interface WorkLogEntry { }>; }; toolData?: unknown; + userInputTranscript?: string; } interface DerivedWorkLogEntry extends WorkLogEntry { @@ -138,6 +148,9 @@ type RawThreadFeedEntry = readonly id: string; readonly createdAt: string; readonly message: OrchestrationThread["messages"][number]; + readonly deliveryState?: "waiting" | "sending" | "queued"; + readonly queueSource?: "local" | "server"; + readonly previewAttachments?: ReadonlyArray; } | { readonly type: "activity"; @@ -208,6 +221,57 @@ export type ThreadFeedEntry = readonly summary: AgentSpawnSummary; }; +export function deriveQueuedMessageControls( + deliveryState: "waiting" | "sending" | "queued" | undefined, + queueSource: "local" | "server" | undefined, +): { readonly canSteer: boolean; readonly canEdit: boolean } { + return { + canSteer: deliveryState === "queued" && queueSource === "server", + canEdit: + (deliveryState === "queued" && queueSource === "server") || + (deliveryState === "waiting" && queueSource === "local"), + }; +} + +/** + * Moves messages the user sent now ("Send now") out of the queue and into the + * conversation before the server confirms the dispatch. + * + * The server keeps listing a steered message as queued until its dispatch + * lands, so the promotion happens here rather than waiting: the feed renders it + * as a bubble, and every chip list that skips ids already in the timeline drops + * its chip for free. Dropping the id from `steeringMessageIds` reverts both. + */ +export function promoteSteeredQueuedMessages( + thread: OrchestrationThread, + steeringMessageIds: ReadonlySet, +): OrchestrationThread { + if (steeringMessageIds.size === 0) { + return thread; + } + const alreadyPersisted = new Set(thread.messages.map((message) => message.id)); + const steeredMessages = thread.queuedMessages + .filter( + (queuedMessage) => + steeringMessageIds.has(queuedMessage.messageId) && + !alreadyPersisted.has(queuedMessage.messageId), + ) + .map((queuedMessage) => ({ + id: queuedMessage.messageId, + role: "user" as const, + text: queuedMessage.text, + attachments: queuedMessage.attachments, + turnId: null, + streaming: false, + createdAt: queuedMessage.queuedAt, + updatedAt: queuedMessage.queuedAt, + })); + if (steeredMessages.length === 0) { + return thread; + } + return { ...thread, messages: [...thread.messages, ...steeredMessages] }; +} + export interface AgentSpawnSummary { /** "Locate UNO hand rendering code" for one agent, "3 subagents" for a batch. */ readonly title: string; @@ -226,7 +290,10 @@ export interface AgentSpawnSummary { export type ThreadFeedLatestTurn = Pick< OrchestrationLatestTurn, "turnId" | "state" | "startedAt" | "completedAt" ->; +> & { + /** When set, preferred terminal assistant for this turn (fold visibility). */ + readonly assistantMessageId?: MessageId | null; +}; type ThreadFeedActivityGroup = Extract; @@ -405,6 +472,11 @@ function deriveWorkLogEntries( activities: ReadonlyArray, ): DerivedWorkLogEntry[] { const ordered = Arr.sort(activities, activityOrder); + const resolvedTranscripts = deriveResolvedUserInputTranscripts(activities); + const resolvedUserInputs = new Map(resolvedTranscripts.map((entry) => [entry.activityId, entry])); + const resolvedUserInputsByRequestId = new Map( + resolvedTranscripts.map((entry) => [entry.requestId, entry]), + ); const entries: DerivedWorkLogEntry[] = []; for (const activity of foldUserInputActivities(ordered)) { if (activity.tone !== "error" && isWorktreeSetupActivity(activity.kind)) continue; @@ -421,7 +493,19 @@ function deriveWorkLogEntries( if (isNoContentRuntimeWarning(activity)) continue; if (isPlanBoundaryToolActivity(activity)) continue; if (isAgentInternalActivity(activity)) continue; - entries.push(toDerivedWorkLogEntry(activity)); + const entry = toDerivedWorkLogEntry(activity); + const requestId = + activity.payload && typeof activity.payload === "object" + ? (activity.payload as { requestId?: unknown }).requestId + : undefined; + const resolvedUserInput = + resolvedUserInputs.get(activity.id) ?? + (typeof requestId === "string" ? resolvedUserInputsByRequestId.get(requestId) : undefined); + if (resolvedUserInput) { + entry.detail = resolvedUserInput.preview; + entry.userInputTranscript = resolvedUserInput.detail; + } + entries.push(entry); } return collapseDerivedWorkLogEntries(entries); } @@ -978,6 +1062,7 @@ function buildWorkEntryExpandedBody(entry: WorkLogEntry): string | null { } appendBlock(entry.rawCommand ?? entry.command); appendBlock(entry.detail); + appendBlock(entry.userInputTranscript); if ((entry.changedFiles?.length ?? 0) > 0) { appendBlock(entry.changedFiles!.join("\n")); } @@ -1604,26 +1689,104 @@ interface ThreadFeedTurnFold { readonly label: string; } -function deriveThreadFeedTurnFolds( +interface MutableTurnGroup { + entries: ThreadFeedEntry[]; + startBoundary: string | null; +} + +/** + * When a queued follow-up starts the next turn at the same instant the previous + * turn completes, the final assistant message is often stamped with the *new* + * turn id while `turns.assistant_message_id` still points at it for the old + * turn. That leaves fold logic treating a mid-turn status line as "terminal" + * and burying the real answer. + * + * Re-home: if the first assistant message of turn N is at or before the first + * user message that follows turn N-1, it is a leftover final for turn N-1. + * (Genuine first tokens of turn N always land *after* that user message.) + */ +function rehomeOrphanTurnFinals( feed: ReadonlyArray, + groupsByTurnId: Map, +): void { + const userCreatedAts = feed + .filter( + (entry): entry is Extract => + entry.type === "message" && entry.message.role === "user", + ) + .map((entry) => entry.createdAt); + + const ordered = [...groupsByTurnId.entries()].sort((left, right) => { + const leftAt = left[1].entries[0]?.createdAt ?? left[1].startBoundary ?? ""; + const rightAt = right[1].entries[0]?.createdAt ?? right[1].startBoundary ?? ""; + return leftAt.localeCompare(rightAt); + }); + + for (let index = 1; index < ordered.length; index += 1) { + const previous = ordered[index - 1]; + const current = ordered[index]; + if (!previous || !current) continue; + const [, previousGroup] = previous; + const [, currentGroup] = current; + + const previousLastAt = + previousGroup.entries.at(-1)?.createdAt ?? previousGroup.startBoundary ?? null; + if (previousLastAt === null) continue; + + // First user message at or after the previous turn's last entry — the + // follow-up that opens the next turn (often same ms as the orphan final). + const nextUserAt = userCreatedAts.find((createdAt) => createdAt >= previousLastAt) ?? null; + if (nextUserAt === null) continue; + + const firstAssistantIndex = currentGroup.entries.findIndex( + (entry) => entry.type === "message" && entry.message.role === "assistant", + ); + if (firstAssistantIndex < 0) continue; + const firstAssistant = currentGroup.entries[firstAssistantIndex]; + if (!firstAssistant || firstAssistant.type !== "message") continue; + if (firstAssistant.createdAt > nextUserAt) continue; + + currentGroup.entries.splice(firstAssistantIndex, 1); + previousGroup.entries.push(firstAssistant); + } +} + +function resolveTurnTerminalEntryId( + turnId: TurnId, + entries: ReadonlyArray, latestTurn: ThreadFeedLatestTurn | null, -): ReadonlyMap { - const firstAssistantMessageIdByTurn = new Map(); - const terminalAssistantMessageIdByTurn = new Map(); - for (const entry of feed) { - if (entry.type === "message" && entry.message.role === "assistant" && entry.message.turnId) { - if (!firstAssistantMessageIdByTurn.has(entry.message.turnId)) { - firstAssistantMessageIdByTurn.set(entry.message.turnId, entry.id); - } - terminalAssistantMessageIdByTurn.set(entry.message.turnId, entry.id); +): string | null { + if ( + latestTurn?.turnId === turnId && + latestTurn.assistantMessageId !== null && + latestTurn.assistantMessageId !== undefined + ) { + const preferredId = String(latestTurn.assistantMessageId); + const preferred = entries.find( + (entry) => + entry.type === "message" && + entry.message.role === "assistant" && + (entry.id === preferredId || String(entry.message.id) === preferredId), + ); + if (preferred) { + return preferred.id; } } - interface TurnGroup { - readonly entries: ThreadFeedEntry[]; - readonly startBoundary: string | null; + let lastAssistantId: string | null = null; + for (const entry of entries) { + if (entry.type === "message" && entry.message.role === "assistant") { + lastAssistantId = entry.id; + } } - const groupsByTurnId = new Map(); + return lastAssistantId; +} + +function deriveThreadFeedTurnFolds( + feed: ReadonlyArray, + latestTurn: ThreadFeedLatestTurn | null, +): ReadonlyMap { + const groupsByTurnId = new Map(); let pendingUserBoundary: string | null = null; for (const entry of feed) { if (entry.type === "message" && entry.message.role === "user") { @@ -1651,6 +1814,48 @@ function deriveThreadFeedTurnFolds( group.entries.push(entry); } + // Pull mis-stamped finals (queue drain / turn flip) back onto the prior turn. + rehomeOrphanTurnFinals(feed, groupsByTurnId); + + // If latestTurn names a terminal message still stamped with another turn id, + // force it into the latest turn's group for fold membership. + if (latestTurn?.assistantMessageId != null) { + const preferredId = String(latestTurn.assistantMessageId); + let ownedBy: TurnId | null = null; + let ownedEntry: ThreadFeedEntry | null = null; + for (const [turnId, group] of groupsByTurnId) { + const found = group.entries.find( + (entry) => + entry.type === "message" && + entry.message.role === "assistant" && + (entry.id === preferredId || String(entry.message.id) === preferredId), + ); + if (found) { + ownedBy = turnId; + ownedEntry = found; + break; + } + } + if (ownedBy !== null && ownedBy !== latestTurn.turnId && ownedEntry !== null) { + const source = groupsByTurnId.get(ownedBy); + const target = groupsByTurnId.get(latestTurn.turnId); + if (source) { + source.entries = source.entries.filter((entry) => entry.id !== ownedEntry.id); + } + if (target) { + if (!target.entries.some((entry) => entry.id === ownedEntry.id)) { + target.entries.push(ownedEntry); + } + } else if (source) { + // Latest turn may not have had any entries yet under its id. + groupsByTurnId.set(latestTurn.turnId, { + entries: [ownedEntry], + startBoundary: source.startBoundary, + }); + } + } + } + const unsettledTurnId = deriveUnsettledTurnId(latestTurn); const foldsByAnchorId = new Map(); for (const [turnId, group] of groupsByTurnId) { @@ -1662,8 +1867,10 @@ function deriveThreadFeedTurnFolds( continue; } - const firstAssistantMessageId = firstAssistantMessageIdByTurn.get(turnId); - const terminalAssistantMessageId = terminalAssistantMessageIdByTurn.get(turnId); + const firstAssistantMessageId = entries.find( + (entry) => entry.type === "message" && entry.message.role === "assistant", + )?.id; + const terminalAssistantMessageId = resolveTurnTerminalEntryId(turnId, entries, latestTurn); const hiddenEntryIds = new Set( entries .filter( @@ -2197,27 +2404,136 @@ export function buildThreadFeed( : [], ), ); - const entries = Arr.sortWith( - [ - ...messages - .filter((message) => message.role !== "user" || !foldedAnswerMessageIds.has(message.id)) - .map((message) => { - let entry = messageEntriesCache.get(message); - if (!entry) { - entry = { type: "message", id: message.id, createdAt: message.createdAt, message }; - messageEntriesCache.set(message, entry); - } - return entry; - }), - ...activityEntries, - ], - (s) => new Date(s.createdAt), - Order.Date, - ); + const rawEntries: RawThreadFeedEntry[] = [ + ...messages + .filter((message) => message.role !== "user" || !foldedAnswerMessageIds.has(message.id)) + .map((message) => { + let entry = messageEntriesCache.get(message); + if (!entry) { + entry = { type: "message", id: message.id, createdAt: message.createdAt, message }; + messageEntriesCache.set(message, entry); + } + return entry; + }), + ...activityEntries, + ]; + + const turnIds = new Set(); + for (const entry of rawEntries) { + if (entry.type === "message" && entry.message.turnId !== null) { + turnIds.add(String(entry.message.turnId)); + } + if (entry.type === "activity" && entry.turnId !== null) { + turnIds.add(String(entry.turnId)); + } + } + + const steersByTurnId = new Map< + string, + ReadonlyArray<{ readonly id: string; readonly createdAt: string }> + >(); + const steerIdSet = new Set(); + for (const turnId of turnIds) { + const steers = findMidTurnSteerUserIds({ + items: rawEntries.map((entry) => ({ + id: entry.id, + createdAt: entry.createdAt, + isUser: entry.type === "message" && entry.message.role === "user", + belongsToActiveTurn: + (entry.type === "message" && + entry.message.role !== "user" && + entry.message.turnId !== null && + String(entry.message.turnId) === turnId) || + (entry.type === "activity" && entry.turnId !== null && String(entry.turnId) === turnId), + })), + }); + if (steers.length === 0) { + continue; + } + steersByTurnId.set(turnId, steers); + for (const steer of steers) { + steerIdSet.add(steer.id); + } + } + + const entries = + steersByTurnId.size === 0 + ? Arr.sortWith(rawEntries, (s) => new Date(s.createdAt), Order.Date) + : expandThreadFeedSteers(rawEntries, steersByTurnId, steerIdSet); return groupAdjacentActivities(entries); } +function expandThreadFeedSteers( + rawEntries: ReadonlyArray, + steersByTurnId: ReadonlyMap< + string, + ReadonlyArray<{ readonly id: string; readonly createdAt: string }> + >, + steerIdSet: ReadonlySet, +): RawThreadFeedEntry[] { + const rankedEntries: Array<{ + readonly entry: RawThreadFeedEntry; + readonly id: string; + readonly createdAt: string; + readonly sortRank: number; + }> = []; + for (const entry of rawEntries) { + if ( + entry.type === "message" && + entry.message.role === "assistant" && + entry.message.turnId !== null + ) { + const steers = steersByTurnId.get(String(entry.message.turnId)); + if (steers !== undefined && steers.length > 0) { + const segments = splitAssistantTextAtSteers({ + assistantMessageId: entry.message.id, + assistantCreatedAt: entry.message.createdAt, + text: entry.message.text, + streaming: entry.message.streaming, + steers, + }); + for (const segment of segments) { + rankedEntries.push({ + id: segment.segmentId, + createdAt: segment.sortAt, + sortRank: segment.sortRank, + entry: { + type: "message", + id: segment.segmentId, + createdAt: segment.sortAt, + message: { + ...entry.message, + text: segment.text, + streaming: segment.streaming, + createdAt: segment.sortAt, + updatedAt: segment.streaming ? entry.message.updatedAt : segment.sortAt, + }, + }, + }); + } + continue; + } + } + + rankedEntries.push({ + entry, + id: entry.id, + createdAt: entry.createdAt, + sortRank: steerIdSet.has(entry.id) ? 1 : 0, + }); + } + + return rankedEntries + .sort((left, right) => + compareSteerTimelineSortable( + { id: left.id, sortAt: left.createdAt, sortRank: left.sortRank }, + { id: right.id, sortAt: right.createdAt, sortRank: right.sortRank }, + ), + ) + .map((ranked) => ranked.entry); +} + function getThreadFeedActivityEntries(activities: ReadonlyArray) { const cached = activityEntriesCache.get(activities); if (cached) return cached; diff --git a/apps/mobile/src/mobileSurfaceExistence.test.ts b/apps/mobile/src/mobileSurfaceExistence.test.ts new file mode 100644 index 000000000000..8b0a8bb900c0 --- /dev/null +++ b/apps/mobile/src/mobileSurfaceExistence.test.ts @@ -0,0 +1,130 @@ +/** + * Existence contracts for mobile product surfaces that stack conflict + * resolution can accidentally leave structurally present but unrenderable. + */ +// @effect-diagnostics nodeBuiltinImport:off - existence contract reads source text on disk. +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; +import { describe, expect, it } from "vite-plus/test"; + +const root = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)); + +function readSrc(relativePath: string): string { + return NodeFS.readFileSync(NodePath.join(root, relativePath), "utf8"); +} + +describe("mobile surface existence (anti stack-drop)", () => { + it("keeps the conversation feed inside an explicit flex host", () => { + const threadRoute = readSrc("features/threads/ThreadRouteScreen.tsx"); + + expect(threadRoute).toContain('testID="thread-conversation-surface"'); + expect(threadRoute).toMatch( + /testID="thread-conversation-surface"[\s\S]*?style=\{\{ flex: 1 \}\}/, + ); + // Inner host stays a real flex container so the composer overlay still + // anchors to the true bottom. Material You adds a canvas class and + // rounded corners; the default branch is still flex-1. + expect(threadRoute).toMatch( + /className=\{materialYouStyleLayoutActive \? "flex-1 bg-thread-canvas" : "flex-1"\}[\s\S]*?flex: 1[\s\S]*? { + const listItems = readSrc("features/threads/thread-list-items.tsx"); + + // The settled branch must stay wired into the shared row renderer: a + // whole-file conflict resolve that keeps the helper but drops the branch + // would silently restore full-size settled rows. + expect(listItems).toContain('testID="thread-list-row-settled"'); + expect(listItems).toMatch(/isSettled \? \(\s*settledRowContent\(close\)/); + expect(listItems).toContain("resolveSettledRowTimestamp"); + // Slim chrome: dimmed favicon, one muted title line, no status pill. + expect(listItems).toMatch( + /testID="thread-list-row-settled"[\s\S]*?text-foreground-muted[\s\S]*?<\/Pressable>/, + ); + expect(listItems).toMatch(/settledRowContent[\s\S]*?opacity-40[\s\S]*?ProjectFavicon/); + }); + + it("keeps the feed still for sends the server will hold in the steering queue", () => { + const composerState = readSrc("state/use-thread-composer-state.ts"); + const detailScreen = readSrc("features/threads/ThreadDetailScreen.tsx"); + + // The prediction is the shared one (same rule as the server decider and + // the web client), not a mobile-local re-derivation that can drift. + expect(composerState).toContain('from "@t3tools/shared/chatList"'); + expect(composerState).toContain("sendEntersSteeringQueue({"); + expect(composerState).toContain("hasPendingTurnStart:"); + + // A queue-bound send must move neither the viewport nor the anchor: both + // live inside the guard, and the anchor would otherwise stay armed and + // fire whenever the queue eventually drains. + expect(detailScreen).toMatch( + /if \(!sendWillQueue\) \{[\s\S]*?scrollToEnd\(\{ animated: false \}\)[\s\S]*?setAnchorMessageId\(messageId\)[\s\S]*?\}/, + ); + }); + + it('"Send now" moves the message optimistically and can put it back', () => { + const composerState = readSrc("state/use-thread-composer-state.ts"); + + // The feed and the chip list both read the promoted detail, so one piece + // of state moves the message and one revert puts it back. + expect(composerState).toContain("promoteSteeredQueuedMessages(selectedThreadDetail"); + expect(composerState).toMatch(/const selectedThreadMessages = steeredDetail\?\.messages/); + expect(composerState).toMatch(/const selectedThreadActivities = steeredDetail\?\.activities/); + expect(composerState).toContain("buildThreadFeed("); + expect(composerState).toMatch(/messages: selectedThreadMessages/); + expect(composerState).toMatch(/timelineIds = new Set\(steeredDetail\?\.messages/); + // Failure puts it back rather than leaving a bubble the agent never got. + expect(composerState).toMatch( + /if \(result\._tag === "Success"\) \{[\s\S]*?return;[\s\S]*?\}[\s\S]*?pruneSteeringQueuedMessageIds\([\s\S]*?setPendingConnectionError/, + ); + }); + + it("keeps list-mode titles under the connection-status title swap", () => { + // Upstream's connection-aware header hardcodes the brand lockup and the + // literal "Threads" (#5372). This fork's headers show a list-mode title + // (Threads / Projects / Board), so every surface that adopts the swap has + // to pass its own title through — a plain adoption silently renames Board + // and Projects to "Threads", which is exactly what slipped through once. + const sidebar = NodeFS.readFileSync( + NodePath.join(root, "features/threads/ThreadNavigationSidebar.tsx"), + "utf8", + ); + const homeHeader = NodeFS.readFileSync( + NodePath.join(root, "features/home/HomeHeader.tsx"), + "utf8", + ); + + // Native header slot (iOS split) and the custom large title (Android split). + expect(sidebar).toMatch( + /getConnectionAwareBrandHeaderOptions\(\{[\s\S]*?title: HOME_LIST_MODE_TITLES\[options\.listMode\]/, + ); + expect(sidebar).toMatch( + / { + const nodeKey = NodeFS.readFileSync( + NodePath.join(root, "../modules/t3-markdown-text/src/markdownNodeKey.ts"), + "utf8", + ); + const tableBlock = NodeFS.readFileSync( + NodePath.join(root, "../modules/t3-markdown-text/src/NativeMarkdownBlock.tsx"), + "utf8", + ); + // Grid keys for tables (never type:beg:end → table_cell:0:0). + expect(nodeKey).toContain("markdownTableCellKey"); + expect(nodeKey).toContain("i${index}"); + expect(tableBlock).toContain("markdownTableCellKey"); + expect(tableBlock).toContain("key={markdownTableCellKey(rowIndex, cellIndex)}"); + }); +}); diff --git a/apps/mobile/src/native/StackHeader.tsx b/apps/mobile/src/native/StackHeader.tsx index a524d5152473..78c87119512b 100644 --- a/apps/mobile/src/native/StackHeader.tsx +++ b/apps/mobile/src/native/StackHeader.tsx @@ -340,8 +340,7 @@ function convertToolbarChild(child: ReactNode): NativeStackHeaderItem | null { return { type: "spacing", spacing: typeof child.props.width === "number" ? child.props.width : 8, - flexible: Boolean(child.props.flexible), - } as NativeStackHeaderItem; + }; } return null; @@ -352,11 +351,6 @@ function collectToolbarItems(children: ReactNode): NativeStackHeaderItem[] { Children.forEach(children, (child) => { const item = convertToolbarChild(child); if (item) { - if (item.type === "spacing") { - // Native inserts spacing items at `index`, treating a missing index - // as 0 — which would move the spacer in front of earlier siblings. - (item as { index?: number }).index = items.length; - } items.push(item); } }); @@ -370,8 +364,7 @@ function NativeHeaderToolbarRoot(props: { const navigation = useNativeStackNavigation(); const items = useMemo(() => collectToolbarItems(props.children), [props.children]); - // Swap toolbar owners before paint so split and compact headers cannot clear each other. - useLayoutEffect(() => { + useEffect(() => { if (!navigation) { return; } @@ -447,7 +440,6 @@ function NativeHeaderToolbarLabel(_props: { readonly children?: ReactNode }) { NativeHeaderToolbarLabel.displayName = "NativeHeaderToolbarLabel"; function NativeHeaderToolbarSpacer(_props: { - readonly flexible?: boolean; readonly sharesBackground?: boolean; readonly width?: number; }) { diff --git a/apps/mobile/src/native/T3ComposerEditor.native.tsx b/apps/mobile/src/native/T3ComposerEditor.native.tsx index 129e1af2a92b..95c981c415d3 100644 --- a/apps/mobile/src/native/T3ComposerEditor.native.tsx +++ b/apps/mobile/src/native/T3ComposerEditor.native.tsx @@ -1,6 +1,7 @@ import { collectComposerInlineTokens } from "@t3tools/shared/composerInlineTokens"; import { requireNativeView } from "expo"; import { TextInputWrapper } from "expo-paste-input"; +import { useNativePaste } from "../lib/useNativePaste"; import { useCallback, useEffect, @@ -10,13 +11,12 @@ import { useState, type Ref, } from "react"; -import type { NativeSyntheticEvent, ViewProps } from "react-native"; +import type { NativeSyntheticEvent, StyleProp, ViewProps, ViewStyle } from "react-native"; import { Image, StyleSheet } from "react-native"; import { markdownFileIconSource } from "@t3tools/mobile-markdown-text/file-icons"; import { resolveMarkdownFileIcon } from "@t3tools/mobile-markdown-text/links"; import { MOBILE_TYPOGRAPHY } from "../lib/typography"; -import { useNativePaste } from "../lib/useNativePaste"; import { useFontFamily } from "../lib/useFontFamily"; import { useAppearancePreferences } from "../features/settings/appearance/AppearancePreferencesProvider"; import { useUniwindTheme } from "../lib/useUniwindTheme"; diff --git a/apps/mobile/src/persistence/mobile-preferences.ts b/apps/mobile/src/persistence/mobile-preferences.ts index 8209f6103bcc..a5645aaa2cbd 100644 --- a/apps/mobile/src/persistence/mobile-preferences.ts +++ b/apps/mobile/src/persistence/mobile-preferences.ts @@ -39,7 +39,49 @@ export interface Preferences { * opt-out): sanitizing drops the old key, so every device resets to the * default flat list — see `resolveThreadListV2Enabled`. */ + /** + * @deprecated Superseded by `legacyThreadListEnabled` when v2 became the + * default (#5672). Kept so older device preference payloads still decode. + */ + readonly threadListV2Enabled?: boolean; readonly legacyThreadListEnabled?: boolean; + /** + * @deprecated Legacy toggle from Needs attention / Recent work UI (removed). + * Kept only so older device preference payloads still decode. + */ + readonly recentWorkEnabled?: boolean; + /** + * Multi-select home/board environment filter. Empty or omitted = all + * environments. Device-local (no client-settings sync). + */ + readonly selectedEnvironmentIds?: readonly string[]; + /** + * @deprecated Prefer hideSettledOnRecent. Older payloads used a single flag + * for Recent only; kept so device prefs still decode. + */ + readonly hideSettledThreads?: boolean; + /** + * Recent list: hide settled threads. Default true when omitted (cleaner inbox). + */ + readonly hideSettledOnRecent?: boolean; + /** + * Projects list: hide settled threads. Default false when omitted (full history). + */ + readonly hideSettledOnProjects?: boolean; + /** + * Threads list organization: recency (Recent), project, or none. + * Device-local; survives restarts. Omitted = default project grouping. + */ + readonly threadGrouping?: "recency" | "project" | "none"; + /** + * Home/sidebar ownership filter (anyone / mine / theirs). Device-local so + * it survives app restarts — without this, Mine/Theirs resets on launch. + */ + readonly ownershipFilter?: "any" | "mine" | "theirs"; + /** + * Sub-filter for mine/theirs: created, participated, or both (default). + */ + readonly ownershipRelation?: "created" | "participated" | "both"; /** Device-local counterpart of desktop's `planModeEnabled` legacy flag. */ readonly planModeEnabled?: boolean; /** Fresh keys reset both shelves to collapsed when users update. */ @@ -101,7 +143,16 @@ function sanitizePreferences(parsed: Preferences): Preferences { collapsedProjectGroups?: readonly string[]; projectGroupingEnabled?: boolean; projectGroupingMode?: SidebarProjectGroupingMode; + threadListV2Enabled?: boolean; legacyThreadListEnabled?: boolean; + recentWorkEnabled?: boolean; + selectedEnvironmentIds?: readonly string[]; + hideSettledThreads?: boolean; + hideSettledOnRecent?: boolean; + hideSettledOnProjects?: boolean; + threadGrouping?: "recency" | "project" | "none"; + ownershipFilter?: "any" | "mine" | "theirs"; + ownershipRelation?: "created" | "participated" | "both"; planModeEnabled?: boolean; threadListSettledShelfExpanded?: boolean; threadListSnoozedShelfExpanded?: boolean; @@ -172,6 +223,44 @@ function sanitizePreferences(parsed: Preferences): Preferences { if (typeof parsed.legacyThreadListEnabled === "boolean") { preferences.legacyThreadListEnabled = parsed.legacyThreadListEnabled; } + if (typeof parsed.recentWorkEnabled === "boolean") { + preferences.recentWorkEnabled = parsed.recentWorkEnabled; + } + if (Array.isArray(parsed.selectedEnvironmentIds)) { + preferences.selectedEnvironmentIds = parsed.selectedEnvironmentIds.filter( + (id): id is string => typeof id === "string" && id.length > 0, + ); + } + if (typeof parsed.hideSettledThreads === "boolean") { + preferences.hideSettledThreads = parsed.hideSettledThreads; + } + if (typeof parsed.hideSettledOnRecent === "boolean") { + preferences.hideSettledOnRecent = parsed.hideSettledOnRecent; + } + if (typeof parsed.hideSettledOnProjects === "boolean") { + preferences.hideSettledOnProjects = parsed.hideSettledOnProjects; + } + if ( + parsed.threadGrouping === "recency" || + parsed.threadGrouping === "project" || + parsed.threadGrouping === "none" + ) { + preferences.threadGrouping = parsed.threadGrouping; + } + if ( + parsed.ownershipFilter === "any" || + parsed.ownershipFilter === "mine" || + parsed.ownershipFilter === "theirs" + ) { + preferences.ownershipFilter = parsed.ownershipFilter; + } + if ( + parsed.ownershipRelation === "created" || + parsed.ownershipRelation === "participated" || + parsed.ownershipRelation === "both" + ) { + preferences.ownershipRelation = parsed.ownershipRelation; + } if (typeof parsed.planModeEnabled === "boolean") { preferences.planModeEnabled = parsed.planModeEnabled; } @@ -184,6 +273,60 @@ function sanitizePreferences(parsed: Preferences): Preferences { return preferences; } +/** Resolve stored ownership filter; default Mine when never chosen. */ +export function resolveOwnershipFilter(preferences: Preferences): "any" | "mine" | "theirs" { + if ( + preferences.ownershipFilter === "any" || + preferences.ownershipFilter === "mine" || + preferences.ownershipFilter === "theirs" + ) { + return preferences.ownershipFilter; + } + return "mine"; +} + +/** Resolve mine/theirs relation sub-filter; default both. */ +export function resolveOwnershipRelation( + preferences: Preferences, +): "created" | "participated" | "both" { + if ( + preferences.ownershipRelation === "created" || + preferences.ownershipRelation === "participated" || + preferences.ownershipRelation === "both" + ) { + return preferences.ownershipRelation; + } + return "both"; +} + +/** Resolve stored Threads grouping; default project when never chosen. */ +export function resolveThreadGrouping(preferences: Preferences): "recency" | "project" | "none" { + if ( + preferences.threadGrouping === "recency" || + preferences.threadGrouping === "project" || + preferences.threadGrouping === "none" + ) { + return preferences.threadGrouping; + } + return "project"; +} + +/** Recent: default hide settled. Honors legacy hideSettledThreads when set. */ +export function resolveHideSettledOnRecent(preferences: Preferences): boolean { + if (typeof preferences.hideSettledOnRecent === "boolean") { + return preferences.hideSettledOnRecent; + } + if (typeof preferences.hideSettledThreads === "boolean") { + return preferences.hideSettledThreads; + } + return true; +} + +/** Projects: default show settled (hide = false). */ +export function resolveHideSettledOnProjects(preferences: Preferences): boolean { + return preferences.hideSettledOnProjects === true; +} + export const make = Effect.fn("MobilePreferencesStore.make")(function* () { const database = yield* MobileDatabase.MobileDatabase; const secureStorage = yield* MobileSecureStorage.MobileSecureStorage; diff --git a/apps/mobile/src/state/aiUsage.ts b/apps/mobile/src/state/aiUsage.ts new file mode 100644 index 000000000000..28ce8d712b8c --- /dev/null +++ b/apps/mobile/src/state/aiUsage.ts @@ -0,0 +1,5 @@ +import { createAiUsageEnvironmentAtoms } from "@t3tools/client-runtime/state/ai-usage"; + +import { connectionAtomRuntime } from "../connection/runtime"; + +export const aiUsageEnvironment = createAiUsageEnvironmentAtoms(connectionAtomRuntime); diff --git a/apps/mobile/src/state/assets.ts b/apps/mobile/src/state/assets.ts index 15cbd1d9a89f..2292598483bb 100644 --- a/apps/mobile/src/state/assets.ts +++ b/apps/mobile/src/state/assets.ts @@ -8,11 +8,12 @@ import { createAssetEnvironmentAtoms, createProjectFaviconUrlAtomFamily, EMPTY_ASSET_URL_ATOM, + resolveAssetUrl, } from "@t3tools/client-runtime/state/assets"; import type { AssetResource, EnvironmentId } from "@t3tools/contracts"; import * as Option from "effect/Option"; import { AsyncResult, Atom } from "effect/unstable/reactivity"; -import { useCallback } from "react"; +import { useCallback, useMemo } from "react"; import { environmentCatalog } from "../connection/catalog"; import { connectionAtomRuntime } from "../connection/runtime"; @@ -35,6 +36,10 @@ const EMPTY_CONNECTION_STATE_ATOM = Atom.make(AsyncResult.initial( Atom.withLabel("mobile-asset-connection-state:empty"), ); +const EMPTY_ASSET_URLS_ATOM = Atom.make([] as Array>).pipe( + Atom.withLabel("mobile-asset-urls:empty"), +); + function useConnectionPhase(environmentId: EnvironmentId | null): EnvironmentConnectionPhase { const state = useAtomValue( environmentId === null @@ -77,6 +82,34 @@ export function useAssetUrl( return state._tag === "Success" ? state.url : null; } +/** + * Batch sibling of {@link useAssetUrl}, for a set of resources whose size is + * only known at render time (a thread's attachments, say) and so cannot be + * resolved with one hook call each. + */ +export function useAssetUrls( + environmentId: EnvironmentId | null, + resources: ReadonlyArray, +): ReadonlyArray { + const preparedConnection = usePreparedConnection(environmentId); + const results = useAtomValue( + environmentId === null || resources.length === 0 + ? EMPTY_ASSET_URLS_ATOM + : assetEnvironment.createUrls({ environmentId, resources }), + ); + return useMemo( + () => + preparedConnection._tag === "None" + ? resources.map(() => null) + : results.map((result) => + AsyncResult.isSuccess(result) + ? resolveAssetUrl(preparedConnection.value.httpBaseUrl, result.value.relativeUrl) + : null, + ), + [preparedConnection, resources, results], + ); +} + /** Explicit playback and sharing must reauthorize files that may have been replaced on disk. */ export function useRefreshAssetUrl( environmentId: EnvironmentId | null, diff --git a/apps/mobile/src/state/composerDraftMessage.test.ts b/apps/mobile/src/state/composerDraftMessage.test.ts new file mode 100644 index 000000000000..01b04ca79f42 --- /dev/null +++ b/apps/mobile/src/state/composerDraftMessage.test.ts @@ -0,0 +1,28 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { hasComposerDraftMessage } from "./use-composer-drafts"; + +describe("hasComposerDraftMessage", () => { + it("is false for empty or settings-only drafts", () => { + expect(hasComposerDraftMessage(undefined)).toBe(false); + expect(hasComposerDraftMessage({ text: "", attachments: [] })).toBe(false); + expect(hasComposerDraftMessage({ text: " ", attachments: [] })).toBe(false); + expect( + hasComposerDraftMessage({ + text: "", + attachments: [], + modelSelection: { instanceId: "codex", model: "gpt" } as never, + }), + ).toBe(false); + }); + + it("is true for text or attachments", () => { + expect(hasComposerDraftMessage({ text: "hello", attachments: [] })).toBe(true); + expect( + hasComposerDraftMessage({ + text: "", + attachments: [{ id: "a1" } as never], + }), + ).toBe(true); + }); +}); diff --git a/apps/mobile/src/state/identity.ts b/apps/mobile/src/state/identity.ts new file mode 100644 index 000000000000..09cde6ff8850 --- /dev/null +++ b/apps/mobile/src/state/identity.ts @@ -0,0 +1,28 @@ +import { createIdentityEnvironmentAtoms } from "@t3tools/client-runtime/state/identity"; +import type { EnvironmentId } from "@t3tools/contracts"; +import * as Option from "effect/Option"; +import { AsyncResult, Atom } from "effect/unstable/reactivity"; + +import { environmentCatalog } from "../connection/catalog"; +import { connectionAtomRuntime } from "../connection/runtime"; + +export const identityEnvironment = createIdentityEnvironmentAtoms(connectionAtomRuntime); + +const EMPTY_CLAIM_INPUT = {} as const; + +/** Session claim personId keyed by the thread's environment for ownership filters. */ +export const identityClaimPersonIdByEnvironmentAtom = Atom.make((get) => { + const catalog = get(environmentCatalog.catalogValueAtom); + const out = new Map(); + for (const environmentId of catalog.entries.keys()) { + const result = get( + identityEnvironment.sessionClaim({ + environmentId: environmentId as EnvironmentId, + input: EMPTY_CLAIM_INPUT, + }), + ); + const claimResult = Option.getOrNull(AsyncResult.value(result)); + out.set(environmentId, claimResult?.claim?.personId ?? null); + } + return out; +}).pipe(Atom.withLabel("mobile-identity-claim-person-by-environment")); diff --git a/apps/mobile/src/state/thread-outbox-model.ts b/apps/mobile/src/state/thread-outbox-model.ts index 2676c935e01e..c3c601ff63a7 100644 --- a/apps/mobile/src/state/thread-outbox-model.ts +++ b/apps/mobile/src/state/thread-outbox-model.ts @@ -168,7 +168,12 @@ export function resolveThreadOutboxDeliveryAction(input: { readonly threadExists: boolean; readonly shellStatus: EnvironmentShellStatus; readonly environmentConnected: boolean; - readonly threadBusy: boolean; + /** + * Accepted but unused. Upstream stopped gating on it in #6543 — a send during + * an active turn is now intentional on both sides — and kept it in the + * contract, so callers and its tests still pass it. + */ + readonly threadBusy?: boolean; }): ThreadOutboxDeliveryAction { if (input.isCreation) { // A pending task creates its thread on delivery. If the thread already @@ -184,6 +189,9 @@ export function resolveThreadOutboxDeliveryAction(input: { if (!input.threadExists) { return input.shellStatus === "live" ? "remove" : "wait"; } + // Once connected, hand ownership to the server immediately. The server + // persists follow-ups that arrive during an active turn; this local outbox + // is only the offline/transport safety boundary. return input.environmentConnected ? "send" : "wait"; } diff --git a/apps/mobile/src/state/thread-outbox.test.ts b/apps/mobile/src/state/thread-outbox.test.ts index c186bc098e5b..e992a207df9e 100644 --- a/apps/mobile/src/state/thread-outbox.test.ts +++ b/apps/mobile/src/state/thread-outbox.test.ts @@ -579,6 +579,69 @@ describe("thread outbox", () => { registry.dispose(); }); + it("surfaces enqueue in memory before the durable write resolves", async () => { + const registry = AtomRegistry.make(); + let releaseWrite!: () => void; + const writeGate = new Promise((resolve) => { + releaseWrite = resolve; + }); + const storage: ThreadOutboxStorage = { + load: async () => ({ messages: [], errors: [] }), + write: async () => { + await writeGate; + }, + remove: async () => undefined, + }; + const manager = createThreadOutboxManager({ registry, storage }); + const message = queuedMessage({ + messageId: "message-1", + createdAt: "2026-06-08T10:00:01.000Z", + }); + + const enqueuePromise = manager.enqueue(message); + expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({ + "environment-1:thread-1": [message], + }); + + releaseWrite(); + await enqueuePromise; + registry.dispose(); + }); + + it("rolls back the in-memory queue when the durable write fails", async () => { + const registry = AtomRegistry.make(); + const writeCause = new Error("write failed"); + const storage: ThreadOutboxStorage = { + load: async () => ({ messages: [], errors: [] }), + write: async () => { + throw writeCause; + }, + remove: async () => undefined, + }; + const manager = createThreadOutboxManager({ registry, storage }); + const message = queuedMessage({ + messageId: "message-1", + createdAt: "2026-06-08T10:00:01.000Z", + }); + + expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({}); + const enqueuePromise = manager.enqueue(message); + expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({ + "environment-1:thread-1": [message], + }); + await expect(enqueuePromise).rejects.toEqual( + new ThreadOutboxManagerError({ + operation: "enqueue", + environmentId: message.environmentId, + threadId: message.threadId, + messageId: message.messageId, + cause: writeCause, + }), + ); + expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({}); + registry.dispose(); + }); + it("keeps atom state aligned with durable writes and removals", async () => { const registry = AtomRegistry.make(); const stored = new Map(); @@ -817,6 +880,41 @@ describe("thread outbox", () => { registry.dispose(); }); + it("keeps offline messages local and hands connected messages to the server", () => { + expect( + resolveThreadOutboxDeliveryAction({ + isCreation: false, + threadExists: false, + shellStatus: "synchronizing", + environmentConnected: true, + }), + ).toBe("wait"); + expect( + resolveThreadOutboxDeliveryAction({ + isCreation: false, + threadExists: false, + shellStatus: "live", + environmentConnected: true, + }), + ).toBe("remove"); + expect( + resolveThreadOutboxDeliveryAction({ + isCreation: false, + threadExists: true, + shellStatus: "live", + environmentConnected: false, + }), + ).toBe("wait"); + expect( + resolveThreadOutboxDeliveryAction({ + isCreation: false, + threadExists: true, + shellStatus: "live", + environmentConnected: true, + }), + ).toBe("send"); + }); + it("rejects a stale revision before its payload reaches durable storage", async () => { const registry = AtomRegistry.make(); const writes: string[] = []; @@ -1270,7 +1368,6 @@ describe("thread outbox", () => { threadExists: false, shellStatus: "synchronizing", environmentConnected: true, - threadBusy: false, }), ).toBe("wait"); expect( @@ -1279,16 +1376,22 @@ describe("thread outbox", () => { threadExists: false, shellStatus: "live", environmentConnected: true, - threadBusy: false, }), ).toBe("remove"); + expect( + resolveThreadOutboxDeliveryAction({ + isCreation: false, + threadExists: true, + shellStatus: "live", + environmentConnected: false, + }), + ).toBe("wait"); expect( resolveThreadOutboxDeliveryAction({ isCreation: false, threadExists: true, shellStatus: "live", environmentConnected: true, - threadBusy: false, }), ).toBe("send"); }); @@ -1321,7 +1424,6 @@ describe("thread outbox", () => { threadExists: false, shellStatus: "cached", environmentConnected: false, - threadBusy: false, }), ).toBe("wait"); // Connected but not yet synchronized: a previously delivered creation may @@ -1332,7 +1434,6 @@ describe("thread outbox", () => { threadExists: false, shellStatus: "synchronizing", environmentConnected: true, - threadBusy: false, }), ).toBe("wait"); expect( @@ -1341,7 +1442,6 @@ describe("thread outbox", () => { threadExists: false, shellStatus: "live", environmentConnected: true, - threadBusy: false, }), ).toBe("send"); expect( @@ -1350,7 +1450,6 @@ describe("thread outbox", () => { threadExists: true, shellStatus: "live", environmentConnected: true, - threadBusy: true, }), ).toBe("remove"); }); diff --git a/apps/mobile/src/state/threads.ts b/apps/mobile/src/state/threads.ts index 7f2471230510..7bfb9adc74c8 100644 --- a/apps/mobile/src/state/threads.ts +++ b/apps/mobile/src/state/threads.ts @@ -13,6 +13,7 @@ import { AsyncResult, Atom } from "effect/unstable/reactivity"; import { environmentCatalog } from "../connection/catalog"; import { connectionAtomRuntime } from "../connection/runtime"; +import { appAtomRegistry } from "./atom-registry"; import { environmentSnapshotAtom } from "./shell"; export const threadEnvironment = createThreadEnvironmentAtoms(connectionAtomRuntime); @@ -29,6 +30,51 @@ const EMPTY_THREAD_STATE_ATOM = Atom.make(AsyncResult.success(EMPTY_ENVIRONMENT_ Atom.withLabel("mobile-environment-thread:empty"), ); +/** Keep the last selected thread detail stream mounted so reopen/back-nav is warm. */ +let warmThreadUnmount: (() => void) | null = null; +const pressPrefetchTimers = new Map>(); + +function threadPrefetchKey(environmentId: EnvironmentId, threadId: ThreadId): string { + return `${environmentId}\u0000${threadId}`; +} + +/** + * Start loading thread detail (SQLite → HTTP snapshot → WS resume) before the + * Thread route mounts. Call from list press-in / selection so open latency + * overlaps the navigation transition. + */ +export function prefetchEnvironmentThread(environmentId: EnvironmentId, threadId: ThreadId): void { + const key = threadPrefetchKey(environmentId, threadId); + const existingTimer = pressPrefetchTimers.get(key); + if (existingTimer !== undefined) { + clearTimeout(existingTimer); + } + // Mount kicks off makeEnvironmentThreadState. Hold briefly so navigate can + // attach useAtomValue; the Thread screen then keeps the same atom alive. + const unmount = appAtomRegistry.mount(environmentThreads.stateAtom(environmentId, threadId)); + const timer = setTimeout(() => { + pressPrefetchTimers.delete(key); + unmount(); + }, 15_000); + pressPrefetchTimers.set(key, timer); +} + +/** + * Hold the selected thread's detail atom mounted while the user stays in the + * app session, so returning from the list does not re-run a cold full hydrate. + * Replaces any previous warm hold. + */ +export function warmSelectedEnvironmentThread( + environmentId: EnvironmentId, + threadId: ThreadId, +): void { + const atom = environmentThreads.stateAtom(environmentId, threadId); + const nextUnmount = appAtomRegistry.mount(atom); + const previous = warmThreadUnmount; + warmThreadUnmount = nextUnmount; + previous?.(); +} + export function useEnvironmentThread( environmentId: EnvironmentId | null, threadId: ThreadId | null, diff --git a/apps/mobile/src/state/use-composer-drafts.ts b/apps/mobile/src/state/use-composer-drafts.ts index 37ea3bbe6ee0..a13143048e03 100644 --- a/apps/mobile/src/state/use-composer-drafts.ts +++ b/apps/mobile/src/state/use-composer-drafts.ts @@ -203,6 +203,15 @@ export function isComposerDraftEmpty(draft: ComposerDraft): boolean { return isEmptyDraft(draft); } +/** + * Unsent composer content (text or attachments). Settings-only sticky draft + * state does not count for list draft dots. + */ +export function hasComposerDraftMessage(draft: ComposerDraft | null | undefined): boolean { + if (!draft) return false; + return draft.text.trim().length > 0 || draft.attachments.length > 0; +} + // The project stamp is identity, not content: a new-task draft with nothing // else in it is still empty and gets dropped like any other. function isEmptyDraft(draft: ComposerDraft): boolean { diff --git a/apps/mobile/src/state/use-selected-thread-git-actions.ts b/apps/mobile/src/state/use-selected-thread-git-actions.ts index e66f690428e8..094e372fb351 100644 --- a/apps/mobile/src/state/use-selected-thread-git-actions.ts +++ b/apps/mobile/src/state/use-selected-thread-git-actions.ts @@ -3,6 +3,8 @@ import { useCallback, useEffect, useMemo } from "react"; import { EnvironmentProject, EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime"; import { + buildUnsignedCommitRetryInput, + isCommitSigningFailure, type GitActionRequestInput, type VcsActionOperation, type VcsRef, @@ -14,6 +16,7 @@ import { } from "@t3tools/shared/git"; import * as Cause from "effect/Cause"; import { AsyncResult } from "effect/unstable/reactivity"; +import { Alert } from "react-native"; import { useBranches } from "../state/queries"; import { threadEnvironment } from "../state/threads"; @@ -131,7 +134,10 @@ export function useSelectedThreadGitActions() { readonly project: EnvironmentProject; readonly cwd: string; }) => Promise>, - options?: { readonly managedExternally?: boolean }, + options?: { + readonly managedExternally?: boolean; + readonly onFailure?: (error: unknown) => boolean; + }, ): Promise => { if (!selectedThread || !selectedThreadProject || !selectedThreadCwd) { return null; @@ -154,6 +160,9 @@ export function useSelectedThreadGitActions() { : await vcsActionManager.track(appAtomRegistry, target, { operation, label }, run); if (AsyncResult.isFailure(result)) { const error = Cause.squash(result.cause); + if (options?.onFailure?.(error) === true) { + return null; + } const message = error instanceof Error ? error.message : "Git action failed."; setPendingConnectionError(message); showGitActionResult({ type: "error", title: "Git action failed", description: message }); @@ -319,51 +328,97 @@ export function useSelectedThreadGitActions() { const onRunSelectedThreadGitAction = useCallback( async (input: GitActionRequestInput): Promise => { - const actionId = uuidv4(); - return await runSelectedThreadGitMutation( - "run_change_request", - "Running source control action", - async ({ thread, cwd }) => { - const result = await runStackedAction({ - actionId, - action: input.action, - ...(input.commitMessage ? { commitMessage: input.commitMessage } : {}), - ...(input.featureBranch ? { featureBranch: input.featureBranch } : {}), - ...(input.filePaths?.length ? { filePaths: [...input.filePaths] } : {}), - // A pull request the action opens is linked to the thread it ran beside. - threadId: thread.id, - }); - if (AsyncResult.isFailure(result)) { - return result; - } - - showGitActionResult({ - type: "success", - title: result.value.toast.title, - description: result.value.toast.description, - prUrl: - result.value.toast.cta.kind === "open_pr" ? result.value.toast.cta.url : undefined, - }); + async function runAction( + actionInput: GitActionRequestInput, + options?: { readonly syncCurrentBranchOnSuccess?: boolean }, + ): Promise { + const actionId = uuidv4(); + return await runSelectedThreadGitMutation( + "run_change_request", + "Running source control action", + async ({ thread, cwd }) => { + const result = await runStackedAction({ + actionId, + action: actionInput.action, + ...(actionInput.commitMessage ? { commitMessage: actionInput.commitMessage } : {}), + ...(actionInput.featureBranch ? { featureBranch: actionInput.featureBranch } : {}), + ...(actionInput.disableCommitSigning ? { disableCommitSigning: true } : {}), + ...(actionInput.filePaths?.length ? { filePaths: [...actionInput.filePaths] } : {}), + // A pull request the action opens is linked to the thread it ran beside. + threadId: thread.id, + }); + if (AsyncResult.isFailure(result)) { + return result; + } - if (result.value.branch.status === "created" && result.value.branch.name) { - const syncResult = await syncSelectedThreadBranchState({ - thread, - cwd, - nextThreadState: { - branch: result.value.branch.name, - worktreePath: selectedThreadWorktreePath, - }, + showGitActionResult({ + type: "success", + title: result.value.toast.title, + description: result.value.toast.description, + prUrl: + result.value.toast.cta.kind === "open_pr" ? result.value.toast.cta.url : undefined, }); - if (AsyncResult.isFailure(syncResult)) { - return AsyncResult.failure(syncResult.cause); + + if (result.value.branch.status === "created" && result.value.branch.name) { + const syncResult = await syncSelectedThreadBranchState({ + thread, + cwd, + nextThreadState: { + branch: result.value.branch.name, + worktreePath: selectedThreadWorktreePath, + }, + }); + if (AsyncResult.isFailure(syncResult)) { + return AsyncResult.failure(syncResult.cause); + } + } else if (options?.syncCurrentBranchOnSuccess) { + const status = await refreshSelectedThreadGitStatus({ quiet: true, cwd }); + if (status?.refName) { + const syncResult = await syncSelectedThreadBranchState({ + thread, + cwd, + nextThreadState: { + branch: status.refName, + worktreePath: selectedThreadWorktreePath, + }, + }); + if (AsyncResult.isFailure(syncResult)) { + return AsyncResult.failure(syncResult.cause); + } + } + } else { + await refreshSelectedThreadGitStatus({ quiet: true, cwd }); } - } else { - await refreshSelectedThreadGitStatus({ quiet: true, cwd }); - } - return result; - }, - { managedExternally: true }, - ); + return result; + }, + { + managedExternally: true, + onFailure: (error) => { + if (actionInput.disableCommitSigning || !isCommitSigningFailure(error)) { + return false; + } + Alert.alert( + "Commit signing failed", + "Git couldn’t sign the commit. Retry this commit without signing?", + [ + { text: "Cancel", style: "cancel" }, + { + text: "Retry without signing", + onPress: () => { + void runAction(buildUnsignedCommitRetryInput(actionInput), { + syncCurrentBranchOnSuccess: actionInput.featureBranch === true, + }); + }, + }, + ], + ); + return true; + }, + }, + ); + } + + return await runAction(input); }, [ runStackedAction, diff --git a/apps/mobile/src/state/use-selected-thread-requests.ts b/apps/mobile/src/state/use-selected-thread-requests.ts index 3e0cbe295936..ba4c16e84871 100644 --- a/apps/mobile/src/state/use-selected-thread-requests.ts +++ b/apps/mobile/src/state/use-selected-thread-requests.ts @@ -17,6 +17,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react"; import { ApprovalRequestId, + type OrchestrationThreadActivity, type ProviderApprovalDecision, type UserInputQuestion, } from "@t3tools/contracts"; @@ -77,7 +78,18 @@ function setUserInputDraftCustomAnswer( }); } -export function useSelectedThreadRequests() { +/** + * Pending approval / user-input requests for the selected thread. + * + * `activities` should be the FULL loaded set (lazy-loaded older pages + the + * windowed live view, i.e. `useThreadComposerState().mergedActivities`): the + * detail snapshot windows activities to the most recent page, so deriving from + * `selectedThread.activities` alone would hide a prompt the user scrolled back + * to load. Falls back to the live window when not provided. Deriving from the + * merged set is sound — resolutions are always newer than their requests, so a + * loaded request whose resolution exists always has that resolution loaded too. + */ +export function useSelectedThreadRequests(activities?: ReadonlyArray) { const respondToApproval = useAtomCommand( threadEnvironment.respondToApproval, "thread approval response", @@ -99,12 +111,16 @@ export function useSelectedThreadRequests() { null, ); + const requestActivities = activities ?? selectedThread?.activities ?? []; const { approvals: activePendingApprovals, userInputs: activePendingUserInputs } = useMemo( - () => derivePendingRequests(selectedThread?.activities ?? []), - [selectedThread?.activities], + () => derivePendingRequests(requestActivities), + [requestActivities], ); - const activePendingApproval = activePendingApprovals[0] ?? null; - const activePendingUserInput = activePendingUserInputs[0] ?? null; + // derivePendingRequests sorts ascending by createdAt; surface the NEWEST + // open request. With lazy-loaded older pages in the set, index 0 could be + // an ancient dangling request hijacking the prompt for the current one. + const activePendingApproval = activePendingApprovals.at(-1) ?? null; + const activePendingUserInput = activePendingUserInputs.at(-1) ?? null; const questionServerConfigs = useServerConfigs(); const attachmentDrafts = useAtomValue(composerDraftsAtom); const preparationCounts = useAtomValue(questionAttachmentPreparationAtom); diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts index 8f10bc92acf8..22ad1f213429 100644 --- a/apps/mobile/src/state/use-thread-composer-state.ts +++ b/apps/mobile/src/state/use-thread-composer-state.ts @@ -14,11 +14,13 @@ import { type ThreadId, } from "@t3tools/contracts"; import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors"; +import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime"; import { parseCodexFeedbackCommand, submitCodexFeedback, type CodexFeedbackSubmission, } from "@t3tools/client-runtime/state/threads"; +import { sendEntersSteeringQueue } from "@t3tools/shared/chatList"; import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming"; import { makeQueuedMessageMetadata } from "../lib/commandMetadata"; @@ -31,8 +33,14 @@ import { pickComposerMedia, } from "../lib/composerImages"; import type { DraftComposerImageAttachment } from "../lib/composerImages"; +import { + defaultFetchAttachmentDataUrl, + describeQueuedAttachmentCapacity, + formatMissingAttachmentsError, + recallQueuedAttachments, +} from "../lib/queuedAttachmentRecall"; import { scopedThreadKey } from "../lib/scopedEntities"; -import { buildThreadFeed } from "../lib/threadActivity"; +import { buildThreadFeed, promoteSteeredQueuedMessages } from "../lib/threadActivity"; import { acknowledgedThreadMessagesAtom } from "./acknowledged-thread-messages"; import { appendPendingThreadMessages } from "../features/threads/pending-thread-feed"; import { appAtomRegistry } from "../state/atom-registry"; @@ -51,10 +59,15 @@ import { updateComposerDraftSettings, useComposerDraft, } from "./use-composer-drafts"; -import { setPendingConnectionError } from "../state/use-remote-environment-registry"; +import { + setPendingConnectionError, + useRemoteConnectionStatus, +} from "../state/use-remote-environment-registry"; +import { useAssetUrls } from "../state/assets"; import { useSelectedThreadDetail } from "../state/use-thread-detail"; import { useThreadSelection } from "../state/use-thread-selection"; import { enqueueThreadOutboxMessage } from "./thread-outbox"; +import { removeThreadOutboxMessage } from "./thread-outbox-removal"; import { dispatchingQueuedMessageIdAtom, useThreadOutboxMessages } from "./use-thread-outbox"; import { threadEnvironment } from "./threads"; import { useAtomCommand } from "./use-atom-command"; @@ -63,6 +76,46 @@ import { composerAttachmentUploadsAtom, } from "./composer-attachment-uploads"; +const EMPTY_MESSAGE_ID_SET: ReadonlySet = new Set(); + +/** Set-minus that keeps the current reference when nothing was removed. */ +function pruneSteeringQueuedMessageIds( + current: ReadonlySet, + resolved: ReadonlySet, +): ReadonlySet { + if (current.size === 0 || resolved.size === 0) { + return current; + } + const next = new Set(); + for (const messageId of current) { + if (!resolved.has(messageId)) { + next.add(messageId); + } + } + return next.size === current.size ? current : next; +} + +/** + * Steered ids the server no longer holds in the queue. That is the settle + * signal for the optimistic overlay: dispatched (now a real message) or gone. + */ +function resolvedSteeredMessageIds( + steering: ReadonlySet, + queuedMessages: ReadonlyArray<{ readonly messageId: MessageId }> | undefined, +): ReadonlySet { + if (steering.size === 0) { + return EMPTY_MESSAGE_ID_SET; + } + const stillQueued = new Set((queuedMessages ?? []).map((message) => message.messageId)); + const resolved = new Set(); + for (const messageId of steering) { + if (!stillQueued.has(messageId)) { + resolved.add(messageId); + } + } + return resolved; +} + export function appendReviewCommentToDraft(input: { readonly environmentId: EnvironmentId; readonly threadId: ThreadId; @@ -111,6 +164,11 @@ export function useThreadComposerState() { const composerDrafts = useAtomValue(composerDraftsAtom); const acknowledgedMessages = useAtomValue(acknowledgedThreadMessagesAtom); const queuedMessagesByThreadKey = useThreadOutboxMessages(); + const { connectedEnvironments } = useRemoteConnectionStatus(); + // Server-queued messages the user sent now, until the dispatch lands (or a + // failure puts them back in the queue). + const [steeringQueuedMessageIds, setSteeringQueuedMessageIds] = + useState>(EMPTY_MESSAGE_ID_SET); const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom); const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState< Record> @@ -128,6 +186,23 @@ export function useThreadComposerState() { : null; // The creation entry is the thread itself (rendered as the first message), // not a follow-up waiting behind it. + + // Resolved once the server stops listing it as queued: the dispatch landed + // and it is a real timeline message from here on, so stop overlaying it. + const serverQueuedMessages = selectedThreadDetail?.queuedMessages; + useEffect(() => { + setSteeringQueuedMessageIds((existing) => + pruneSteeringQueuedMessageIds( + existing, + resolvedSteeredMessageIds(existing, serverQueuedMessages), + ), + ); + }, [serverQueuedMessages]); + + // Optimistic overlays never survive a thread switch. + useEffect(() => { + setSteeringQueuedMessageIds(EMPTY_MESSAGE_ID_SET); + }, [selectedThreadKey]); const selectedThreadQueuedMessages = useMemo( () => selectedThreadKey @@ -137,6 +212,23 @@ export function useThreadComposerState() { : [], [queuedMessagesByThreadKey, selectedThreadKey], ); + const steerQueuedMessage = useAtomCommand(threadEnvironment.steerQueuedMessage, { + label: "steer queued message", + }); + const removeServerQueuedMessage = useAtomCommand(threadEnvironment.removeQueuedMessage, { + label: "remove queued message", + }); + // "Send now" promotes a queued message into the conversation before the + // server confirms the dispatch; the chip goes with it. See + // promoteSteeredQueuedMessages. + const steeredDetail = useMemo( + () => + selectedThreadDetail + ? promoteSteeredQueuedMessages(selectedThreadDetail, steeringQueuedMessageIds) + : selectedThreadDetail, + [selectedThreadDetail, steeringQueuedMessageIds], + ); + const feedbackSubmissions = useMemo( () => (selectedThreadKey ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? []) : []), [feedbackSubmissionsByThreadKey, selectedThreadKey], @@ -151,23 +243,27 @@ export function useThreadComposerState() { }, [selectedThreadKey], ); - const selectedThreadMessages = selectedThreadDetail?.messages; - const selectedThreadActivities = selectedThreadDetail?.activities; + const selectedThreadMessages = steeredDetail?.messages; + const selectedThreadActivities = steeredDetail?.activities; // A thread whose creation has not delivered its turn yet: the prompt only // exists in the outbox, so it is appended to whatever the server has. The // detail is usually present but empty during a worktree checkout, so this // cannot be an either/or with the loaded messages. const pendingCreationMessage = selectedThreadCreation?.message ?? null; const selectedThreadFeed = useMemo(() => { - const loadedMessages = selectedThreadMessages ?? []; const feed = (selectedThreadMessages && selectedThreadActivities) || pendingCreationMessage !== null ? buildThreadFeed({ - messages: - pendingCreationMessage !== null && - !loadedMessages.some((message) => message.id === pendingCreationMessage.messageId) - ? [...loadedMessages, pendingThreadCreationMessage(pendingCreationMessage)] - : loadedMessages, + messages: selectedThreadMessages + ? pendingCreationMessage !== null && + !selectedThreadMessages.some( + (message) => message.id === pendingCreationMessage.messageId, + ) + ? [...selectedThreadMessages, pendingThreadCreationMessage(pendingCreationMessage)] + : selectedThreadMessages + : pendingCreationMessage !== null + ? [pendingThreadCreationMessage(pendingCreationMessage)] + : [], activities: selectedThreadActivities ?? [], }) : []; @@ -200,11 +296,59 @@ export function useThreadComposerState() { } }, [acknowledgedMessages, selectedThreadMessages]); + const composerQueueItems = useMemo(() => { + type QueueItem = { + readonly messageId: MessageId; + readonly text: string; + readonly attachmentCount: number; + readonly deliveryState: "waiting" | "sending" | "queued"; + readonly queueSource: "local" | "server"; + readonly sortAt: string; + }; + const byId = new Map(); + // Includes optimistically steered messages, so their chips go immediately. + const timelineIds = new Set(steeredDetail?.messages.map((message) => message.id) ?? []); + + for (const message of steeredDetail?.queuedMessages ?? []) { + if (timelineIds.has(message.messageId)) continue; + byId.set(message.messageId, { + messageId: message.messageId, + text: message.text, + attachmentCount: message.attachments.length, + deliveryState: "queued", + queueSource: "server", + sortAt: message.queuedAt, + }); + } + + // Local outbox wins for the same id until the ack removes it (sending → + // queued transition without a double chip). + for (const message of selectedThreadQueuedMessages) { + if (timelineIds.has(message.messageId)) continue; + byId.set(message.messageId, { + messageId: message.messageId, + text: message.text, + attachmentCount: message.attachments.length, + queueSource: "local", + deliveryState: connectedEnvironments.some( + (environment) => + environment.environmentId === message.environmentId && + environment.connectionState === "connected", + ) + ? "sending" + : "waiting", + sortAt: message.createdAt, + }); + } + + return Array.from(byId.values()).sort((left, right) => left.sortAt.localeCompare(right.sortAt)); + }, [connectedEnvironments, steeredDetail, selectedThreadQueuedMessages]); + const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null; const draftMessage = selectedDraft?.text ?? ""; const draftAttachments = selectedDraft?.attachments ?? []; - const selectedThreadQueueCount = selectedThreadQueuedMessages.length; const selectedThread = selectedThreadDetail ?? selectedThreadShell; + const selectedThreadQueueCount = selectedThreadQueuedMessages.length; const modelSelection = selectedDraft?.modelSelection ?? selectedThread?.modelSelection ?? null; const runtimeMode = selectedDraft?.runtimeMode ?? selectedThread?.runtimeMode ?? null; const selectedProvider = selectedEnvironmentRuntime?.serverConfig?.providers.find( @@ -284,6 +428,15 @@ export function useThreadComposerState() { ); }, [selectedThreadDetail, selectedThreadSessionActivity, selectedThreadShell]); + // A send made now would be held in the steering queue rather than opening a + // turn, so it becomes a composer chip and must not move the feed. Threads on + // this screen already exist server-side, so no send here is a bootstrap. + const sendEntersQueue = sendEntersSteeringQueue({ + hasBootstrap: false, + sessionStatus: selectedThread?.session?.status, + hasPendingTurnStart: (selectedThreadDetail?.pendingTurnStart ?? null) !== null, + }); + const onSendMessage = useCallback(async () => { if (!selectedThreadShell) { return null; @@ -385,11 +538,9 @@ export function useThreadComposerState() { const metadata = makeQueuedMessageMetadata(); const messageId = MessageId.make(metadata.messageId); - // Enqueue publishes the queued atom synchronously (the durable write - // happens behind it), so clearing the draft here gives send feedback on - // the tap frame instead of after file I/O. If the write fails the message - // is rolled out of the queue and the content is merged back into the - // draft, preserving anything typed since. + // Enqueue updates the in-memory outbox synchronously so the feed can paint + // "Sending" before disk I/O finishes. Clear the draft in the same turn and + // return immediately — durability trails off the critical path. const enqueuePromise = enqueueThreadOutboxMessage({ environmentId: selectedThreadShell.environmentId, threadId: selectedThreadShell.id, @@ -435,6 +586,141 @@ export function useThreadComposerState() { uploadThreadFeedback, ]); + const onSteerQueuedMessage = useCallback( + async (messageId: MessageId) => { + if (!selectedThreadShell || steeringQueuedMessageIds.has(messageId)) { + return; + } + // Into the conversation up front; the chip goes with it. + setSteeringQueuedMessageIds((existing) => new Set(existing).add(messageId)); + const result = await steerQueuedMessage({ + environmentId: selectedThreadShell.environmentId, + input: { threadId: selectedThreadShell.id, messageId }, + }); + if (result._tag === "Success") { + return; + } + // Back to the queue. The decider rejects a steer that races a pending + // turn start, so this is a reachable path, not just transport failure. + // Interruption reverts too — a steer that did land re-settles on the + // next projection. + setSteeringQueuedMessageIds((existing) => + pruneSteeringQueuedMessageIds(existing, new Set([messageId])), + ); + if (!isAtomCommandInterrupted(result)) { + setPendingConnectionError("Failed to send the queued message now."); + } + }, + [selectedThreadShell, steerQueuedMessage, steeringQueuedMessageIds], + ); + + // Server-queued attachments are resolved up front so editing one can put its + // pictures back in the composer; the bytes only exist behind a signed URL. + const serverQueuedAttachmentIds = useMemo(() => { + const attachmentIds = new Set(); + for (const queued of serverQueuedMessages ?? []) { + for (const attachment of queued.attachments) { + attachmentIds.add(attachment.id); + } + } + return [...attachmentIds]; + }, [serverQueuedMessages]); + const serverQueuedAttachmentResources = useMemo( + () => + serverQueuedAttachmentIds.map((attachmentId) => ({ + _tag: "attachment" as const, + attachmentId, + })), + [serverQueuedAttachmentIds], + ); + const serverQueuedAttachmentUrls = useAssetUrls( + selectedThreadShell?.environmentId ?? null, + serverQueuedAttachmentResources, + ); + const serverQueuedAttachmentUrlById = useMemo( + () => + new Map( + serverQueuedAttachmentIds.flatMap((attachmentId, index) => { + const url = serverQueuedAttachmentUrls[index]; + return url ? [[attachmentId, url] as const] : []; + }), + ), + [serverQueuedAttachmentIds, serverQueuedAttachmentUrls], + ); + + const onEditQueuedMessage = useCallback( + async (messageId: MessageId, source: "local" | "server") => { + if (!selectedThreadShell) { + return; + } + const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id); + if (source === "local") { + const message = selectedThreadQueuedMessages.find( + (candidate) => candidate.messageId === messageId, + ); + if (!message) return; + try { + await removeThreadOutboxMessage(message); + } catch (error) { + setPendingConnectionError( + error instanceof Error + ? error.message + : "Failed to remove the queued message for editing.", + ); + return; + } + setComposerDraftText(threadKey, message.text); + if (message.attachments.length > 0) { + appendComposerDraftAttachments(threadKey, message.attachments); + } + } else { + const message = selectedThreadDetail?.queuedMessages.find( + (candidate) => candidate.messageId === messageId, + ); + if (!message) return; + // Removing a queued message deletes its attachment files on the server, + // so everything that could lose a picture happens before the removal and + // backs out of the whole edit instead. + const capacityError = describeQueuedAttachmentCapacity( + message.attachments.length, + getComposerDraftSnapshot(threadKey).attachments.length, + ); + if (capacityError !== null) { + setPendingConnectionError(capacityError); + return; + } + const recalled = await recallQueuedAttachments(message.attachments, { + urlById: serverQueuedAttachmentUrlById, + fetchDataUrl: defaultFetchAttachmentDataUrl, + }); + // Signed URLs resolve asynchronously, so an edit tapped early — or one + // that hits a network blip — finds nothing to read. Leave the message + // queued: it and its pictures are intact, and the edit can be retried. + const missingError = formatMissingAttachmentsError(recalled.missing); + if (missingError !== null) { + setPendingConnectionError(missingError); + return; + } + const result = await removeServerQueuedMessage({ + environmentId: selectedThreadShell.environmentId, + input: { threadId: selectedThreadShell.id, messageId }, + }); + if (result._tag !== "Success") return; + setComposerDraftText(threadKey, message.text); + if (recalled.images.length > 0) { + appendComposerDraftAttachments(threadKey, recalled.images); + } + } + }, + [ + removeServerQueuedMessage, + selectedThreadDetail, + selectedThreadQueuedMessages, + selectedThreadShell, + serverQueuedAttachmentUrlById, + ], + ); + const onChangeDraftMessage = useCallback( (value: string) => { if (!selectedThreadShell) { @@ -617,6 +903,7 @@ export function useThreadComposerState() { dismissFeedback, selectedThreadFeed, selectedThreadQueueCount, + composerQueueItems, selectedThreadQueuedMessages, dispatchingQueuedMessageId, activeWorkStartedAt, @@ -626,6 +913,7 @@ export function useThreadComposerState() { modelSelection, runtimeMode, interactionMode, + sendEntersQueue, onChangeDraftMessage, onPickDraftMedia, onPickDraftFiles, @@ -633,6 +921,8 @@ export function useThreadComposerState() { onNativePasteImages, onRemoveDraftImage, onSendMessage, + onSteerQueuedMessage, + onEditQueuedMessage, onUpdateModelSelection, onUpdateRuntimeMode, onUpdateInteractionMode, diff --git a/apps/mobile/src/state/use-thread-outbox-drain.ts b/apps/mobile/src/state/use-thread-outbox-drain.ts index 7388037a5593..552a1576f414 100644 --- a/apps/mobile/src/state/use-thread-outbox-drain.ts +++ b/apps/mobile/src/state/use-thread-outbox-drain.ts @@ -55,7 +55,7 @@ import { type QueuedThreadMessage, type ThreadOutboxCommandStage, } from "./thread-outbox-model"; -import { environmentThreadShells, threadEnvironment } from "./threads"; +import { threadEnvironment } from "./threads"; import { appendComposerDraftAttachments, composerDraftsAtom, @@ -560,6 +560,18 @@ export function useThreadOutboxDrain(): void { const retryAttemptRef = useRef(new Map()); const retryNotBeforeRef = useRef(new Map()); const retryTimersRef = useRef(new Map>()); + // Keep large snapshots off the effect dep list so shell/connection identity + // thrash does not re-enter the drain. Content fingerprints gate the effect. + const threadsRef = useRef(threads); + const projectsRef = useRef(projects); + const connectedEnvironmentsRef = useRef(connectedEnvironments); + const shellStatusesRef = useRef(shellStatuses); + threadsRef.current = threads; + projectsRef.current = projects; + connectedEnvironmentsRef.current = connectedEnvironments; + shellStatusesRef.current = shellStatuses; + + const mountedRef = useRef(true); const acknowledgedExistingThreadMessageIdsRef = useRef(new Set()); const blockedRecoverySubscriptionsRef = useRef( new Map< @@ -568,22 +580,31 @@ export function useThreadOutboxDrain(): void { >(), ); - const scheduleQueuedMessageRetry = useCallback((messageId: MessageId) => { - const retryAttempt = (retryAttemptRef.current.get(messageId) ?? 0) + 1; - retryAttemptRef.current.set(messageId, retryAttempt); - const retryDelayMs = threadOutboxRetryDelayMs(retryAttempt); - retryNotBeforeRef.current.set(messageId, Date.now() + retryDelayMs); + const scheduleDeferredRetry = useCallback((messageId: MessageId, delayMs: number) => { + retryNotBeforeRef.current.set(messageId, Date.now() + delayMs); const pendingTimer = retryTimersRef.current.get(messageId); if (pendingTimer !== undefined) { clearTimeout(pendingTimer); } const retryTimer = setTimeout(() => { retryTimersRef.current.delete(messageId); + if (!mountedRef.current) { + return; + } setRetryTick((current) => current + 1); - }, retryDelayMs); + }, delayMs); retryTimersRef.current.set(messageId, retryTimer); }, []); + const scheduleQueuedMessageRetry = useCallback( + (messageId: MessageId) => { + const retryAttempt = (retryAttemptRef.current.get(messageId) ?? 0) + 1; + retryAttemptRef.current.set(messageId, retryAttempt); + scheduleDeferredRetry(messageId, threadOutboxRetryDelayMs(retryAttempt)); + }, + [scheduleDeferredRetry], + ); + const restoreQueuedMessage = useCallback( async (queuedMessage: QueuedThreadMessage, message: string): Promise => { const result = await restoreRejectedQueuedMessage(queuedMessage, message); @@ -626,9 +647,9 @@ export function useThreadOutboxDrain(): void { ); useEffect(() => { - let mounted = true; + mountedRef.current = true; const load = async () => { - if ((await threadOutboxManager.load()) || !mounted) return; + if ((await threadOutboxManager.load()) || !mountedRef.current) return; Alert.alert( "Some queued messages could not be loaded", "Unreadable records and attachment files are still saved. Other messages can still be sent.", @@ -640,7 +661,7 @@ export function useThreadOutboxDrain(): void { }; void load(); return () => { - mounted = false; + mountedRef.current = false; for (const timer of retryTimersRef.current.values()) { clearTimeout(timer); } @@ -962,6 +983,22 @@ export function useThreadOutboxDrain(): void { [makeDeliveryHelpers, restoreQueuedMessage, startTurn], ); + const outboxKey = Object.entries(queuedMessagesByThreadKey) + .map(([threadKey, messages]) => `${threadKey}:${messages.length}`) + .sort() + .join(","); + const connectedEnvKey = connectedEnvironments + .map((environment) => `${environment.environmentId}:${environment.connectionState}`) + .sort() + .join(","); + const shellStatusKey = + shellStatuses instanceof Map + ? [...shellStatuses.entries()] + .map(([environmentId, status]) => `${environmentId}:${status}`) + .sort() + .join(",") + : ""; + const editingKey = Object.keys(editingQueuedMessageIds).sort().join(","); // A creation outcome bridges setup until the server's shell has a turn. // Drop it once that happens so the map cannot grow for a whole session; a // failed outcome stays until its thread screen consumes it. @@ -990,6 +1027,14 @@ export function useThreadOutboxDrain(): void { if (dispatchingQueuedMessageId !== null) { return; } + if (outboxKey === "") { + return; + } + + const threadsNow = threadsRef.current; + const projectsNow = projectsRef.current; + const connectedEnvironmentsNow = connectedEnvironmentsRef.current; + const shellStatusesNow = shellStatusesRef.current; const queuedMessageIds = new Set( Object.values(queuedMessagesByThreadKey) @@ -1052,22 +1097,21 @@ export function useThreadOutboxDrain(): void { continue; } - const thread = findThread(threads, nextQueuedMessage); + const thread = findThread(threadsNow, nextQueuedMessage); if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) { continue; } const creation = nextQueuedMessage.creation; - const environment = connectedEnvironments.find( + const environment = connectedEnvironmentsNow.find( (candidate) => candidate.environmentId === nextQueuedMessage.environmentId, ); - const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty"; + const shellStatus = shellStatusesNow.get(nextQueuedMessage.environmentId) ?? "empty"; const deliveryAction = resolveThreadOutboxDeliveryAction({ isCreation: creation !== undefined, threadExists: thread !== undefined, shellStatus, environmentConnected: environment?.connectionState === "connected", - threadBusy: thread?.session?.status === "running" || thread?.session?.status === "starting", }); // The delivery action resolves first; capability checks apply only to // a message that will send. Checking earlier would restore a @@ -1121,7 +1165,7 @@ export function useThreadOutboxDrain(): void { // just because its project shell is not loaded. const creationProjectCwd = creation !== undefined - ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ?? + ? (findCreationProject(projectsNow, nextQueuedMessage)?.workspaceRoot ?? creation.projectCwd ?? null) : null; @@ -1137,9 +1181,10 @@ export function useThreadOutboxDrain(): void { } beginDispatchingQueuedMessage(nextQueuedMessage.messageId); - const removeQueuedMessage = (warning: string) => + type DrainOutcome = "delivered" | "deferred" | "failed"; + const removeQueuedMessage = (warning: string): Promise => removeThreadOutboxMessage(nextQueuedMessage).then( - () => true, + () => "delivered" as const, (error) => { console.warn(warning, { environmentId: nextQueuedMessage.environmentId, @@ -1147,65 +1192,50 @@ export function useThreadOutboxDrain(): void { messageId: nextQueuedMessage.messageId, error, }); - return false; + return "failed" as const; }, ); // Enqueues publish optimistically before their durable write settles. // Confirm the write landed (and the message wasn't rolled back) before // sending, so a failed write can never chase an already-delivered turn. - const delivery = confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => { - if (!queued) { - // Rolled back by a failed write; nothing to deliver or retry. - return true; - } - // The guards evaluated before the confirmation await are stale by now: - // the user may have opened this message in the editor. Re-read that - // guard and defer to the next drain pass (returning true skips the - // failure/backoff path) rather than sending a payload being edited. - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[nextQueuedMessage.messageId]) { - return true; - } - // The shell state is equally stale. Re-run the same delivery policy - // against the live thread snapshot so a vanished thread or newly - // created target defers, while busy existing threads can still steer. - if (deliveryAction === "send") { - const liveThread = findThread( - appAtomRegistry.get(environmentThreadShells.threadShellsAtom), - nextQueuedMessage, - ); - const liveThreadBusy = - liveThread?.session?.status === "running" || liveThread?.session?.status === "starting"; - const liveDeliveryAction = resolveThreadOutboxDeliveryAction({ - isCreation: creation !== undefined, - threadExists: liveThread !== undefined, - shellStatus, - environmentConnected: environment?.connectionState === "connected", - threadBusy: liveThreadBusy, - }); - if (liveDeliveryAction !== "send") { - return true; + const delivery = confirmThreadOutboxMessageQueued(nextQueuedMessage).then( + async (queued): Promise => { + if (!queued) { + // Rolled back by a failed write; nothing to deliver or retry. + return "delivered"; } - } - return deliveryAction === "remove" - ? creation !== undefined - ? // A creation entry that survived its delivery cleanup either - // holds edits (recover them) or the delivered payload (a - // recovered duplicate the user can delete). Restart loses any - // in-memory distinction, and losing edits is the worse failure, - // so recovery is unconditional here. - recoverEditedCreationAfterDelivery(nextQueuedMessage) - : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread") - : creation !== undefined - ? creationProjectCwd !== null - ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd) - : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project") - : thread !== undefined - ? sendQueuedMessage(nextQueuedMessage, thread) - : Promise.resolve(false); - }); + // Editor hold: defer with backoff. Do NOT report success (that cleared + // retry state and spun beginDispatch → finish → effect forever). + // Mid-turn is an intentional send: ownership belongs to the server, + // which queues follow-ups during an active turn. Upstream gated this + // on threadBusy until #6543 removed that guard and matched us. + if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[nextQueuedMessage.messageId]) { + return "deferred"; + } + if (deliveryAction === "remove") { + return removeQueuedMessage( + "[thread-outbox] failed to remove message for a missing thread", + ); + } + if (creation !== undefined) { + if (creationProjectCwd === null) { + return removeQueuedMessage( + "[thread-outbox] dropped pending task for a missing project", + ); + } + const ok = await sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd); + return ok ? "delivered" : "failed"; + } + if (thread === undefined) { + return "failed"; + } + const ok = await sendQueuedMessage(nextQueuedMessage, thread); + return ok ? "delivered" : "failed"; + }, + ); void delivery - .then((sent) => { - if (sent) { + .then((outcome) => { + if (outcome === "delivered") { retryAttemptRef.current.delete(nextQueuedMessage.messageId); retryNotBeforeRef.current.delete(nextQueuedMessage.messageId); const pendingTimer = retryTimersRef.current.get(nextQueuedMessage.messageId); @@ -1216,7 +1246,33 @@ export function useThreadOutboxDrain(): void { return; } - scheduleQueuedMessageRetry(nextQueuedMessage.messageId); + if (outcome === "deferred") { + // Editor hold: short pause so we cannot spin + // beginDispatch → microtask → finish → effect → begin. + scheduleDeferredRetry(nextQueuedMessage.messageId, 500); + return; + } + + const retryAttempt = (retryAttemptRef.current.get(nextQueuedMessage.messageId) ?? 0) + 1; + retryAttemptRef.current.set(nextQueuedMessage.messageId, retryAttempt); + scheduleDeferredRetry( + nextQueuedMessage.messageId, + threadOutboxRetryDelayMs(retryAttempt), + ); + }) + .catch((error) => { + console.warn("[thread-outbox] drain delivery threw", { + environmentId: nextQueuedMessage.environmentId, + threadId: nextQueuedMessage.threadId, + messageId: nextQueuedMessage.messageId, + error, + }); + const retryAttempt = (retryAttemptRef.current.get(nextQueuedMessage.messageId) ?? 0) + 1; + retryAttemptRef.current.set(nextQueuedMessage.messageId, retryAttempt); + scheduleDeferredRetry( + nextQueuedMessage.messageId, + threadOutboxRetryDelayMs(retryAttempt), + ); }) .finally(() => { finishDispatchingQueuedMessage(nextQueuedMessage.messageId); @@ -1224,18 +1280,18 @@ export function useThreadOutboxDrain(): void { return; } }, [ - connectedEnvironments, + connectedEnvKey, dispatchingQueuedMessageId, + editingKey, editingQueuedMessageIds, - projects, + outboxKey, queuedMessagesByThreadKey, retryTick, restoreQueuedMessage, + scheduleDeferredRetry, scheduleQueuedMessageRetry, sendQueuedCreation, sendQueuedMessage, - serverConfigs, - shellStatuses, - threads, + shellStatusKey, ]); } diff --git a/apps/mobile/src/state/use-thread-outbox.ts b/apps/mobile/src/state/use-thread-outbox.ts index e8599e1ecbb7..869a0889a068 100644 --- a/apps/mobile/src/state/use-thread-outbox.ts +++ b/apps/mobile/src/state/use-thread-outbox.ts @@ -7,6 +7,29 @@ import { appAtomRegistry } from "./atom-registry"; import { environmentShell } from "./shell"; import { threadOutboxManager } from "./thread-outbox"; +/** + * Stable empty map so an empty outbox does not allocate a new Map on every + * shell tick (that was enough to keep ThreadOutboxDrainWorker re-rendering). + */ +const EMPTY_THREAD_OUTBOX_SHELL_STATUSES: ReadonlyMap = + new Map(); + +let cachedThreadOutboxShellStatuses: ReadonlyMap = + EMPTY_THREAD_OUTBOX_SHELL_STATUSES; +let cachedThreadOutboxShellStatusesKey = ""; + +function shellStatusesFingerprint( + statuses: ReadonlyMap, +): string { + if (statuses.size === 0) { + return ""; + } + return [...statuses.entries()] + .map(([environmentId, status]) => `${environmentId}:${status}`) + .sort() + .join("|"); +} + const threadOutboxShellStatusesAtom = Atom.make( (get): ReadonlyMap => { const statuses = new Map(); @@ -16,6 +39,17 @@ const threadOutboxShellStatusesAtom = Atom.make( statuses.set(environmentId, get(environmentShell.stateValueAtom(environmentId)).status); } } + if (statuses.size === 0) { + cachedThreadOutboxShellStatuses = EMPTY_THREAD_OUTBOX_SHELL_STATUSES; + cachedThreadOutboxShellStatusesKey = ""; + return EMPTY_THREAD_OUTBOX_SHELL_STATUSES; + } + const key = shellStatusesFingerprint(statuses); + if (key === cachedThreadOutboxShellStatusesKey) { + return cachedThreadOutboxShellStatuses; + } + cachedThreadOutboxShellStatusesKey = key; + cachedThreadOutboxShellStatuses = statuses; return statuses; }, ).pipe(Atom.withLabel("mobile:thread-outbox:shell-statuses")); diff --git a/apps/mobile/src/state/use-thread-pr.ts b/apps/mobile/src/state/use-thread-pr.ts index c903abbb07f2..d4aa250d2c79 100644 --- a/apps/mobile/src/state/use-thread-pr.ts +++ b/apps/mobile/src/state/use-thread-pr.ts @@ -17,6 +17,7 @@ import { presentThreadPr, type ThreadPrPresentation, } from "./thread-pr-presentation"; +import { vcsEnvironment } from "./vcs"; const pullRequestSummaryAtom = createLinkedPullRequestSummaryAtomFamily(connectionAtomRuntime); const MAX_THREAD_PR_SNAPSHOTS = 500; @@ -27,7 +28,7 @@ interface ThreadPrSnapshot { } // One bounded cache survives row virtualization without retaining one live -// atom for every thread or pull request ever seen. +// atom for every thread, branch, directory, or linked pull request ever seen. const threadPrSnapshotsAtom = Atom.make>(new Map()).pipe( Atom.keepAlive, Atom.withLabel("mobile:thread-pr-snapshots"), @@ -40,10 +41,16 @@ export { } from "./thread-pr-presentation"; /** - * Linked PRs use server snapshots. Branch fallback and legacy references share - * a live summary request across visible rows in the same environment. + * Linked PRs use server snapshots. Visible rows share a summary request for + * the same PR in the same environment. When the server has not linked a PR, + * list rows may still pass a project cwd so unlinked branches can fall back + * to a budgeted git status query. */ -export function useThreadPr(thread: EnvironmentThreadShell): ThreadPrPresentation | null { +export function useThreadPr( + thread: EnvironmentThreadShell, + projectCwd?: string | null, +): ThreadPrPresentation | null { + const cwd = thread.worktreePath ?? projectCwd ?? null; const supportsLinks = useAtomValue( serverEnvironment.configValueAtom(thread.environmentId), (config) => config?.environment.capabilities.threadPullRequests === true, @@ -61,7 +68,7 @@ export function useThreadPr(thread: EnvironmentThreadShell): ThreadPrPresentatio [thread.pullRequests, thread.linkedPullRequest, thread.branchPullRequest, supportsLinks], ); const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)); - const snapshotIdentity = JSON.stringify(pullRequestRef); + const snapshotIdentity = JSON.stringify(pullRequestRef ?? { branch: thread.branch, cwd }); // Select this row's entry so writes for other rows do not re-render it. const snapshotEntry = useAtomValue( threadPrSnapshotsAtom, @@ -71,6 +78,14 @@ export function useThreadPr(thread: EnvironmentThreadShell): ThreadPrPresentatio ), ); const snapshot = snapshotEntry?.identity === snapshotIdentity ? snapshotEntry.presentation : null; + const gitStatus = useEnvironmentQuery( + pullRequestRef === null && thread.branch !== null && cwd !== null + ? vcsEnvironment.listStatus({ + environmentId: thread.environmentId, + input: { cwd }, + }) + : null, + ); const pullRequestSummary = useEnvironmentQuery( pullRequestRef === null ? null @@ -85,16 +100,23 @@ export function useThreadPr(thread: EnvironmentThreadShell): ThreadPrPresentatio ); const live = useMemo(() => { - if (pullRequestRef === null) return null; - const summary = pullRequestSummary.data; - return summary === null - ? undefined - : presentThreadPr(pullRequestDetailToVcsStatus(summary), { - kind: summary.provider, - name: summary.provider, - baseUrl: "", - }); - }, [pullRequestRef, pullRequestSummary.data]); + if (pullRequestRef !== null) { + const summary = pullRequestSummary.data; + return summary === null + ? undefined + : presentThreadPr(pullRequestDetailToVcsStatus(summary), { + kind: summary.provider, + name: summary.provider, + baseUrl: "", + }); + } + + if (thread.branch === null || cwd === null) return null; + const status = gitStatus.data; + if (status === null) return undefined; + if (status.refName !== thread.branch || !status.pr) return null; + return presentThreadPr(status.pr, status.sourceControlProvider); + }, [cwd, gitStatus.data, pullRequestRef, pullRequestSummary.data, thread.branch]); useEffect(() => { if (live === undefined) return; diff --git a/apps/mobile/src/state/useAiUsageSnapshot.ts b/apps/mobile/src/state/useAiUsageSnapshot.ts new file mode 100644 index 000000000000..bbe22e97f80e --- /dev/null +++ b/apps/mobile/src/state/useAiUsageSnapshot.ts @@ -0,0 +1,12 @@ +import type { AiUsageSnapshot, EnvironmentId } from "@t3tools/contracts"; + +import { aiUsageEnvironment } from "./aiUsage"; +import { useEnvironmentQuery } from "./query"; + +/** Subscribe to an environment's AI-usage snapshot (null until available). */ +export function useAiUsageSnapshot(environmentId: EnvironmentId | null): AiUsageSnapshot | null { + const query = useEnvironmentQuery( + environmentId === null ? null : aiUsageEnvironment.snapshot({ environmentId, input: {} }), + ); + return query.data ?? null; +} diff --git a/apps/mobile/src/state/useHostResourceSnapshot.ts b/apps/mobile/src/state/useHostResourceSnapshot.ts new file mode 100644 index 000000000000..ba66f1a80021 --- /dev/null +++ b/apps/mobile/src/state/useHostResourceSnapshot.ts @@ -0,0 +1,21 @@ +import type { EnvironmentId } from "@t3tools/contracts"; +import { useEffect } from "react"; + +import { useEnvironmentQuery } from "./query"; +import { serverEnvironment } from "./server"; + +const HOST_RESOURCE_POLL_INTERVAL_MS = 10_000; + +export function useHostResourceSnapshot(environmentId: EnvironmentId, connected: boolean) { + const query = useEnvironmentQuery( + connected ? serverEnvironment.hostResourceSnapshot({ environmentId, input: {} }) : null, + ); + + useEffect(() => { + if (!connected) return; + const interval = setInterval(query.refresh, HOST_RESOURCE_POLL_INTERVAL_MS); + return () => clearInterval(interval); + }, [connected, query.refresh]); + + return query; +} diff --git a/apps/server/docs/t3-agent-rules.md b/apps/server/docs/t3-agent-rules.md new file mode 100644 index 000000000000..a59880a1e2b6 --- /dev/null +++ b/apps/server/docs/t3-agent-rules.md @@ -0,0 +1,23 @@ +# T3 agent rules (global — all surfaces) + +**Layer:** product-wide base rules for every T3 session (web, desktop, mobile, +Discord, GitHub, Jira). Project `AGENTS.md` / `CLAUDE.md` still own repo-local +conventions. + +Delivery: the T3 server injects a **file pointer** to this document on the first +turn of each provider session, and again after context compaction. Read the file; +do not expect the body inline in the prompt. + +Client overlays (e.g. Discord `apps/discord-bot/docs/agent-turn-rules.md`) add +surface-specific policy only. Put shared policy **here**. + +**Reply surface:** Answer only on the surface this turn started on. Linked +Jira/GitHub/Sentry IDs are context, not a request to post there. Do not add +Jira/Confluence comments or GitHub issue/PR discussion comments unless the +user explicitly asked. Opening a GitHub PR for landable work is allowed. + +**Links:** always markdown hyperlinks `[label](url)` — never bare `https://…` — +in Jira/Confluence comments, PR bodies, handoff notes, and any reply where a URL +should be clickable. Prefer short labels (`[scanner#2036](…)`, `[SA-49](…)`). +Jira API Markdown→ADF often leaves bare URLs as plain text; explicit link syntax +becomes a real hyperlink. diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts index 4d8a384ee997..46e46698f825 100644 --- a/apps/server/integration/OrchestrationEngineHarness.integration.ts +++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts @@ -88,6 +88,7 @@ import { VcsStatusBroadcaster } from "../src/vcs/VcsStatusBroadcaster.ts"; import { GitWorkflowService } from "../src/git/GitWorkflowService.ts"; import * as VcsProcess from "../src/vcs/VcsProcess.ts"; import * as AgentAwarenessRelay from "../src/relay/AgentAwarenessRelay.ts"; +import * as IdentityService from "../src/identity/IdentityService.ts"; import * as PullRequestService from "../src/pullRequest/PullRequestService.ts"; const decodeCodexSettings = Schema.decodeEffect(CodexSettings); @@ -316,6 +317,7 @@ export const makeOrchestrationIntegrationHarness = ( ProjectionPendingApprovalRepositoryLive, checkpointStoreLayer, providerLayer, + providerSessionDirectoryLayer, RuntimeReceiptBusTest, ).pipe( Layer.provideMerge(ThreadBackgroundLiveness.layer), @@ -426,6 +428,7 @@ export const makeOrchestrationIntegrationHarness = ( Layer.provide(persistenceLayer), Layer.provideMerge(RepositoryIdentityResolver.layer), Layer.provideMerge(ServerSettingsService.layerTest()), + Layer.provideMerge(IdentityService.layerWithPeople([])), Layer.provideMerge(ServerConfig.layerTest(workspaceDir, rootDir)), Layer.provideMerge(NodeServices.layer), Layer.provideMerge( diff --git a/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts b/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts index e07681ae153b..5a5a08596def 100644 --- a/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts +++ b/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts @@ -30,6 +30,7 @@ import * as Keybindings from "../src/keybindings.ts"; import { OrchestrationLayerLive } from "../src/orchestration/runtimeLayer.ts"; import * as OrchestrationEngine from "../src/orchestration/Services/OrchestrationEngine.ts"; import * as OrchestrationReactor from "../src/orchestration/Services/OrchestrationReactor.ts"; +import { OrphanSessionRecovery } from "../src/orchestration/Services/OrphanSessionRecovery.ts"; import * as ProjectionSnapshotQuery from "../src/orchestration/Services/ProjectionSnapshotQuery.ts"; import { makeSqlitePersistenceLive } from "../src/persistence/Layers/Sqlite.ts"; import * as ProviderSessionRuntime from "../src/persistence/ProviderSessionRuntime.ts"; @@ -109,12 +110,19 @@ const startupDependencies = Layer.mergeAll( }), ), AnalyticsService.layerTest, + Layer.mock(OrphanSessionRecovery)({ + hasLiveProcess: () => Effect.succeed(false), + settleThread: () => Effect.void, + settleIfOrphan: () => Effect.succeed(false), + settleAllAfterServerRestart: () => Effect.succeed({ settledSessions: 0, settledRuntimes: 0 }), + }), Layer.mock(GitVcsDriver.GitVcsDriver)({}), Layer.succeed(ProviderService.ProviderService, { startSession: () => Effect.die("unused"), sendTurn: () => Effect.die("unused"), compactThread: () => Effect.die("unused"), interruptTurn: () => Effect.die("unused"), + compactSession: () => Effect.die("unused"), respondToRequest: () => Effect.die("unused"), respondToUserInput: () => Effect.die("unused"), stopSession: () => Effect.die("unused"), diff --git a/apps/server/package.json b/apps/server/package.json index 84a8c6a5988b..d6440162d5ce 100644 --- a/apps/server/package.json +++ b/apps/server/package.json @@ -16,7 +16,7 @@ "type": "module", "scripts": { "dev": "node --watch src/bin.ts", - "build:bundle": "vp pack && vp pack src/service-launcher.ts --out-dir dist --no-clean", + "build:bundle": "vp pack --no-clean && vp pack src/service-launcher.ts --out-dir dist --no-clean", "start": "node dist/bin.mjs", "typecheck": "tsc --noEmit", "test": "vp test run" @@ -27,7 +27,7 @@ "@effect/platform-node": "catalog:", "@effect/sql-sqlite-bun": "catalog:", "@ff-labs/fff-node": "0.9.4", - "@opencode-ai/sdk": "^1.3.15", + "@opencode-ai/sdk": "^1.17.13", "effect": "catalog:", "msgpackr-extract": "3.0.4", "node-pty": "^1.1.0", diff --git a/apps/server/scripts/acp-mock-agent.ts b/apps/server/scripts/acp-mock-agent.ts index c923fa401021..8458ac385ad3 100644 --- a/apps/server/scripts/acp-mock-agent.ts +++ b/apps/server/scripts/acp-mock-agent.ts @@ -20,6 +20,7 @@ const emitInterleavedAssistantToolCalls = process.env.T3_ACP_EMIT_INTERLEAVED_ASSISTANT_TOOL_CALLS === "1"; const emitGenericToolPlaceholders = process.env.T3_ACP_EMIT_GENERIC_TOOL_PLACEHOLDERS === "1"; const emitAskQuestion = process.env.T3_ACP_EMIT_ASK_QUESTION === "1"; +const emitExitPlanMode = process.env.T3_ACP_EMIT_EXIT_PLAN_MODE === "1"; const emitXAiAskUserQuestion = process.env.T3_ACP_EMIT_XAI_ASK_USER_QUESTION === "1"; const emitXAiExitPlanMode = process.env.T3_ACP_EMIT_XAI_EXIT_PLAN_MODE === "1"; const emitXAiPlanMdWrite = process.env.T3_ACP_EMIT_XAI_PLAN_MD_WRITE === "1"; @@ -40,6 +41,7 @@ const emitLateUpdateAfterCancel = process.env.T3_ACP_EMIT_LATE_UPDATE_AFTER_CANC const omitXAiPromptCompleteStopReason = process.env.T3_ACP_OMIT_XAI_PROMPT_COMPLETE_STOP_REASON === "1"; const failLoadSession = process.env.T3_ACP_FAIL_LOAD_SESSION === "1"; +const failLoadSessionInvalidParams = process.env.T3_ACP_FAIL_LOAD_SESSION_INVALID_PARAMS === "1"; const emitLoadReplay = process.env.T3_ACP_EMIT_LOAD_REPLAY === "1"; const hangLoadSessionAfterReplay = process.env.T3_ACP_HANG_LOAD_SESSION_AFTER_REPLAY === "1"; const delayLoadSessionAfterReplay = process.env.T3_ACP_DELAY_LOAD_SESSION_AFTER_REPLAY === "1"; @@ -48,9 +50,18 @@ const emitStaleXAiPromptCompleteBeforeSecondHang = process.env.T3_ACP_EMIT_STALE_XAI_PROMPT_COMPLETE_BEFORE_SECOND_HANG === "1"; const emitOverlappingXAiPromptCompleteOutOfOrder = process.env.T3_ACP_EMIT_OVERLAPPING_XAI_PROMPT_COMPLETE_OUT_OF_ORDER === "1"; +/** + * Emulates Grok's prompt queue: a plain prompt waits for the running turn, + * while a prompt carrying `_meta.sendNow` cancels it and runs immediately. + */ +const xAiSendNowQueue = process.env.T3_ACP_XAI_SEND_NOW_QUEUE === "1"; const failPrompt = process.env.T3_ACP_FAIL_PROMPT === "1"; const failSetConfigOption = process.env.T3_ACP_FAIL_SET_CONFIG_OPTION === "1"; const exitOnSetConfigOption = process.env.T3_ACP_EXIT_ON_SET_CONFIG_OPTION === "1"; +const omitModeConfigOption = process.env.T3_ACP_OMIT_MODE_CONFIG_OPTION === "1"; +const exitAfterPrompt = process.env.T3_ACP_EXIT_AFTER_PROMPT === "1"; +/** Lets a test distinguish a crash from a signalled shutdown (128 + signal). */ +const exitAfterPromptCode = Number(process.env.T3_ACP_EXIT_AFTER_PROMPT_CODE ?? "7"); const promptResponseText = process.env.T3_ACP_PROMPT_RESPONSE_TEXT; const initialGrokReasoningEffort = process.env.T3_ACP_INITIAL_GROK_REASONING_EFFORT?.trim() || undefined; @@ -74,8 +85,11 @@ let currentReasoning = "medium"; let currentContext = "272k"; let currentFast = false; let promptCount = 0; +let exitPlanModeEmitted = false; let overlappingFirstPromptId: string | undefined; const cancelledSessions = new Set(); +/** Resolves the running turn when a `sendNow` prompt takes over (see `xAiSendNowQueue`). */ +let cancelRunningSendNowTurn: (() => void) | undefined; function promptIdFromRequestMeta( request: Pick, @@ -88,6 +102,11 @@ function promptIdFromRequestMeta( return typeof promptId === "string" && promptId.length > 0 ? promptId : undefined; } +function sendNowFromRequestMeta(request: Pick): boolean { + const meta = request._meta; + return meta !== null && typeof meta === "object" && meta.sendNow === true; +} + function logExit(reason: string): void { if (!exitLogPath) { return; @@ -113,6 +132,21 @@ process.once("exit", (code) => { logExit(`exit:${code}`); }); +function modeConfigOption(): AcpSchema.SessionConfigOption { + return { + id: "mode", + name: "Mode", + category: "mode", + type: "select", + currentValue: currentModeId, + options: availableModes.map((mode) => ({ + value: mode.id, + name: mode.name, + ...(mode.description ? { description: mode.description } : {}), + })), + }; +} + function configOptions(): ReadonlyArray { if (antigravityProfile) { return [ @@ -136,18 +170,7 @@ function configOptions(): ReadonlyArray { } if (parameterizedModelPicker) { const baseOptions: Array = [ - { - id: "mode", - name: "Mode", - category: "mode", - type: "select", - currentValue: currentModeId, - options: availableModes.map((mode) => ({ - value: mode.id, - name: mode.name, - ...(mode.description ? { description: mode.description } : {}), - })), - }, + ...(omitModeConfigOption ? [] : [modeConfigOption()]), { id: "model", name: "Model", @@ -310,6 +333,16 @@ const availableModes: ReadonlyArray = antigravityProfile name: "Ask", description: "Request permission before making any changes", }, + { + id: "agent", + name: "Agent", + description: "Implement changes with full tool access", + }, + { + id: "plan", + name: "Plan", + description: "Design and plan software systems without implementation", + }, { id: "architect", name: "Architect", @@ -497,6 +530,11 @@ const program = Effect.gen(function* () { if (failLoadSession) { return yield* AcpError.AcpRequestError.internalError("Mock load session failure"); } + if (failLoadSessionInvalidParams) { + return yield* AcpError.AcpRequestError.invalidParams( + "Mock invalid params for session/load", + ); + } if (hangLoadSessionAfterReplay || delayLoadSessionAfterReplay) { emitLoadReplayNotifications(requestedSessionId); yield* agent.client.sessionUpdate({ @@ -531,6 +569,27 @@ const program = Effect.gen(function* () { }), ); + yield* agent.handleSetSessionMode((request) => + Effect.gen(function* () { + const nextModeId = request.modeId.trim(); + if (!nextModeId) { + return yield* AcpError.AcpRequestError.invalidParams("modeId is required", { + method: "session/set_mode", + params: request, + }); + } + currentModeId = nextModeId; + yield* agent.client.sessionUpdate({ + sessionId: request.sessionId || sessionId, + update: { + sessionUpdate: "current_mode_update", + currentModeId, + }, + }); + return {}; + }), + ); + yield* agent.handleSetSessionModel((request) => Effect.gen(function* () { if (!modelState().availableModels.some((model) => model.modelId === request.modelId)) { @@ -547,6 +606,27 @@ const program = Effect.gen(function* () { }), ); + yield* agent.handleSetSessionMode((request) => + Effect.gen(function* () { + const nextModeId = request.modeId.trim(); + if (!nextModeId) { + return yield* AcpError.AcpRequestError.invalidParams("modeId is required", { + method: "session/set_mode", + params: request, + }); + } + currentModeId = nextModeId; + yield* agent.client.sessionUpdate({ + sessionId: request.sessionId, + update: { + sessionUpdate: "current_mode_update", + currentModeId, + }, + }); + return {}; + }), + ); + yield* agent.handleSetSessionConfigOption((request) => Effect.gen(function* () { if (exitOnSetConfigOption) { @@ -617,6 +697,9 @@ const program = Effect.gen(function* () { Effect.gen(function* () { const requestedSessionId = String(request.sessionId ?? sessionId); promptCount += 1; + if (exitAfterPrompt) { + return yield* Effect.sync(() => process.exit(exitAfterPromptCode)); + } if (completeFirstPromptOnCancel && promptCount === 1) { yield* agent.client.sessionUpdate({ @@ -658,6 +741,31 @@ const program = Effect.gen(function* () { return yield* AcpError.AcpRequestError.internalError("Mock prompt failure"); } + if (xAiSendNowQueue) { + if (sendNowFromRequestMeta(request) && cancelRunningSendNowTurn !== undefined) { + // Send now against a running turn: that turn settles as cancelled and + // this prompt is answered instead of waiting for it. + cancelRunningSendNowTurn(); + cancelRunningSendNowTurn = undefined; + writeJsonRpcNotification("session/update", { + sessionId: requestedSessionId, + update: { + sessionUpdate: "agent_message_chunk", + content: { type: "text", text: "steered" }, + }, + }); + return { stopReason: "end_turn" } satisfies AcpSchema.PromptResponse; + } + // Otherwise this prompt becomes the running turn and stays open until a + // send-now prompt supersedes it. `sendNow` on an idle session is a + // no-op, as it is on the real agent. + return yield* Effect.callback((resume) => { + cancelRunningSendNowTurn = () => { + resume(Effect.succeed({ stopReason: "cancelled" })); + }; + }); + } + if (emitStaleXAiPromptCompleteBeforeSecondHang && promptCount === 1) { return { stopReason: "end_turn", @@ -1030,6 +1138,102 @@ const program = Effect.gen(function* () { return { stopReason: "end_turn" }; } + if (emitExitPlanMode && !exitPlanModeEmitted) { + exitPlanModeEmitted = true; + const toolCallId = "exit-plan-mode-1"; + const planMarkdown = "# Mock Grok Plan\n\n- capture exit_plan_mode\n"; + yield* agent.client.sessionUpdate({ + sessionId: requestedSessionId, + update: { + sessionUpdate: "tool_call", + toolCallId: "plan-write-1", + title: "write", + kind: "edit", + status: "completed", + rawInput: { + file_path: `/tmp/mock-session/${requestedSessionId}/plan.md`, + content: planMarkdown, + }, + }, + }); + yield* agent.client.sessionUpdate({ + sessionId: requestedSessionId, + update: { + sessionUpdate: "tool_call", + toolCallId, + title: "Plan: Exit", + kind: "other", + status: "pending", + rawInput: { variant: "ExitPlanMode" }, + _meta: { + "x.ai/tool": { + name: "exit_plan_mode", + kind: "exit_plan", + }, + }, + }, + }); + // Mirror real Grok: auto-allow the tool permission, then reverse-RPC + // `_x.ai/exit_plan_mode` with planContent for client-side approval. + yield* agent.client.requestPermission({ + sessionId: requestedSessionId, + toolCall: { + toolCallId, + title: "Plan: Exit", + kind: "other", + status: "pending", + rawInput: { variant: "ExitPlanMode" }, + _meta: { + "x.ai/tool": { + name: "exit_plan_mode", + kind: "exit_plan", + }, + }, + }, + options: [ + { optionId: permissionOptionIds.allowOnce, name: "Allow once", kind: "allow_once" }, + { optionId: permissionOptionIds.rejectOnce, name: "Reject", kind: "reject_once" }, + ], + }); + const exitPlanResult = yield* agent.client.extRequest("_x.ai/exit_plan_mode", { + sessionId: requestedSessionId, + toolCallId, + planContent: planMarkdown, + }); + const outcome = + typeof exitPlanResult === "object" && + exitPlanResult !== null && + "outcome" in exitPlanResult && + typeof (exitPlanResult as { outcome?: unknown }).outcome === "string" + ? (exitPlanResult as { outcome: string }).outcome + : "unknown"; + yield* agent.client.sessionUpdate({ + sessionId: requestedSessionId, + update: { + sessionUpdate: "tool_call_update", + toolCallId, + title: "Plan: Exit", + status: "completed", + }, + }); + yield* agent.client.sessionUpdate({ + sessionId: requestedSessionId, + update: { + sessionUpdate: "agent_message_chunk", + content: { + type: "text", + text: + outcome === "approved" + ? "plan approved — implementing" + : outcome === "abandoned" + ? "plan abandoned" + : "plan revision requested", + }, + }, + }); + return { stopReason: "end_turn" }; + } + if (emitAskQuestion) { yield* agent.client.extRequest("cursor/ask_question", { toolCallId: "ask-question-tool-call-1", @@ -1227,7 +1431,26 @@ const program = Effect.gen(function* () { }, }); - return { stopReason: "end_turn" }; + // Session-level context window (usage_update RFD) + end-turn Usage on PromptResponse. + yield* agent.client.sessionUpdate({ + sessionId: requestedSessionId, + update: { + sessionUpdate: "usage_update", + used: 42_000, + size: 256_000, + }, + }); + + return { + stopReason: "end_turn", + usage: { + totalTokens: 1_500, + inputTokens: 1_000, + outputTokens: 400, + thoughtTokens: 100, + cachedReadTokens: 200, + }, + } satisfies AcpSchema.PromptResponse; }), ); diff --git a/apps/server/scripts/cli.ts b/apps/server/scripts/cli.ts index 2de5b702a286..138c1a79730a 100644 --- a/apps/server/scripts/cli.ts +++ b/apps/server/scripts/cli.ts @@ -27,7 +27,9 @@ import { ServerCliDevelopmentIconTargetMissingError, ServerCliPublishIconSourceMissingError, ServerCliPublishIconTargetMissingError, + ServerCliWebClientBundleMissingError, } from "./cliErrors.ts"; +import { shouldPreserveServerDistEntry } from "./serverDistClean.ts"; interface PackageJson { name: string; @@ -140,6 +142,96 @@ const applyDevelopmentIconOverrides = Effect.fn("applyDevelopmentIconOverrides") // build subcommand // --------------------------------------------------------------------------- +/** + * Remove pack outputs under dist/ while leaving the live web client tree alone. + * Deploy rebuilds the server with the process still serving dist/client; a + * full `vp pack --clean` wipe is what left desktop on an empty "Not Found" + * shell until someone re-ran `pnpm build` by hand. + */ +const cleanServerDistPreservingClient = Effect.fn("cleanServerDistPreservingClient")(function* ( + distDir: string, +) { + const path = yield* Path.Path; + const fs = yield* FileSystem.FileSystem; + if (!(yield* fs.exists(distDir))) { + return; + } + const entries = yield* fs.readDirectory(distDir); + for (const entry of entries) { + if (shouldPreserveServerDistEntry(entry)) { + continue; + } + yield* fs.remove(path.join(distDir, entry), { recursive: true, force: true }); + } +}); + +const promoteWebClientBundle = Effect.fn("promoteWebClientBundle")(function* (input: { + readonly repoRoot: string; + readonly serverDir: string; +}) { + const path = yield* Path.Path; + const fs = yield* FileSystem.FileSystem; + const webDist = path.join(input.repoRoot, "apps/web/dist"); + const webIndex = path.join(webDist, "index.html"); + const distDir = path.join(input.serverDir, "dist"); + const clientTarget = path.join(distDir, "client"); + const previousDir = path.join(distDir, "client.prev"); + + // Fail closed: soft-skipping shipped empty client trees that surface as + // desktop "Not Found" after deploy. + if (!(yield* fs.exists(webIndex))) { + return yield* new ServerCliWebClientBundleMissingError({ webDistPath: webDist }); + } + + yield* fs.makeDirectory(distDir, { recursive: true }); + const stagingDir = yield* fs.makeTempDirectory({ + directory: distDir, + prefix: "client.next.", + }); + + yield* Effect.gen(function* () { + yield* fs.copy(webDist, stagingDir); + if (!(yield* fs.exists(path.join(stagingDir, "index.html")))) { + return yield* new ServerCliWebClientBundleMissingError({ webDistPath: stagingDir }); + } + + if (yield* fs.exists(previousDir)) { + yield* fs.remove(previousDir, { recursive: true, force: true }); + } + if (yield* fs.exists(clientTarget)) { + yield* fs.rename(clientTarget, previousDir); + } + yield* fs.rename(stagingDir, clientTarget).pipe( + Effect.catch((cause) => + // If promote fails after the live tree was moved aside, put the + // previous client back so the process never stays empty. + Effect.gen(function* () { + if ((yield* fs.exists(previousDir)) && !(yield* fs.exists(clientTarget))) { + yield* fs.rename(previousDir, clientTarget).pipe(Effect.ignore); + } + return yield* Effect.fail(cause); + }), + ), + ); + if (yield* fs.exists(previousDir)) { + yield* fs.remove(previousDir, { recursive: true, force: true }).pipe(Effect.ignore); + } + + yield* applyDevelopmentIconOverrides(input.repoRoot, input.serverDir); + + if (!(yield* fs.exists(path.join(clientTarget, "index.html")))) { + return yield* new ServerCliWebClientBundleMissingError({ webDistPath: clientTarget }); + } + yield* Effect.log("[cli] Bundled web app into dist/client"); + }).pipe( + Effect.ensuring( + // Staging only remains if promote failed before rename; force so a + // successful promote (path gone) is a no-op. + fs.remove(stagingDir, { recursive: true, force: true }).pipe(Effect.ignore), + ), + ); +}); + const buildCmd = Command.make( "build", { @@ -151,6 +243,18 @@ const buildCmd = Command.make( const fs = yield* FileSystem.FileSystem; const repoRoot = yield* RepoRoot; const serverDir = path.join(repoRoot, "apps/server"); + const distDir = path.join(serverDir, "dist"); + + // Prefer a complete client tree *before* packing when web dist is already + // present (dependsOn web#build). That way a live server keeps serving + // through the JS rebuild window instead of losing index.html at pack clean. + const webIndex = path.join(repoRoot, "apps/web/dist", "index.html"); + if (yield* fs.exists(webIndex)) { + yield* promoteWebClientBundle({ repoRoot, serverDir }); + } + + yield* Effect.log("[cli] Cleaning server dist (preserving dist/client)..."); + yield* cleanServerDistPreservingClient(distDir); yield* Effect.log("[cli] Running tsdown..."); yield* runCommand( @@ -162,16 +266,9 @@ const buildCmd = Command.make( }), ); - const webDist = path.join(repoRoot, "apps/web/dist"); - const clientTarget = path.join(serverDir, "dist/client"); - - if (yield* fs.exists(webDist)) { - yield* fs.copy(webDist, clientTarget); - yield* applyDevelopmentIconOverrides(repoRoot, serverDir); - yield* Effect.log("[cli] Bundled web app into dist/client"); - } else { - yield* Effect.logWarning("[cli] Web dist not found — skipping client bundle."); - } + // Always re-promote after pack so the served tree matches the web build + // that this package depends on (and fail closed if it is missing). + yield* promoteWebClientBundle({ repoRoot, serverDir }); }), ).pipe(Command.withDescription("Build the server package (tsdown + bundle web client).")); diff --git a/apps/server/scripts/cliErrors.test.ts b/apps/server/scripts/cliErrors.test.ts new file mode 100644 index 000000000000..888cea17ae8f --- /dev/null +++ b/apps/server/scripts/cliErrors.test.ts @@ -0,0 +1,43 @@ +import { assert, describe, it } from "@effect/vitest"; + +import { + ServerCliBuildAssetMissingError, + ServerCliCommandExitError, + ServerCliWebClientBundleMissingError, +} from "./cliErrors.ts"; + +describe("server CLI errors", () => { + it("preserves failed command context without changing its message", () => { + const error = new ServerCliCommandExitError({ + command: "vp", + args: ["pm", "publish"], + cwd: "/repo", + exitCode: 17, + }); + + assert.equal(error._tag, "ServerCliCommandExitError"); + assert.equal(error.command, "vp"); + assert.deepEqual(error.args, ["pm", "publish"]); + assert.equal(error.cwd, "/repo"); + assert.equal(error.exitCode, 17); + assert.equal(error.message, "Command exited with non-zero exit code (17)"); + }); + + it("preserves a representative missing asset path", () => { + const error = new ServerCliBuildAssetMissingError({ assetPath: "/repo/server.mjs" }); + + assert.equal(error.assetPath, "/repo/server.mjs"); + assert.equal( + error.message, + "Missing build asset: /repo/server.mjs. Run the build subcommand first.", + ); + }); + + it("explains a missing web client bundle at package time", () => { + const error = new ServerCliWebClientBundleMissingError({ webDistPath: "/repo/apps/web/dist" }); + + assert.equal(error.webDistPath, "/repo/apps/web/dist"); + assert.include(error.message, "Web client dist is missing"); + assert.include(error.message, "/repo/apps/web/dist"); + }); +}); diff --git a/apps/server/scripts/cliErrors.ts b/apps/server/scripts/cliErrors.ts index d2a410a6e0f3..7a14799bbe39 100644 --- a/apps/server/scripts/cliErrors.ts +++ b/apps/server/scripts/cliErrors.ts @@ -68,3 +68,19 @@ export class ServerCliBuildAssetMissingError extends Schema.TaggedError()( + "ServerCliWebClientBundleMissingError", + { + webDistPath: Schema.String, + }, +) { + override get message(): string { + return `Web client dist is missing at ${this.webDistPath}. Build apps/web before packaging the server so deploys cannot ship an empty UI.`; + } +} diff --git a/apps/server/scripts/serverDistClean.test.ts b/apps/server/scripts/serverDistClean.test.ts new file mode 100644 index 000000000000..48e8618e56ae --- /dev/null +++ b/apps/server/scripts/serverDistClean.test.ts @@ -0,0 +1,18 @@ +import { assert, describe, it } from "@effect/vitest"; + +import { shouldPreserveServerDistEntry } from "./serverDistClean.ts"; + +describe("shouldPreserveServerDistEntry", () => { + it("keeps the live client tree and promote staging dirs", () => { + assert.isTrue(shouldPreserveServerDistEntry("client")); + assert.isTrue(shouldPreserveServerDistEntry("client.prev")); + assert.isTrue(shouldPreserveServerDistEntry("client.next.abc123")); + }); + + it("allows pack outputs to be removed", () => { + assert.isFalse(shouldPreserveServerDistEntry("bin.mjs")); + assert.isFalse(shouldPreserveServerDistEntry("bin.mjs.map")); + assert.isFalse(shouldPreserveServerDistEntry("service-launcher.mjs")); + assert.isFalse(shouldPreserveServerDistEntry("NodePtyAdapter-abc.mjs")); + }); +}); diff --git a/apps/server/scripts/serverDistClean.ts b/apps/server/scripts/serverDistClean.ts new file mode 100644 index 000000000000..38aa9a8d2370 --- /dev/null +++ b/apps/server/scripts/serverDistClean.ts @@ -0,0 +1,7 @@ +/** + * Keep the live served tree and any in-flight atomic promote dirs when + * clearing pack outputs under apps/server/dist/. + */ +export function shouldPreserveServerDistEntry(entry: string): boolean { + return entry === "client" || entry.startsWith("client."); +} diff --git a/apps/server/src/_acp_repro.ts b/apps/server/src/_acp_repro.ts new file mode 100644 index 000000000000..03c94660a01d --- /dev/null +++ b/apps/server/src/_acp_repro.ts @@ -0,0 +1,25 @@ +import * as NodeRuntime from "@effect/platform-node/NodeRuntime"; +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { CursorSettings } from "@t3tools/contracts"; +import * as Cause from "effect/Cause"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; + +import { discoverCursorModelsViaAcp } from "./provider/Layers/CursorProvider.ts"; + +const settings = Schema.decodeSync(CursorSettings)({ binaryPath: "agent" }); + +const program = Effect.gen(function* () { + const exit = yield* Effect.exit(discoverCursorModelsViaAcp(settings, process.env)); + if (exit._tag === "Failure") { + yield* Effect.logError("Cursor ACP discovery failed", { + cause: Cause.pretty(exit.cause), + }); + } else { + yield* Effect.logInfo("Cursor ACP discovery succeeded", { + modelCount: exit.value.length, + }); + } +}).pipe(Effect.provide(NodeServices.layer)); + +NodeRuntime.runMain(program); diff --git a/apps/server/src/agentRules/T3AgentRules.test.ts b/apps/server/src/agentRules/T3AgentRules.test.ts new file mode 100644 index 000000000000..d4b08662e982 --- /dev/null +++ b/apps/server/src/agentRules/T3AgentRules.test.ts @@ -0,0 +1,50 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeAssert from "node:assert/strict"; +import * as NodeFS from "node:fs"; +import { describe, it } from "vite-plus/test"; + +import { + ensureT3AgentRulesInput, + readT3AgentRulesInjected, + resolveT3AgentRulesPath, + T3_AGENT_RULES_INJECTED_KEY, + withT3AgentRules, +} from "./T3AgentRules.ts"; + +describe("resolveT3AgentRulesPath", () => { + it("points at an existing markdown file", () => { + const path = resolveT3AgentRulesPath(); + NodeAssert.ok(path.endsWith("t3-agent-rules.md")); + NodeAssert.ok(NodeFS.existsSync(path), `rules file missing: ${path}`); + const body = NodeFS.readFileSync(path, "utf8"); + NodeAssert.ok(body.includes("always markdown hyperlinks")); + NodeAssert.ok(body.includes("Reply surface")); + NodeAssert.ok(body.includes("not a request to post there")); + }); +}); + +describe("session inject helpers", () => { + it("prepends a file pointer, not the body", () => { + const path = resolveT3AgentRulesPath(); + const result = withT3AgentRules("do the thing"); + NodeAssert.ok(result?.includes(`rules: ${path}`)); + NodeAssert.ok(result?.includes("do the thing")); + NodeAssert.equal(result?.includes("always markdown hyperlinks"), false); + }); + + it("skips re-inject when already injected this session", () => { + NodeAssert.equal(ensureT3AgentRulesInput("hello", false, true), "hello"); + }); + + it("injects when session needs rules", () => { + const result = ensureT3AgentRulesInput("hello", false, false); + NodeAssert.ok(result?.includes("## Agent rules")); + NodeAssert.ok(result?.includes("hello")); + }); + + it("reads the injected flag from runtime payload", () => { + NodeAssert.equal(readT3AgentRulesInjected(null), false); + NodeAssert.equal(readT3AgentRulesInjected({ [T3_AGENT_RULES_INJECTED_KEY]: true }), true); + NodeAssert.equal(readT3AgentRulesInjected({ [T3_AGENT_RULES_INJECTED_KEY]: false }), false); + }); +}); diff --git a/apps/server/src/agentRules/T3AgentRules.ts b/apps/server/src/agentRules/T3AgentRules.ts new file mode 100644 index 000000000000..a7499916292e --- /dev/null +++ b/apps/server/src/agentRules/T3AgentRules.ts @@ -0,0 +1,143 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Product-wide agent rules (source of truth + helpers). + * + * Single delivery mechanism (all harnesses, all surfaces): + * - Inject `## Agent rules` **file pointers** on the first provider turn of a session + * - Clear the inject flag on context compaction, re-inject on the next turn + * + * Not project AGENTS.md. Not harness-home mutation. Bodies are never embedded; + * agents open the rules file path. + * + * Discord overlay is surface-only (`agent-turn-rules.md` via Discord turn context). + */ + +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; + +import { + AGENT_RULES_HEADER, + ensureAgentRulesPaths, + formatAgentRulesPointers, +} from "@t3tools/shared/agentRulesPointer"; + +/** Fallback body when the package docs file is missing (bundled `dist/` binary). */ +const T3_AGENT_RULES_FALLBACK_MARKDOWN = `# T3 agent rules (all surfaces) + +Product rules for every T3 turn (web, desktop, mobile, Discord, GitHub, Jira). +Project \`AGENTS.md\` still owns repo-local conventions. + +**Reply surface:** Answer only on the surface this turn started on. Linked +Jira/GitHub/Sentry IDs are context, not a request to post there. Do not add +Jira/Confluence comments or GitHub issue/PR discussion comments unless the +user explicitly asked. Opening a GitHub PR for landable work is allowed. + +**Links:** always markdown hyperlinks \`[label](url)\` — never bare \`https://…\` — +in Jira/Confluence comments, PR bodies, handoff notes, and any reply where a URL +should be clickable. Prefer short labels (\`[scanner#2036](…)\`, \`[SA-49](…)\`). +Jira API Markdown→ADF often leaves bare URLs as plain text; explicit link syntax +becomes a real hyperlink. +`; + +/** runtimePayload key: rules pointer already sent for this provider session. */ +export const T3_AGENT_RULES_INJECTED_KEY = "t3AgentRulesInjected"; + +export { AGENT_RULES_HEADER }; + +function serverPackageRoot(): string { + return NodePath.resolve(NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)), "../.."); +} + +/** + * Absolute path to the product-wide rules markdown file. + * Prefer the packaged/source docs path; materialize a temp copy if missing. + */ +export function resolveT3AgentRulesPath(): string { + const root = serverPackageRoot(); + const candidates = [ + NodePath.resolve(root, "docs/t3-agent-rules.md"), + NodePath.resolve(root, "src/docs/t3-agent-rules.md"), + NodePath.resolve(root, "t3-agent-rules.md"), + ]; + for (const candidate of candidates) { + if (NodeFS.existsSync(candidate)) { + return candidate; + } + } + + const materializeDir = NodePath.join(NodeOS.tmpdir(), "t3-code"); + const materialized = NodePath.join(materializeDir, "t3-agent-rules.md"); + if (!NodeFS.existsSync(materialized)) { + NodeFS.mkdirSync(materializeDir, { recursive: true }); + NodeFS.writeFileSync(materialized, T3_AGENT_RULES_FALLBACK_MARKDOWN, "utf8"); + } + return materialized; +} + +/** Discord client overlay when monorepo layout is present. */ +export function resolveDiscordAgentRulesPath(): string | null { + const candidate = NodePath.resolve( + serverPackageRoot(), + "../discord-bot/docs/agent-turn-rules.md", + ); + return NodeFS.existsSync(candidate) ? candidate : null; +} + +export function isDiscordOriginatedTurnText(text: string | undefined): boolean { + if (text === undefined) return false; + return text.includes("## Discord conversation context"); +} + +/** Paths for this turn: global always; Discord overlay when Discord-originated. */ +export function resolveT3AgentRulesPathsForTurn(providerInput: string | undefined): string[] { + const paths = [resolveT3AgentRulesPath()]; + if (isDiscordOriginatedTurnText(providerInput)) { + const overlay = resolveDiscordAgentRulesPath(); + if (overlay !== null) paths.push(overlay); + } + return paths; +} + +export function formatT3AgentRulesPointer(rulesPath: string = resolveT3AgentRulesPath()): string { + return formatAgentRulesPointers([rulesPath]); +} + +export function readT3AgentRulesInjected(runtimePayload: unknown): boolean { + if ( + runtimePayload === null || + typeof runtimePayload !== "object" || + Array.isArray(runtimePayload) + ) { + return false; + } + return (runtimePayload as Record)[T3_AGENT_RULES_INJECTED_KEY] === true; +} + +export function withT3AgentRules(providerInput: string | undefined): string | undefined { + if (providerInput === undefined) { + return undefined; + } + return ensureAgentRulesPaths(providerInput, resolveT3AgentRulesPathsForTurn(providerInput)); +} + +/** + * Ensure turn input includes rules pointers when this session still needs them. + * When `alreadyInjectedThisSession` is true, leave text unchanged until compaction + * clears the flag. + */ +export function ensureT3AgentRulesInput( + providerInput: string | undefined, + hasAttachments: boolean, + alreadyInjectedThisSession = false, +): string | undefined { + if (alreadyInjectedThisSession) { + return providerInput ?? (hasAttachments ? "" : undefined); + } + const wrapped = withT3AgentRules(providerInput ?? (hasAttachments ? "" : undefined)); + if (wrapped !== undefined && wrapped.trim().length > 0) { + return wrapped; + } + return providerInput; +} diff --git a/apps/server/src/aiUsage/AiUsageMonitor.ts b/apps/server/src/aiUsage/AiUsageMonitor.ts new file mode 100644 index 000000000000..7d6075c7741c --- /dev/null +++ b/apps/server/src/aiUsage/AiUsageMonitor.ts @@ -0,0 +1,162 @@ +/** + * AiUsageMonitor - polls the local `ai-usage` daemon and fans snapshots out. + * + * A user-run daemon (`ai-usage serve`, default `http://127.0.0.1:8787`) exposes + * a `/dms` endpoint with normalized coding-plan usage across providers. This + * service polls it on an interval and broadcasts the latest snapshot to + * subscribers so the web can mark providers near/over their limits. + * + * The daemon is optional: any fetch/parse failure yields `AI_USAGE_UNAVAILABLE` + * (available: false, no items) rather than an error, so the feature degrades to + * "no markers" when the daemon isn't running. + * + * Polling is reference-counted via scoped `retain`, mirroring PortScanner: a + * single layer-scoped fiber polls forever, but each tick is a no-op when the + * retain count is zero. + */ +import { + AI_USAGE_UNAVAILABLE, + AiUsageProviderStatus, + type AiUsageSnapshot, +} from "@t3tools/contracts"; +import * as Cause from "effect/Cause"; +import * as Context from "effect/Context"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import * as Schedule from "effect/Schedule"; +import * as Schema from "effect/Schema"; +import * as Scope from "effect/Scope"; +import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"; + +export class AiUsageMonitor extends Context.Service< + AiUsageMonitor, + { + readonly current: () => Effect.Effect; + readonly subscribe: ( + listener: (snapshot: AiUsageSnapshot) => Effect.Effect, + ) => Effect.Effect; + readonly retain: Effect.Effect; + } +>()("t3/aiUsage/AiUsageMonitor") {} + +const POLL_INTERVAL = Duration.seconds(60); +const REQUEST_TIMEOUT = Duration.seconds(10); + +const DEFAULT_BASE_URL = "http://127.0.0.1:8787"; +const resolveBaseUrl = (): string => { + const configured = process.env.AI_USAGE_URL?.trim(); + return (configured && configured.length > 0 ? configured : DEFAULT_BASE_URL).replace(/\/+$/u, ""); +}; + +// The daemon feed has no `available` flag; we add it when constructing the +// snapshot. Reusing `AiUsageProviderStatus` avoids re-declaring the item shape. +const AiUsageFeed = Schema.Struct({ + generated_at: Schema.optionalKey(Schema.NullOr(Schema.String)), + worst_percent: Schema.optionalKey(Schema.NullOr(Schema.Number)), + items: Schema.Array(AiUsageProviderStatus), +}); + +type Listener = (snapshot: AiUsageSnapshot) => Effect.Effect; + +interface MonitorState { + readonly lastSnapshot: AiUsageSnapshot; + readonly listeners: ReadonlySet; + readonly retainCount: number; +} + +export const make = Effect.gen(function* AiUsageMonitorMake() { + const httpClient = yield* HttpClient.HttpClient; + const baseUrl = resolveBaseUrl(); + const stateRef = yield* Ref.make({ + lastSnapshot: AI_USAGE_UNAVAILABLE, + listeners: new Set(), + retainCount: 0, + }); + + const fetchSnapshot = HttpClientRequest.get(`${baseUrl}/dms`).pipe( + HttpClientRequest.acceptJson, + httpClient.execute, + Effect.flatMap(HttpClientResponse.schemaBodyJson(AiUsageFeed)), + Effect.timeout(REQUEST_TIMEOUT), + Effect.map((feed): AiUsageSnapshot => ({ + generated_at: feed.generated_at ?? null, + worst_percent: feed.worst_percent ?? null, + available: true, + items: feed.items, + })), + Effect.catchCause((cause) => + Effect.logDebug("ai-usage daemon unavailable", Cause.pretty(cause)).pipe( + Effect.as(AI_USAGE_UNAVAILABLE), + ), + ), + ); + + const broadcast = Effect.fn("AiUsageMonitor.broadcast")(function* (snapshot: AiUsageSnapshot) { + const listeners = (yield* Ref.get(stateRef)).listeners; + yield* Effect.forEach(listeners, (listener) => listener(snapshot), { discard: true }); + }); + + const pollTick = Effect.fn("AiUsageMonitor.pollTick")( + function* () { + if ((yield* Ref.get(stateRef)).retainCount <= 0) return; + const next = yield* fetchSnapshot; + const changed = yield* Ref.modify(stateRef, (state) => + snapshotsEqual(state.lastSnapshot, next) + ? [false, state] + : [true, { ...state, lastSnapshot: next }], + ); + if (changed) yield* broadcast(next); + }, + Effect.catchCause((cause: Cause.Cause) => + Effect.logWarning("ai-usage poll failed", Cause.pretty(cause)), + ), + ); + + // Single layer-scoped polling fiber; ticks are no-ops when unretained. + yield* Effect.forkScoped(pollTick().pipe(Effect.repeat(Schedule.spaced(POLL_INTERVAL)))); + + const acquireRetention = Effect.fn("AiUsageMonitor.retain")(function* () { + const wasIdle = yield* Ref.modify(stateRef, (state) => [ + state.retainCount === 0, + { ...state, retainCount: state.retainCount + 1 }, + ]); + if (wasIdle) yield* pollTick(); + }); + + const retain: AiUsageMonitor["Service"]["retain"] = Effect.acquireRelease( + acquireRetention(), + () => + Ref.update(stateRef, (state) => ({ + ...state, + retainCount: Math.max(0, state.retainCount - 1), + })), + ); + + const subscribe: AiUsageMonitor["Service"]["subscribe"] = Effect.fn("AiUsageMonitor.subscribe")( + (listener) => + Effect.acquireRelease( + Ref.update(stateRef, (state) => ({ + ...state, + listeners: new Set([...state.listeners, listener]), + })), + () => + Ref.update(stateRef, (state) => { + const listeners = new Set(state.listeners); + listeners.delete(listener); + return { ...state, listeners }; + }), + ), + ); + + const current: AiUsageMonitor["Service"]["current"] = () => + Ref.get(stateRef).pipe(Effect.map((state) => state.lastSnapshot)); + + return AiUsageMonitor.of({ current, subscribe, retain }); +}).pipe(Effect.withSpan("AiUsageMonitor.make")); + +const snapshotsEqual = (left: AiUsageSnapshot, right: AiUsageSnapshot): boolean => + JSON.stringify(left) === JSON.stringify(right); + +export const layer = Layer.effect(AiUsageMonitor, make); diff --git a/apps/server/src/assets/AssetAccess.test.ts b/apps/server/src/assets/AssetAccess.test.ts index b83b8684432c..b6219aa20474 100644 --- a/apps/server/src/assets/AssetAccess.test.ts +++ b/apps/server/src/assets/AssetAccess.test.ts @@ -461,7 +461,7 @@ describe("AssetAccess", () => { }).pipe(Effect.provide(testLayer)), ); - it.effect("rejects workspace files outside the authorized root", () => + it.effect("serves explicitly linked absolute preview files outside the project root", () => Effect.gen(function* () { const fileSystem = yield* FileSystem.FileSystem; const path = yield* Path.Path; @@ -474,24 +474,59 @@ describe("AssetAccess", () => { const htmlPath = path.join(outside, "report.html"); yield* fileSystem.writeFileString(htmlPath, "

outside

"); - const error = yield* issueAssetUrl({ + const canonicalHtmlPath = yield* fileSystem.realPath(htmlPath); + const result = yield* issueAssetUrl({ resource: { _tag: "workspace-file", threadId: ThreadId.make("thread-1"), path: htmlPath, }, workspaceRoot: root, - }).pipe(Effect.flip); - expect(error.message).toBe("Workspace file path must be relative to the project root."); - expect(error).toMatchObject({ - _tag: "AssetWorkspacePathValidationError", + }); + const suffix = result.relativeUrl.slice(`${ASSET_ROUTE_PREFIX}/`.length); + const separatorIndex = suffix.indexOf("/"); + const token = suffix.slice(0, separatorIndex); + expect(yield* resolveAsset(token, "report.html")).toEqual({ + kind: "file", + path: canonicalHtmlPath, + }); + expect(yield* resolveAsset(token, "../secret.html")).toBeNull(); + }).pipe(Effect.provide(testLayer)), + ); + + it.effect("serves absolute Codex-style generated_images png paths outside the project", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const projectRoot = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-asset-project-", + }); + const generatedRoot = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-asset-generated-images-", + }); + const callDir = path.join(generatedRoot, "019f6511-7b93-7663-9908-41e3f45b5bac"); + yield* fileSystem.makeDirectory(callDir, { recursive: true }); + const imagePath = path.join(callDir, "call_5K1KcXmRdTGulQT91c2PtIl6.png"); + yield* fileSystem.writeFile(imagePath, new Uint8Array([0x89, 0x50, 0x4e, 0x47])); + const canonicalImagePath = yield* fileSystem.realPath(imagePath); + + const result = yield* issueAssetUrl({ resource: { _tag: "workspace-file", - threadId: "thread-1", - path: htmlPath, + threadId: ThreadId.make("thread-1"), + path: imagePath, }, + workspaceRoot: projectRoot, + }); + const suffix = result.relativeUrl.slice(`${ASSET_ROUTE_PREFIX}/`.length); + const separatorIndex = suffix.indexOf("/"); + const token = suffix.slice(0, separatorIndex); + const fileName = suffix.slice(separatorIndex + 1); + expect(fileName).toBe("call_5K1KcXmRdTGulQT91c2PtIl6.png"); + expect(yield* resolveAsset(token, fileName)).toEqual({ + kind: "file", + path: canonicalImagePath, }); - expect(error.cause).toBeInstanceOf(WorkspacePaths.WorkspacePathOutsideRootError); }).pipe(Effect.provide(testLayer)), ); @@ -712,10 +747,7 @@ describe("AssetAccess", () => { prefix: "t3-asset-favicon-", }); const faviconPath = path.join(root, "favicon.svg"); - const initialFavicon = "a"; - const updatedFavicon = "b"; - expect(updatedFavicon).toHaveLength(initialFavicon.length); - yield* fileSystem.writeFileString(faviconPath, initialFavicon); + yield* fileSystem.writeFileString(faviconPath, ""); const canonicalFaviconPath = yield* fileSystem.realPath(faviconPath); const faviconResult = yield* issueAssetUrl({ @@ -737,14 +769,6 @@ describe("AssetAccess", () => { ), ).toEqual({ kind: "file", path: canonicalFaviconPath }); - yield* fileSystem.writeFileString(faviconPath, updatedFavicon); - const updatedFaviconResult = yield* issueAssetUrl({ - resource: { _tag: "project-favicon", cwd: root }, - }); - expect( - updatedFaviconResult.relativeUrl.slice(updatedFaviconResult.relativeUrl.lastIndexOf("/")), - ).not.toBe(faviconResult.relativeUrl.slice(faviconResult.relativeUrl.lastIndexOf("/"))); - yield* fileSystem.remove(faviconPath); const fallbackResult = yield* issueAssetUrl({ resource: { _tag: "project-favicon", cwd: root }, diff --git a/apps/server/src/assets/AssetAccess.ts b/apps/server/src/assets/AssetAccess.ts index 956c4ac44211..b507d60185a2 100644 --- a/apps/server/src/assets/AssetAccess.ts +++ b/apps/server/src/assets/AssetAccess.ts @@ -342,18 +342,37 @@ export const issueAssetUrl = Effect.fn("AssetAccess.issueAssetUrl")(function* (i resource: input.resource, }); } - const workspaceRoot = yield* workspacePaths.normalizeWorkspaceRoot(input.workspaceRoot).pipe( - Effect.mapError( - (cause) => - new AssetWorkspaceRootNormalizationError({ - resource: input.resource, - cause, - }), - ), - ); - const relativePath = path.isAbsolute(input.resource.path) - ? path.relative(workspaceRoot, input.resource.path) + const projectWorkspaceRoot = yield* workspacePaths + .normalizeWorkspaceRoot(input.workspaceRoot) + .pipe( + Effect.mapError( + (cause) => + new AssetWorkspaceRootNormalizationError({ + resource: input.resource, + cause, + }), + ), + ); + const projectRelativePath = path.isAbsolute(input.resource.path) + ? path.relative(projectWorkspaceRoot, input.resource.path) : input.resource.path; + const isAbsoluteOutsideProject = + path.isAbsolute(input.resource.path) && + (projectRelativePath.startsWith("..") || path.isAbsolute(projectRelativePath)); + const workspaceRoot = isAbsoluteOutsideProject + ? yield* workspacePaths.normalizeWorkspaceRoot(path.dirname(input.resource.path)).pipe( + Effect.mapError( + (cause) => + new AssetWorkspaceRootNormalizationError({ + resource: input.resource, + cause, + }), + ), + ) + : projectWorkspaceRoot; + const relativePath = isAbsoluteOutsideProject + ? path.basename(input.resource.path) + : projectRelativePath; const resolved = yield* workspacePaths .resolveRelativePathWithinRoot({ workspaceRoot, relativePath }) .pipe( diff --git a/apps/server/src/auth/PairingGrantStore.test.ts b/apps/server/src/auth/PairingGrantStore.test.ts index 9a093be41ca4..1920c4c27e20 100644 --- a/apps/server/src/auth/PairingGrantStore.test.ts +++ b/apps/server/src/auth/PairingGrantStore.test.ts @@ -1,4 +1,9 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; + import * as NodeServices from "@effect/platform-node/NodeServices"; +import { LOCAL_BOOTSTRAP_CREDENTIAL_FILE } from "@t3tools/shared/serverRuntime"; import { expect, it } from "@effect/vitest"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; @@ -38,6 +43,29 @@ const makePairingGrantStoreLayer = ( Layer.provide(makeServerConfigLayer(overrides)), ); +const makeLocalBootstrapGrantStoreLayer = (credential: string) => + PairingGrantStore.layer.pipe( + Layer.provide(SqlitePersistenceMemory), + Layer.provide( + Layer.effect( + ServerConfig.ServerConfig, + Effect.gen(function* () { + const config = yield* ServerConfig.ServerConfig; + NodeFS.writeFileSync( + NodePath.join(config.stateDir, LOCAL_BOOTSTRAP_CREDENTIAL_FILE), + `${credential}\n`, + { mode: 0o600 }, + ); + return config; + }), + ).pipe( + Layer.provide( + ServerConfig.layerTest(process.cwd(), { prefix: "t3-auth-local-bootstrap-test-" }), + ), + ), + ), + ); + const makePairingGrantStoreTestLayer = ( overrides: Partial, ) => @@ -196,6 +224,28 @@ it.layer(NodeServices.layer)("PairingGrantStore.layer", (it) => { ), ); + it.effect("seeds the local bootstrap file as a long-lived reusable grant", () => + Effect.gen(function* () { + const bootstrapCredentials = yield* PairingGrantStore.PairingGrantStore; + + yield* TestClock.adjust(Duration.hours(25)); + const afterADay = yield* bootstrapCredentials.consume("local-file-bootstrap-token"); + expect(afterADay.method).toBe("desktop-bootstrap"); + expect(afterADay.subject).toBe("local-bootstrap"); + + yield* TestClock.adjust(Duration.days(400)); + const monthsLater = yield* bootstrapCredentials.consume("local-file-bootstrap-token"); + expect(monthsLater.subject).toBe("local-bootstrap"); + }).pipe( + Effect.provide( + Layer.merge( + makeLocalBootstrapGrantStoreLayer("local-file-bootstrap-token"), + TestClock.layer(), + ), + ), + ), + ); + it.effect("keeps credentials out of pairing lists and change events", () => Effect.gen(function* () { const grants = yield* PairingGrantStore.PairingGrantStore; diff --git a/apps/server/src/auth/PairingGrantStore.ts b/apps/server/src/auth/PairingGrantStore.ts index ec27c0a4e147..50b88b47bfeb 100644 --- a/apps/server/src/auth/PairingGrantStore.ts +++ b/apps/server/src/auth/PairingGrantStore.ts @@ -1,3 +1,7 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; + import { AuthAdministrativeScopes, AuthStandardClientScopes, @@ -5,6 +9,7 @@ import { type AuthPairingLink, type ServerAuthBootstrapMethod, } from "@t3tools/contracts"; +import { LOCAL_BOOTSTRAP_CREDENTIAL_FILE } from "@t3tools/shared/serverRuntime"; import * as Context from "effect/Context"; import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; @@ -20,6 +25,18 @@ import * as Stream from "effect/Stream"; import * as ServerConfig from "../config.ts"; import * as AuthPairingLinks from "../persistence/AuthPairingLinks.ts"; +function readLocalBootstrapCredential(stateDir: string): string | undefined { + try { + const credential = NodeFS.readFileSync( + NodePath.join(stateDir, LOCAL_BOOTSTRAP_CREDENTIAL_FILE), + "utf8", + ).trim(); + return credential.length > 0 ? credential : undefined; + } catch { + return undefined; + } +} + export interface BootstrapGrant { readonly method: ServerAuthBootstrapMethod; readonly scopes: ReadonlyArray; @@ -246,6 +263,12 @@ const DEFAULT_ONE_TIME_TOKEN_TTL_MINUTES = Duration.minutes(5); // window can still recover by re-bootstrapping rather than locking // the user out of the backend. const DESKTOP_BOOTSTRAP_TTL_HOURS = Duration.hours(24); +// File-backed local bootstrap (`local-bootstrap-credential` in stateDir) is for +// colocated trusted clients — the Discord bot on t3vm re-exchanges it on every +// process start. It must outlive a long-running server: a 24h TTL meant any bot +// restart more than a day after `t3code-server` started failed with +// `invalid_credential` until the server itself was restarted. +const LOCAL_BOOTSTRAP_TTL = Duration.days(3650); // A dev server's startup token is read off a log by whoever (or whatever) is // driving the session, often minutes later — after a `node --watch` restart, a // detour into another task, or a hand-off to the person actually doing the @@ -326,6 +349,19 @@ export const make = Effect.gen(function* () { remainingUses: "unbounded", }); } + const localCredential = readLocalBootstrapCredential(config.stateDir); + if (localCredential !== undefined && localCredential !== config.desktopBootstrapToken) { + const now = yield* DateTime.now; + yield* seedGrant(localCredential, { + method: "desktop-bootstrap", + scopes: AuthAdministrativeScopes, + subject: "local-bootstrap", + expiresAt: DateTime.add(now, { + milliseconds: Duration.toMillis(LOCAL_BOOTSTRAP_TTL), + }), + remainingUses: "unbounded", + }); + } const listActive: PairingGrantStore["Service"]["listActive"] = Effect.fn( "PairingGrantStore.listActive", diff --git a/apps/server/src/auth/RpcAuthorization.test.ts b/apps/server/src/auth/RpcAuthorization.test.ts index 7262239577b4..093866540ff7 100644 --- a/apps/server/src/auth/RpcAuthorization.test.ts +++ b/apps/server/src/auth/RpcAuthorization.test.ts @@ -12,9 +12,19 @@ import { RPC_REQUIRED_SCOPES, requiredScopeForRpcMethod } from "./RpcAuthorizati describe("RPC authorization scopes", () => { it("declares exactly one scope for every RPC in the server group", () => { + // Single source of truth: ws.ts must call requiredScopeForRpcMethod / RPC_REQUIRED_SCOPES + // and must not keep a parallel Map (that drifted and broke identity.* RPCs in production). expect(new Set(Object.keys(RPC_REQUIRED_SCOPES))).toEqual(new Set(WsRpcGroup.requests.keys())); }); + it("resolves every registered RPC method through requiredScopeForRpcMethod", () => { + for (const method of WsRpcGroup.requests.keys()) { + expect(requiredScopeForRpcMethod(method)).toBe( + RPC_REQUIRED_SCOPES[method as keyof typeof RPC_REQUIRED_SCOPES], + ); + } + }); + it("authorizes background policy reporting and observation deliberately", () => { expect(requiredScopeForRpcMethod(WS_METHODS.serverReportClientActivity)).toBe( AuthOrchestrationReadScope, diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts index d7d1be455fa1..9607d93dfbc7 100644 --- a/apps/server/src/auth/RpcAuthorization.ts +++ b/apps/server/src/auth/RpcAuthorization.ts @@ -24,6 +24,7 @@ export const RPC_REQUIRED_SCOPES = { [ORCHESTRATION_WS_METHODS.dispatchCommand]: AuthOrchestrationOperateScope, [ORCHESTRATION_WS_METHODS.getWorkflowScript]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.getTurnDiff]: AuthOrchestrationReadScope, + [ORCHESTRATION_WS_METHODS.getThreadActivities]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.getFullThreadDiff]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.searchThreads]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.subscribeShell]: AuthOrchestrationReadScope, @@ -55,6 +56,7 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.serverGetProcessDiagnostics]: AuthOrchestrationReadScope, [WS_METHODS.serverGetHostResources]: AuthOrchestrationReadScope, [WS_METHODS.serverGetProcessResourceHistory]: AuthOrchestrationReadScope, + [WS_METHODS.serverGetHostResourceSnapshot]: AuthOrchestrationReadScope, [WS_METHODS.serverGetResourceTelemetryHistory]: AuthOrchestrationReadScope, [WS_METHODS.serverRetryResourceTelemetry]: AuthOrchestrationOperateScope, [WS_METHODS.serverGetUsageSummary]: AuthOrchestrationReadScope, @@ -65,6 +67,10 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.serverGetBackgroundPolicy]: AuthOrchestrationReadScope, [WS_METHODS.cloudGetRelayClientStatus]: AuthRelayReadScope, [WS_METHODS.cloudInstallRelayClient]: AuthRelayWriteScope, + [WS_METHODS.identityGetSnapshot]: AuthOrchestrationReadScope, + [WS_METHODS.identityGetSessionClaim]: AuthOrchestrationReadScope, + [WS_METHODS.identityClaim]: AuthOrchestrationOperateScope, + [WS_METHODS.identityClearClaim]: AuthOrchestrationOperateScope, [WS_METHODS.pullRequestsList]: AuthOrchestrationReadScope, [WS_METHODS.pullRequestsListStats]: AuthOrchestrationReadScope, [WS_METHODS.pullRequestsSummary]: AuthOrchestrationReadScope, @@ -98,6 +104,7 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.projectsListEntries]: AuthOrchestrationReadScope, [WS_METHODS.projectsReadFile]: AuthOrchestrationReadScope, [WS_METHODS.projectsSearchContents]: AuthOrchestrationReadScope, + [WS_METHODS.projectsWatchFile]: AuthOrchestrationReadScope, [WS_METHODS.projectsSearchEntries]: AuthOrchestrationReadScope, [WS_METHODS.projectsWriteFile]: AuthOrchestrationOperateScope, [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope, @@ -118,6 +125,9 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.vcsListRefs]: AuthOrchestrationReadScope, [WS_METHODS.vcsCreateWorktree]: AuthOrchestrationOperateScope, [WS_METHODS.vcsRemoveWorktree]: AuthOrchestrationOperateScope, + [WS_METHODS.vcsResolveBranchChangeRequest]: AuthOrchestrationReadScope, + [WS_METHODS.vcsPreviewWorktreeCleanup]: AuthOrchestrationReadScope, + [WS_METHODS.vcsCleanupThreadWorktree]: AuthOrchestrationOperateScope, [WS_METHODS.vcsCreateRef]: AuthOrchestrationOperateScope, [WS_METHODS.vcsSwitchRef]: AuthOrchestrationOperateScope, [WS_METHODS.vcsInit]: AuthOrchestrationOperateScope, @@ -138,12 +148,14 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.previewRefresh]: AuthOrchestrationOperateScope, [WS_METHODS.previewClose]: AuthOrchestrationOperateScope, [WS_METHODS.previewList]: AuthOrchestrationReadScope, + [WS_METHODS.previewResolvePort]: AuthOrchestrationOperateScope, [WS_METHODS.previewReportStatus]: AuthOrchestrationOperateScope, [WS_METHODS.previewAutomationConnect]: AuthOrchestrationOperateScope, [WS_METHODS.previewAutomationRespond]: AuthOrchestrationOperateScope, [WS_METHODS.previewAutomationFocusHost]: AuthOrchestrationOperateScope, [WS_METHODS.subscribePreviewEvents]: AuthOrchestrationReadScope, [WS_METHODS.subscribeDiscoveredLocalServers]: AuthOrchestrationReadScope, + [WS_METHODS.subscribeAiUsage]: AuthOrchestrationReadScope, [WS_METHODS.deviceConfigure]: AuthOrchestrationOperateScope, [WS_METHODS.deviceTestHost]: AuthOrchestrationOperateScope, [WS_METHODS.deviceList]: AuthOrchestrationReadScope, diff --git a/apps/server/src/bin.test.ts b/apps/server/src/bin.test.ts index e1a13d4ce8e7..f5fbed6231d3 100644 --- a/apps/server/src/bin.test.ts +++ b/apps/server/src/bin.test.ts @@ -38,6 +38,7 @@ import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts"; import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts"; import { OrchestrationLayerLive } from "./orchestration/runtimeLayer.ts"; +import * as GrokTranscriptResync from "./externalSessions/GrokTranscriptResync.ts"; import { orchestrationHttpApiLayer } from "./orchestration/http.ts"; import { layerConfig as SqlitePersistenceLayerLive } from "./persistence/Layers/Sqlite.ts"; import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts"; @@ -49,10 +50,11 @@ import * as WorkspacePaths from "./workspace/WorkspacePaths.ts"; import * as ServerSecretStore from "./auth/ServerSecretStore.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import { environmentAuthenticatedAuthLayer } from "./auth/http.ts"; +import * as IdentityService from "./identity/IdentityService.ts"; import packageJson from "../package.json" with { type: "json" }; -const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer); +const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer, IdentityService.layer); const DisconnectedLauncherChildLayer = Layer.mergeAll( Layer.succeed(HostProcessEnvironment, { ...process.env, @@ -362,7 +364,13 @@ const withLiveProjectCliServer = (baseDir: string, run: () => Effect.Ef const config = yield* makeCliTestServerConfig(baseDir); const routesLayer = HttpApiBuilder.layer(ProjectCliHttpApi).pipe( Layer.provide(orchestrationHttpApiLayer), + Layer.provide( + Layer.mock(GrokTranscriptResync.GrokTranscriptResync)({ + resyncThread: () => Effect.void, + }), + ), Layer.provide(environmentAuthenticatedAuthLayer), + Layer.provide(IdentityService.layer), ); const appLayer = HttpRouter.serve(routesLayer, { disableListenLog: true, diff --git a/apps/server/src/bin.ts b/apps/server/src/bin.ts index 52cc363ed04f..25b8a4597b40 100644 --- a/apps/server/src/bin.ts +++ b/apps/server/src/bin.ts @@ -9,6 +9,7 @@ import * as NetService from "@t3tools/shared/Net"; import packageJson from "../package.json" with { type: "json" }; import { authCommand } from "./cli/auth.ts"; import { appCommand } from "./cli/app.ts"; +import { backfillGrokCommand } from "./cli/backfillGrok.ts"; import { connectCommand } from "./cli/connect.ts"; import { pairCommand } from "./cli/pair.ts"; import { hasCloudPublicConfig } from "./cloud/publicConfig.ts"; @@ -20,8 +21,10 @@ import { serviceCommand } from "./cli/service.ts"; import { servicePreflightCommand } from "./cli/servicePreflight.ts"; import { themeCommand } from "./cli/theme.ts"; import { triageCommand } from "./cli/triage.ts"; +import * as IdentityService from "./identity/IdentityService.ts"; -const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer); +// Identity is residual-free and required by the server command graph type. +const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer, IdentityService.layer); const connectPublicConfigMissingMessage = "T3 Connect commands are unavailable: this build is missing T3 Connect public configuration."; @@ -58,6 +61,7 @@ export const makeCli = ({ cloudEnabled = hasCloudPublicConfig } = {}) => pairCommand, authCommand, projectCommand, + backfillGrokCommand, serviceCommand, servicePreflightCommand, themeCommand, diff --git a/apps/server/src/checkpointing/CaptureBackoff.test.ts b/apps/server/src/checkpointing/CaptureBackoff.test.ts new file mode 100644 index 000000000000..6e9a4c64f3de --- /dev/null +++ b/apps/server/src/checkpointing/CaptureBackoff.test.ts @@ -0,0 +1,191 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { cooldownForFailureCount, makeCaptureBackoff } from "./CaptureBackoff.ts"; + +const MINUTE = 60_000; +const CWD = "/repo/workspace"; + +describe("cooldownForFailureCount", () => { + it("tolerates transient failures before opening a cooldown", () => { + expect(cooldownForFailureCount(1)).toBe(0); + expect(cooldownForFailureCount(2)).toBe(0); + }); + + it("backs off further the longer capture keeps failing", () => { + expect(cooldownForFailureCount(3)).toBe(5 * MINUTE); + expect(cooldownForFailureCount(4)).toBe(10 * MINUTE); + expect(cooldownForFailureCount(5)).toBe(20 * MINUTE); + }); + + it("caps the cooldown so a workspace is retried eventually", () => { + expect(cooldownForFailureCount(20)).toBe(60 * MINUTE); + expect(cooldownForFailureCount(500)).toBe(60 * MINUTE); + }); +}); + +describe("makeCaptureBackoff", () => { + it("does not skip before the failure threshold is reached", () => { + const backoff = makeCaptureBackoff(); + + backoff.recordFailure(CWD, 0, "timeout"); + backoff.recordFailure(CWD, 1_000, "timeout"); + + expect(backoff.beginAttempt(CWD, 2_000).skip).toBe(false); + }); + + it("skips and replays the recorded failure once capture keeps failing", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 1_000, 2_000]) { + backoff.recordFailure(CWD, at, "git add timed out"); + } + + const decision = backoff.beginAttempt(CWD, 3_000); + expect(decision.skip).toBe(true); + expect(decision.lastError).toBe("git add timed out"); + expect(decision.remainingMs).toBeGreaterThan(0); + }); + + it("retries again once the cooldown elapses", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + + expect(backoff.beginAttempt(CWD, 5 * MINUTE - 1).skip).toBe(true); + expect(backoff.beginAttempt(CWD, 5 * MINUTE).skip).toBe(false); + }); + + it("clears the record after a capture succeeds", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(true); + + backoff.recordSuccess(CWD); + + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(false); + expect(backoff.trackedWorkspaceCount).toBe(0); + }); + + it("tracks each workspace independently", () => { + const backoff = makeCaptureBackoff(); + const healthy = "/repo/other"; + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(true); + expect(backoff.beginAttempt(healthy, 1_000).skip).toBe(false); + }); + + it("bounds how many workspaces it retains", () => { + const backoff = makeCaptureBackoff(); + + for (let index = 0; index < 400; index += 1) { + backoff.recordFailure(`/repo/workspace-${index}`, index, "timeout"); + } + + expect(backoff.trackedWorkspaceCount).toBe(256); + // The oldest entries are the ones dropped: an evicted workspace starts + // counting again from one, a retained one continues. + expect(backoff.recordFailure("/repo/workspace-0", 1_000, "timeout").consecutiveFailures).toBe( + 1, + ); + expect(backoff.recordFailure("/repo/workspace-399", 1_000, "timeout").consecutiveFailures).toBe( + 2, + ); + }); + + it("keeps a repeatedly failing workspace alive through eviction pressure", () => { + const backoff = makeCaptureBackoff(); + + // A workspace in active use fails on every turn while many one-off + // workspaces churn past it. + for (let index = 0; index < 400; index += 1) { + backoff.recordFailure(CWD, index, "timeout"); + backoff.recordFailure(`/repo/other-${index}`, index, "timeout"); + } + + expect(backoff.beginAttempt(CWD, 400).skip).toBe(true); + }); + + it("keeps a workspace that is only being skipped safe from eviction", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + + // A skipped workspace never calls recordFailure again, so only the skip + // itself can keep it ahead of churn from unrelated workspaces. + for (let index = 0; index < 400; index += 1) { + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(true); + backoff.recordFailure(`/repo/other-${index}`, index, "timeout"); + } + + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(true); + }); + + it("does not reserve for a workspace that has not reached the threshold", () => { + const backoff = makeCaptureBackoff(); + + backoff.recordFailure(CWD, 0, "timeout"); + + // One transient failure must not suppress a capture running alongside it. + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(false); + expect(backoff.beginAttempt(CWD, 1_000).skip).toBe(false); + expect(backoff.beginAttempt(CWD, 2_000).skip).toBe(false); + }); + + it("releases only one caller when the cooldown expires", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + + // Threads sharing a workspace can complete turns together, and only the + // first past the cooldown should pay for the capture. + const released = [ + backoff.beginAttempt(CWD, 5 * MINUTE), + backoff.beginAttempt(CWD, 5 * MINUTE), + backoff.beginAttempt(CWD, 5 * MINUTE), + ].filter((decision) => !decision.skip); + + expect(released).toHaveLength(1); + }); + + it("lets the reservation lapse when an attempt never reports back", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + backoff.beginAttempt(CWD, 5 * MINUTE); + + // An interrupted capture reports neither success nor failure, so the + // reservation must expire on its own rather than wedge the workspace. + expect(backoff.beginAttempt(CWD, 5 * MINUTE + 30_000).skip).toBe(true); + expect(backoff.beginAttempt(CWD, 6 * MINUTE + 1).skip).toBe(false); + }); + + it("keeps extending the cooldown while failures continue", () => { + const backoff = makeCaptureBackoff(); + + for (const at of [0, 0, 0]) { + backoff.recordFailure(CWD, at, "timeout"); + } + const firstRemaining = backoff.beginAttempt(CWD, 0).remainingMs; + + // The next attempt after the cooldown fails again, so the wait grows. + backoff.recordFailure(CWD, 5 * MINUTE, "timeout"); + const secondRemaining = backoff.beginAttempt(CWD, 5 * MINUTE).remainingMs; + + expect(secondRemaining).toBeGreaterThan(firstRemaining); + }); +}); diff --git a/apps/server/src/checkpointing/CaptureBackoff.ts b/apps/server/src/checkpointing/CaptureBackoff.ts new file mode 100644 index 000000000000..d53a8278e689 --- /dev/null +++ b/apps/server/src/checkpointing/CaptureBackoff.ts @@ -0,0 +1,146 @@ +/** + * Consecutive-failure backoff for workspace checkpoint capture. + * + * Capture runs a full-tree `git add -A` under a temporary index after every + * completed turn. On a repository large enough to exceed the VCS process + * timeout, that capture can never succeed, so the unguarded retry pegs a CPU + * core for as long as any thread is in use and litters `.git/objects/pack` + * with `tmp_pack_*` files from each killed process. + * + * After a few consecutive failures for a workspace, capture is skipped for a + * growing cooldown instead of being retried every turn. Any success clears + * the record, so a transient failure (a lock held by a concurrent git + * command) costs nothing. + * + * @module CaptureBackoff + */ + +/** Failures tolerated before a workspace enters cooldown. */ +const FAILURE_THRESHOLD = 3; +const BASE_COOLDOWN_MS = 5 * 60_000; +const MAX_COOLDOWN_MS = 60 * 60_000; + +/** + * Only a workspace that later succeeds clears its own record, so a workspace + * that fails once and is then abandoned would otherwise be retained for the + * lifetime of the server. Bound the tracked set and evict least-recently + * touched entries; dropping one only costs a workspace its failure history. + */ +const MAX_TRACKED_WORKSPACES = 256; + +/** + * How long the first caller past an expired cooldown holds the retry to + * itself. Threads sharing a workspace complete turns independently, so + * without this they would all be released at once and launch the same + * expensive capture together. Comfortably longer than the VCS process + * timeout that kills a stuck capture, and it lapses on its own, so an + * attempt that never reports back cannot wedge the workspace. + */ +const ATTEMPT_RESERVATION_MS = 60_000; + +export interface CaptureBackoffDecision { + readonly skip: boolean; + /** Milliseconds left in the cooldown, for logging. Zero when not skipping. */ + readonly remainingMs: number; + /** + * The failure that opened the cooldown. Replayed instead of inventing a new + * error, so callers keep seeing the real reason capture is unavailable and + * the error channel is unchanged. + */ + readonly lastError: E | null; +} + +export function cooldownForFailureCount(consecutiveFailures: number): number { + if (consecutiveFailures < FAILURE_THRESHOLD) return 0; + const doublings = consecutiveFailures - FAILURE_THRESHOLD; + // Clamp the exponent before shifting so a long-lived workspace cannot + // overflow into a negative or infinite cooldown. + const scale = 2 ** Math.min(doublings, 10); + return Math.min(BASE_COOLDOWN_MS * scale, MAX_COOLDOWN_MS); +} + +export interface CaptureFailureOutcome { + readonly consecutiveFailures: number; + /** Zero while the workspace is still under the failure threshold. */ + readonly cooldownMs: number; +} + +interface WorkspaceRecord { + consecutiveFailures: number; + skipUntilMs: number; + lastError: E; +} + +/** + * Tracks capture health per workspace. Callers ask whether to skip, then + * report the outcome of any capture they actually ran. + */ +export function makeCaptureBackoff() { + const recordByCwd = new Map>(); + + /** Move a record to the most-recent position so eviction sees real usage. */ + const touch = (cwd: string, record: WorkspaceRecord) => { + recordByCwd.delete(cwd); + recordByCwd.set(cwd, record); + }; + + return { + /** + * Decide whether this caller should run a capture. Mutating: a caller + * released past an expired cooldown reserves the attempt, and any read + * refreshes eviction recency so a workspace being actively skipped is not + * evicted by churn from unrelated workspaces. + */ + beginAttempt(cwd: string, nowMs: number): CaptureBackoffDecision { + const record = recordByCwd.get(cwd); + if (!record) { + return { skip: false, remainingMs: 0, lastError: null }; + } + + touch(cwd, record); + // Below the threshold a workspace has no cooldown at all, and its zero + // deadline must not read as one that just expired: reserving there + // would let a single transient failure suppress a concurrent capture. + if (record.consecutiveFailures < FAILURE_THRESHOLD) { + return { skip: false, remainingMs: 0, lastError: null }; + } + + if (nowMs < record.skipUntilMs) { + return { + skip: true, + remainingMs: record.skipUntilMs - nowMs, + lastError: record.lastError, + }; + } + + record.skipUntilMs = nowMs + ATTEMPT_RESERVATION_MS; + return { skip: false, remainingMs: 0, lastError: null }; + }, + + recordSuccess(cwd: string): void { + recordByCwd.delete(cwd); + }, + + recordFailure(cwd: string, nowMs: number, error: E): CaptureFailureOutcome { + const consecutiveFailures = (recordByCwd.get(cwd)?.consecutiveFailures ?? 0) + 1; + const cooldownMs = cooldownForFailureCount(consecutiveFailures); + touch(cwd, { + consecutiveFailures, + skipUntilMs: cooldownMs === 0 ? 0 : nowMs + cooldownMs, + lastError: error, + }); + + while (recordByCwd.size > MAX_TRACKED_WORKSPACES) { + const oldestCwd = recordByCwd.keys().next().value; + if (oldestCwd === undefined) break; + recordByCwd.delete(oldestCwd); + } + + return { consecutiveFailures, cooldownMs }; + }, + + get trackedWorkspaceCount(): number { + return recordByCwd.size; + }, + }; +} diff --git a/apps/server/src/checkpointing/CheckpointCaptureBackoff.test.ts b/apps/server/src/checkpointing/CheckpointCaptureBackoff.test.ts new file mode 100644 index 000000000000..ad454d741da1 --- /dev/null +++ b/apps/server/src/checkpointing/CheckpointCaptureBackoff.test.ts @@ -0,0 +1,169 @@ +import { it } from "@effect/vitest"; +import { ThreadId, VcsProcessTimeoutError } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import { describe, expect } from "vite-plus/test"; + +import * as CheckpointStore from "./CheckpointStore.ts"; +import { checkpointRefForThreadTurn } from "./Utils.ts"; +import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts"; +import type * as VcsDriver from "../vcs/VcsDriver.ts"; + +const CWD = "/repo/huge-monorepo"; +const THREAD_ID = ThreadId.make("thread-checkpoint-backoff"); + +const captureTimeout = new VcsProcessTimeoutError({ + operation: "GitVcsDriver.checkpoints.captureCheckpoint", + command: "git add", + cwd: CWD, + timeoutMs: 30_000, +}); + +/** + * A driver whose capture always exceeds the process timeout, matching a + * repository too large for a full-tree `git add -A` to finish in time. + */ +function makeAlwaysTimingOutRegistry( + captureAttempts: { count: number }, + options: { readonly succeedOnAttempt?: number } = {}, +) { + const checkpoints = { + captureCheckpoint: () => + Effect.suspend(() => { + captureAttempts.count += 1; + return captureAttempts.count === options.succeedOnAttempt + ? Effect.void + : Effect.fail(captureTimeout); + }), + hasCheckpointRef: () => Effect.succeed(false), + restoreCheckpoint: () => Effect.succeed(false), + diffCheckpoints: () => Effect.succeed(""), + deleteCheckpointRefs: () => Effect.void, + } as unknown as VcsDriver.VcsCheckpointOps; + + const handle = { + kind: "git" as const, + repository: { + kind: "git" as const, + rootPath: CWD, + metadataPath: `${CWD}/.git`, + bare: false, + freshness: { source: "cache" as const, checkedAt: 0 }, + }, + driver: { checkpoints } as unknown as VcsDriver.VcsDriver["Service"], + } as unknown as VcsDriverRegistry.VcsDriverHandle; + + return Layer.succeed( + VcsDriverRegistry.VcsDriverRegistry, + VcsDriverRegistry.VcsDriverRegistry.of({ + get: () => Effect.succeed(handle.driver), + detect: () => Effect.succeed(handle), + resolve: () => Effect.succeed(handle), + }), + ); +} + +describe("checkpoint capture backoff", () => { + it.effect("stops re-running a capture that keeps timing out", () => { + const captureAttempts = { count: 0 }; + + return Effect.gen(function* () { + const store = yield* CheckpointStore.CheckpointStore; + const capture = (turn: number) => + store + .captureCheckpoint({ + cwd: CWD, + checkpointRef: checkpointRefForThreadTurn(THREAD_ID, turn), + }) + .pipe(Effect.flip); + + // The first three turns each pay for a real capture attempt. + for (let turn = 1; turn <= 3; turn += 1) { + const error = yield* capture(turn); + expect(error._tag).toBe("VcsProcessTimeoutError"); + } + expect(captureAttempts.count).toBe(3); + + // Every later turn inside the cooldown replays the recorded failure + // without spawning git again. The cooldown is minutes long, so the rest + // of this test runs well inside it. + for (let turn = 4; turn <= 20; turn += 1) { + const error = yield* capture(turn); + expect(error).toBe(captureTimeout); + } + expect(captureAttempts.count).toBe(3); + }).pipe( + Effect.provide( + CheckpointStore.layer.pipe(Layer.provide(makeAlwaysTimingOutRegistry(captureAttempts))), + ), + ); + }); + + it.effect("does not hold a workspace when the driver cannot be resolved", () => { + const captureAttempts = { count: 0 }; + const registryFailure = new VcsProcessTimeoutError({ + operation: "VcsDriverRegistry.resolve", + command: "git rev-parse", + cwd: CWD, + timeoutMs: 5_000, + }); + const failingRegistry = Layer.succeed( + VcsDriverRegistry.VcsDriverRegistry, + VcsDriverRegistry.VcsDriverRegistry.of({ + get: () => Effect.fail(registryFailure), + detect: () => Effect.fail(registryFailure), + resolve: () => Effect.fail(registryFailure), + }) as never, + ); + + return Effect.gen(function* () { + const store = yield* CheckpointStore.CheckpointStore; + const capture = (turn: number) => + store + .captureCheckpoint({ + cwd: CWD, + checkpointRef: checkpointRefForThreadTurn(THREAD_ID, turn), + }) + .pipe(Effect.flip); + + // Failing before the driver runs still counts as a failure, so the + // first two turns stay under the threshold and keep retrying rather + // than being held by a stale reservation. + for (let turn = 1; turn <= 2; turn += 1) { + const error = yield* capture(turn); + expect(error).toBe(registryFailure); + } + expect(captureAttempts.count).toBe(0); + }).pipe(Effect.provide(CheckpointStore.layer.pipe(Layer.provide(failingRegistry)))); + }); + + it.effect("keeps capturing for a workspace that recovers", () => { + const captureAttempts = { count: 0 }; + + return Effect.gen(function* () { + const store = yield* CheckpointStore.CheckpointStore; + const capture = (turn: number) => + store.captureCheckpoint({ + cwd: CWD, + checkpointRef: checkpointRefForThreadTurn(THREAD_ID, turn), + }); + + // Two failures stay under the threshold, and the success that follows + // clears them, so a later isolated failure does not open a cooldown. + yield* capture(1).pipe(Effect.flip); + yield* capture(2).pipe(Effect.flip); + yield* capture(3); + yield* capture(4).pipe(Effect.flip); + yield* capture(5).pipe(Effect.flip); + yield* capture(6).pipe(Effect.flip); + + expect(captureAttempts.count).toBe(6); + }).pipe( + Effect.provide( + CheckpointStore.layer.pipe( + Layer.provide(makeAlwaysTimingOutRegistry(captureAttempts, { succeedOnAttempt: 3 })), + ), + ), + ); + }); +}); diff --git a/apps/server/src/checkpointing/CheckpointDiffQuery.test.ts b/apps/server/src/checkpointing/CheckpointDiffQuery.test.ts index c9f514037804..7aa52074a376 100644 --- a/apps/server/src/checkpointing/CheckpointDiffQuery.test.ts +++ b/apps/server/src/checkpointing/CheckpointDiffQuery.test.ts @@ -78,6 +78,8 @@ describe("CheckpointDiffQuery.layer", () => { getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("CheckpointDiffQuery should not request the command read model"), + getThreadActivitiesPage: () => + Effect.die("CheckpointDiffQuery should not request thread activities"), getSnapshot: () => Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"), getShellSnapshot: () => @@ -111,9 +113,11 @@ describe("CheckpointDiffQuery.layer", () => { getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), getThreadDetailById: () => Effect.succeed(Option.none()), getThreadDetailSnapshot: () => Effect.succeed(Option.none()), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.succeed(Option.none()), }), ), ); @@ -192,6 +196,8 @@ describe("CheckpointDiffQuery.layer", () => { getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("CheckpointDiffQuery should not request the command read model"), + getThreadActivitiesPage: () => + Effect.die("CheckpointDiffQuery should not request thread activities"), getSnapshot: () => Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"), getShellSnapshot: () => @@ -210,9 +216,11 @@ describe("CheckpointDiffQuery.layer", () => { getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), getThreadDetailById: () => Effect.succeed(Option.none()), getThreadDetailSnapshot: () => Effect.succeed(Option.none()), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.succeed(Option.none()), }), ), ); @@ -281,6 +289,8 @@ describe("CheckpointDiffQuery.layer", () => { getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("CheckpointDiffQuery should not request the command read model"), + getThreadActivitiesPage: () => + Effect.die("CheckpointDiffQuery should not request thread activities"), getSnapshot: () => Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"), getShellSnapshot: () => @@ -299,9 +309,11 @@ describe("CheckpointDiffQuery.layer", () => { getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), getThreadDetailById: () => Effect.succeed(Option.none()), getThreadDetailSnapshot: () => Effect.succeed(Option.none()), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.succeed(Option.none()), }), ), ); @@ -355,6 +367,8 @@ describe("CheckpointDiffQuery.layer", () => { getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("CheckpointDiffQuery should not request the command read model"), + getThreadActivitiesPage: () => + Effect.die("CheckpointDiffQuery should not request thread activities"), getSnapshot: () => Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"), getShellSnapshot: () => @@ -373,9 +387,11 @@ describe("CheckpointDiffQuery.layer", () => { getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), getThreadDetailById: () => Effect.succeed(Option.none()), getThreadDetailSnapshot: () => Effect.succeed(Option.none()), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.succeed(Option.none()), }), ), ); @@ -414,6 +430,8 @@ describe("CheckpointDiffQuery.layer", () => { getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("CheckpointDiffQuery should not request the command read model"), + getThreadActivitiesPage: () => + Effect.die("CheckpointDiffQuery should not request thread activities"), getSnapshot: () => Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"), getShellSnapshot: () => @@ -432,9 +450,11 @@ describe("CheckpointDiffQuery.layer", () => { getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), getThreadDetailById: () => Effect.succeed(Option.none()), getThreadDetailSnapshot: () => Effect.succeed(Option.none()), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.succeed(Option.none()), }), ), ); diff --git a/apps/server/src/checkpointing/CheckpointStore.ts b/apps/server/src/checkpointing/CheckpointStore.ts index 0c9e60d76a65..27647dfc61f9 100644 --- a/apps/server/src/checkpointing/CheckpointStore.ts +++ b/apps/server/src/checkpointing/CheckpointStore.ts @@ -14,10 +14,12 @@ * @module CheckpointStore */ import { VcsUnsupportedOperationError, type CheckpointRef } from "@t3tools/contracts"; +import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; +import { makeCaptureBackoff } from "./CaptureBackoff.ts"; import type { CheckpointStoreError } from "./Errors.ts"; import type { VcsCheckpointOps } from "../vcs/VcsDriver.ts"; import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts"; @@ -101,6 +103,7 @@ export class CheckpointStore extends Context.Service< /** @public Service construction is part of the canonical Effect module API. */ export const make = Effect.gen(function* () { const vcsRegistry = yield* VcsDriverRegistry.VcsDriverRegistry; + const captureBackoff = makeCaptureBackoff(); const resolveCheckpoints = Effect.fn("CheckpointStore.resolveCheckpoints")(function* ( operation: string, @@ -119,14 +122,46 @@ export const make = Effect.gen(function* () { const isGitRepository: CheckpointStore["Service"]["isGitRepository"] = (cwd) => vcsRegistry - .detect({ cwd, requestedKind: "git" }) + .detect({ cwd, requestedKind: "git", fresh: true }) .pipe(Effect.map((repository) => repository !== null)); const captureCheckpoint: CheckpointStore["Service"]["captureCheckpoint"] = Effect.fn( "captureCheckpoint", )(function* (input) { - const checkpoints = yield* resolveCheckpoints("CheckpointStore.captureCheckpoint", input.cwd); - return yield* checkpoints.captureCheckpoint(input); + const startedAt = yield* Clock.currentTimeMillis; + const decision = captureBackoff.beginAttempt(input.cwd, startedAt); + if (decision.skip && decision.lastError) { + // Spawning git here would repeat a capture that cannot succeed, so + // replay the failure the caller already handles instead of burning a + // CPU core and leaving another orphaned tmp_pack behind. + yield* Effect.logDebug("Skipping checkpoint capture during failure cooldown", { + cwdLength: input.cwd.length, + remainingMs: decision.remainingMs, + }); + return yield* Effect.fail(decision.lastError); + } + + // Resolving the driver sits inside the reported scope so that a failure + // before the capture runs still replaces this caller's reservation with a + // real outcome, rather than leaving the workspace held until it lapses. + return yield* Effect.gen(function* () { + const checkpoints = yield* resolveCheckpoints("CheckpointStore.captureCheckpoint", input.cwd); + return yield* checkpoints.captureCheckpoint(input); + }).pipe( + Effect.tap(() => Effect.sync(() => captureBackoff.recordSuccess(input.cwd))), + Effect.tapError((error) => + Effect.gen(function* () { + const failedAt = yield* Clock.currentTimeMillis; + const outcome = captureBackoff.recordFailure(input.cwd, failedAt, error); + yield* Effect.logWarning("Checkpoint capture failed", { + cwdLength: input.cwd.length, + consecutiveFailures: outcome.consecutiveFailures, + cooldownMs: outcome.cooldownMs, + error, + }); + }), + ), + ); }); const hasCheckpointRef: CheckpointStore["Service"]["hasCheckpointRef"] = Effect.fn( diff --git a/apps/server/src/cli/backfillGrok.ts b/apps/server/src/cli/backfillGrok.ts new file mode 100644 index 000000000000..9211e3d8b29c --- /dev/null +++ b/apps/server/src/cli/backfillGrok.ts @@ -0,0 +1,87 @@ +import * as Console from "effect/Console"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import { Argument, Command, Flag } from "effect/unstable/cli"; + +import { + formatGrokBackfillResult, + runGrokBackfill, +} from "../externalSessions/backfillGrokSession.ts"; +import { baseDirFlag } from "./config.ts"; + +const threadIdArgument = Argument.string("thread-id").pipe( + Argument.withDescription("T3 thread id to backfill grok messages into."), +); +const sessionIdFlag = Flag.string("session-id").pipe( + Flag.withDescription("Grok ACP session id (defaults to the thread's resume cursor)."), + Flag.optional, +); +const historyFlag = Flag.string("history").pipe( + Flag.withDescription("Path to grok chat_history.jsonl (defaults to the session's on-disk file)."), + Flag.optional, +); +const cwdFlag = Flag.string("cwd").pipe( + Flag.withDescription("Session working directory (used to locate the grok history file)."), + Flag.optional, +); +const dbFlag = Flag.string("db").pipe( + Flag.withDescription( + "Path to the T3 state.sqlite (defaults to /userdata/state.sqlite).", + ), + Flag.optional, +); +const dryRunFlag = Flag.boolean("dry-run").pipe( + Flag.withDescription("Print the messages that would be added without writing."), + Flag.withDefault(false), +); +const jsonFlag = Flag.boolean("json").pipe( + Flag.withDescription("Print the result as JSON."), + Flag.withDefault(false), +); +const rebuildAllFlag = Flag.boolean("rebuild-all").pipe( + Flag.withDescription( + "Rebuild the entire transcript from grok's log instead of only the tail (repairs wrong, not just missing, messages).", + ), + Flag.withDefault(false), +); +const forceFlag = Flag.boolean("force").pipe( + Flag.withDescription( + "Emit the resync event even when no messages are missing (re-syncs clients stuck on a stale cached transcript).", + ), + Flag.withDefault(false), +); + +export const backfillGrokCommand = Command.make("backfill-grok", { + threadId: threadIdArgument, + sessionId: sessionIdFlag, + history: historyFlag, + cwd: cwdFlag, + db: dbFlag, + baseDir: baseDirFlag, + dryRun: dryRunFlag, + rebuildAll: rebuildAllFlag, + force: forceFlag, + json: jsonFlag, +}).pipe( + Command.withDescription( + "Backfill missing user + grok messages from a grok CLI session into an existing T3 thread.", + ), + Command.withHandler((flags) => + Effect.sync(() => + formatGrokBackfillResult( + runGrokBackfill({ + threadId: flags.threadId, + dryRun: flags.dryRun, + rebuildAll: flags.rebuildAll, + force: flags.force, + ...(Option.isSome(flags.sessionId) ? { sessionId: flags.sessionId.value } : {}), + ...(Option.isSome(flags.history) ? { historyPath: flags.history.value } : {}), + ...(Option.isSome(flags.cwd) ? { cwd: flags.cwd.value } : {}), + ...(Option.isSome(flags.db) ? { dbPath: flags.db.value } : {}), + ...(Option.isSome(flags.baseDir) ? { baseDir: flags.baseDir.value } : {}), + }), + { json: flags.json }, + ), + ).pipe(Effect.flatMap((output) => Console.log(output))), + ), +); diff --git a/apps/server/src/cli/config.ts b/apps/server/src/cli/config.ts index 847edbbc4fe0..4104c7e6ade5 100644 --- a/apps/server/src/cli/config.ts +++ b/apps/server/src/cli/config.ts @@ -1,5 +1,9 @@ +// @effect-diagnostics nodeBuiltinImport:off import * as NetService from "@t3tools/shared/Net"; import { parsePersistedServerObservabilitySettings } from "@t3tools/shared/serverSettings"; +import { LOCAL_BOOTSTRAP_CREDENTIAL_FILE } from "@t3tools/shared/serverRuntime"; +import * as NodeCrypto from "node:crypto"; +import * as NodeFS from "node:fs"; import { DesktopBackendBootstrap, PortSchema } from "@t3tools/contracts"; import * as Config from "effect/Config"; import * as Duration from "effect/Duration"; @@ -21,6 +25,20 @@ const modeFlag = Flag.choice("mode", ServerConfig.RuntimeMode.literals).pipe( Flag.withDescription("Runtime mode. `desktop` keeps loopback defaults unless overridden."), Flag.optional, ); + +function getOrCreateLocalBootstrapCredential(path: string): string { + try { + return NodeFS.readFileSync(path, "utf8").trim(); + } catch { + const credential = NodeCrypto.randomBytes(24).toString("hex"); + try { + NodeFS.writeFileSync(path, `${credential}\n`, { mode: 0o600, flag: "wx" }); + return credential; + } catch { + return NodeFS.readFileSync(path, "utf8").trim(); + } + } +} const portFlag = Flag.integer("port").pipe( Flag.withSchema(PortSchema), Flag.withDescription("Port for the HTTP/WebSocket server."), @@ -300,6 +318,11 @@ export const resolveServerConfig = ( ), () => mode === "desktop", ); + const localBootstrapCredentialPath = path.join( + derivedPaths.stateDir, + LOCAL_BOOTSTRAP_CREDENTIAL_FILE, + ); + getOrCreateLocalBootstrapCredential(localBootstrapCredentialPath); const desktopBootstrapToken = bootstrap?.desktopBootstrapToken; const desktopTelemetryFd = bootstrap?.desktopTelemetryFd; const desktopTelemetryControlFd = bootstrap?.desktopTelemetryControlFd; diff --git a/apps/server/src/devStacks/DevStackPolicy.test.ts b/apps/server/src/devStacks/DevStackPolicy.test.ts new file mode 100644 index 000000000000..cdd9723d19ab --- /dev/null +++ b/apps/server/src/devStacks/DevStackPolicy.test.ts @@ -0,0 +1,150 @@ +import { DEV_STACK_SCHEMA_VERSION, type DevStackEntry } from "@t3tools/contracts"; +import { describe, expect, it } from "@effect/vitest"; +import { + DEFAULT_CONSUMERS, + DEFAULT_IDLE_MINUTES, + decide, + entryPortsFor, + isActive, + resolvePolicy, +} from "./DevStackPolicy.ts"; + +const ROOT = "/workspaces/example/feature"; + +const entry = (processes: DevStackEntry["processes"]): DevStackEntry => ({ + schema: DEV_STACK_SCHEMA_VERSION, + project: "example", + worktree: "bdb56cccb27eb374", + root: ROOT, + instance: "primary", + processes, +}); + +const browserStack = entry([ + { role: "api", pid: 1, port: 21000, cwd: "api" }, + { role: "frontend", pid: 2, port: 22000, cwd: "frontend" }, +]); +const apiOnlyStack = entry([{ role: "api", pid: 1, port: 21000, cwd: "api" }]); + +const idle = { establishedPorts: new Set(), consumerCwds: [] }; +const policy = resolvePolicy({ entryRoles: ["frontend", "api"] }); + +describe("resolvePolicy", () => { + it("applies the documented defaults when a repository declares nothing", () => { + expect(resolvePolicy(undefined)).toEqual({ + idleMs: DEFAULT_IDLE_MINUTES * 60_000, + consumers: DEFAULT_CONSUMERS, + entryRoles: [], + }); + }); + + it("takes the repository's declaration over the defaults", () => { + expect(resolvePolicy({ idleMinutes: 45, consumers: ["cypress"], entryRoles: ["web"] })).toEqual( + { + idleMs: 45 * 60_000, + consumers: ["cypress"], + entryRoles: ["web"], + }, + ); + }); +}); + +describe("entryPortsFor", () => { + it("watches the frontend of a browser stack, not the API behind it", () => { + expect(entryPortsFor(browserStack, ["frontend", "api"])).toEqual([22000]); + }); + + it("falls through to the API when no frontend is running", () => { + expect(entryPortsFor(apiOnlyStack, ["frontend", "api"])).toEqual([21000]); + }); + + it("watches every port when the repository declared no entry roles", () => { + expect(entryPortsFor(browserStack, [])).toEqual([21000, 22000]); + }); + + it("watches nothing when declared roles match no running process", () => { + expect(entryPortsFor(browserStack, ["worker"])).toEqual([]); + }); +}); + +describe("isActive", () => { + it("ignores a connection to the API of a browser stack", () => { + expect(isActive(browserStack, policy, { ...idle, establishedPorts: new Set([21000]) })).toBe( + false, + ); + }); + + it("counts a connection to the entry port", () => { + expect(isActive(browserStack, policy, { ...idle, establishedPorts: new Set([22000]) })).toBe( + true, + ); + }); + + it("counts a consumer working anywhere inside the worktree", () => { + expect(isActive(browserStack, policy, { ...idle, consumerCwds: [`${ROOT}/e2e`] })).toBe(true); + expect(isActive(browserStack, policy, { ...idle, consumerCwds: [ROOT] })).toBe(true); + }); + + it("does not mistake a sibling worktree sharing a path prefix for a consumer", () => { + expect(isActive(browserStack, policy, { ...idle, consumerCwds: [`${ROOT}-other/e2e`] })).toBe( + false, + ); + }); +}); + +describe("decide", () => { + const base = { + entry: browserStack, + policy, + observation: idle, + anyProcessAlive: true, + rootExists: true, + lastSeenMs: null as number | null, + now: 1_000_000_000, + }; + + it("prunes bookkeeping when every process is already gone", () => { + expect(decide({ ...base, anyProcessAlive: false })).toEqual({ + _tag: "Prune", + reason: "no-live-processes", + }); + }); + + it("prefers pruning over reaping when the worktree is gone but so are the processes", () => { + expect(decide({ ...base, anyProcessAlive: false, rootExists: false })._tag).toBe("Prune"); + }); + + it("reaps a live stack whose worktree was removed, whatever the clock says", () => { + expect(decide({ ...base, rootExists: false, lastSeenMs: base.now })).toEqual({ + _tag: "Reap", + reason: "worktree-removed", + }); + }); + + it("starts the clock the first time it sees a stack rather than reaping it", () => { + expect(decide(base)).toEqual({ _tag: "StartClock" }); + }); + + it("keeps a stack that is still inside its idle window", () => { + const lastSeenMs = base.now - (policy.idleMs - 60_000); + expect(decide({ ...base, lastSeenMs })).toEqual({ + _tag: "Keep", + idleMs: policy.idleMs - 60_000, + }); + }); + + it("reaps once the idle window is exceeded", () => { + const lastSeenMs = base.now - (policy.idleMs + 60_000); + expect(decide({ ...base, lastSeenMs })).toEqual({ + _tag: "Reap", + reason: "idle", + idleMs: policy.idleMs + 60_000, + }); + }); + + it("refreshes an active stack instead of ageing it out", () => { + const observation = { ...idle, establishedPorts: new Set([22000]) }; + const lastSeenMs = base.now - (policy.idleMs + 60_000); + expect(decide({ ...base, observation, lastSeenMs })).toEqual({ _tag: "Active" }); + }); +}); diff --git a/apps/server/src/devStacks/DevStackPolicy.ts b/apps/server/src/devStacks/DevStackPolicy.ts new file mode 100644 index 000000000000..3981f96dc55f --- /dev/null +++ b/apps/server/src/devStacks/DevStackPolicy.ts @@ -0,0 +1,104 @@ +// @effect-diagnostics nodeBuiltinImport:off +import type { DevStackEntry, T3ProjectFileDevStacks } from "@t3tools/contracts"; +import * as NodePath from "node:path"; + +/** + * The decision half of the dev stack sweep, kept free of the filesystem, /proc, + * and signals so it can be tested directly rather than through a live stack. + */ + +export const DEFAULT_IDLE_MINUTES = 20; +export const DEFAULT_CONSUMERS: ReadonlyArray = Object.freeze(["playwright", "vitest"]); + +export interface DevStackPolicy { + readonly idleMs: number; + readonly consumers: ReadonlyArray; + readonly entryRoles: ReadonlyArray; +} + +/** + * `entryRoles` has no safe generic default, so an absent one means "watch every + * port in the stack". That over-detects activity, which is the right way to be + * wrong: a repository that has not declared its entry role keeps a stack alive + * too long rather than losing one mid-run. + */ +export const resolvePolicy = (declared: T3ProjectFileDevStacks | undefined): DevStackPolicy => ({ + idleMs: (declared?.idleMinutes ?? DEFAULT_IDLE_MINUTES) * 60_000, + consumers: declared?.consumers ?? DEFAULT_CONSUMERS, + entryRoles: declared?.entryRoles ?? [], +}); + +/** + * Ports a consumer would connect to. With `entryRoles` declared we watch the + * first role actually present, most specific first — a frontend usually holds + * keep-alive connections to its own API, so watching the API port too would read + * the stack as busy for as long as the frontend is up. + */ +export const entryPortsFor = ( + entry: DevStackEntry, + entryRoles: ReadonlyArray, +): ReadonlyArray => { + const portsOf = (role: string) => + entry.processes + .filter((process) => process.role === role && process.port !== undefined) + .map((process) => process.port as number); + for (const role of entryRoles) { + const ports = portsOf(role); + if (ports.length > 0) return ports; + } + if (entryRoles.length > 0) return []; + return entry.processes.flatMap((process) => (process.port === undefined ? [] : [process.port])); +}; + +const within = (child: string, parent: string) => + child === parent || child.startsWith(`${parent}${NodePath.sep}`); + +export interface ActivityObservation { + readonly establishedPorts: ReadonlySet; + /** Working directories of live processes whose command line matched a consumer pattern. */ + readonly consumerCwds: ReadonlyArray; +} + +export const isActive = ( + entry: DevStackEntry, + policy: DevStackPolicy, + observation: ActivityObservation, +): boolean => { + for (const port of entryPortsFor(entry, policy.entryRoles)) { + if (observation.establishedPorts.has(port)) return true; + } + return observation.consumerCwds.some((cwd) => within(cwd, entry.root)); +}; + +export type SweepDecision = + | { readonly _tag: "Active" } + /** First sighting starts the clock — a cold boot plus a build can outlast the window. */ + | { readonly _tag: "StartClock" } + | { readonly _tag: "Keep"; readonly idleMs: number } + | { readonly _tag: "Reap"; readonly reason: "idle"; readonly idleMs: number } + | { readonly _tag: "Reap"; readonly reason: "worktree-removed" } + | { readonly _tag: "Prune"; readonly reason: "no-live-processes" }; + +export interface SweepInput { + readonly entry: DevStackEntry; + readonly policy: DevStackPolicy; + readonly observation: ActivityObservation; + readonly anyProcessAlive: boolean; + readonly rootExists: boolean; + /** mtime of the sibling `.seen` marker, or null when the sweep has never seen this stack. */ + readonly lastSeenMs: number | null; + readonly now: number; +} + +export const decide = (input: SweepInput): SweepDecision => { + // Nothing left to signal: a reboot, an OOM, or a manual kill already took the + // processes and only the bookkeeping survived. + if (!input.anyProcessAlive) return { _tag: "Prune", reason: "no-live-processes" }; + if (!input.rootExists) return { _tag: "Reap", reason: "worktree-removed" }; + if (isActive(input.entry, input.policy, input.observation)) return { _tag: "Active" }; + if (input.lastSeenMs === null) return { _tag: "StartClock" }; + const idleMs = input.now - input.lastSeenMs; + return idleMs > input.policy.idleMs + ? { _tag: "Reap", reason: "idle", idleMs } + : { _tag: "Keep", idleMs }; +}; diff --git a/apps/server/src/devStacks/DevStackReaper.ts b/apps/server/src/devStacks/DevStackReaper.ts new file mode 100644 index 000000000000..ada21493f694 --- /dev/null +++ b/apps/server/src/devStacks/DevStackReaper.ts @@ -0,0 +1,347 @@ +// @effect-diagnostics nodeBuiltinImport:off globalTimers:off globalDateInEffect:off +import { DevStackEntry, DEV_STACK_REGISTRY_DIR } from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schedule from "effect/Schedule"; +import * as Schema from "effect/Schema"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as T3ProjectFileLoader from "../project/T3ProjectFileLoader.ts"; +import { + decide, + resolvePolicy, + type ActivityObservation, + type DevStackPolicy, +} from "./DevStackPolicy.ts"; + +/** + * Stops dev stacks a repository registered under `$TMPDIR/dev-stacks` once + * nothing has used them for the window that repository declared in `t3.json`. + * + * This is the level-triggered half of stack teardown. The `runOnWorktreeRemove` + * and `runOnPrMerged` project scripts remain the early reap and are strictly + * faster when they fire; they simply cannot be relied on, because both are + * edge-triggered. `runOnPrMerged` in particular only fires when + * VcsStatusBroadcaster observes a not-merged -> merged transition for a worktree + * it happens to be polling, so an agent that finishes its work and a human who + * merges an hour later produce no observer, no edge, and no teardown. Stacks have + * survived for thirteen hours that way. + * + * Looking at state instead of events means a missed hook costs one idle window + * rather than an unbounded number of hours, and it needs no cooperation from the + * repository beyond registering the stack in the first place. + */ + +const SWEEP_INTERVAL = Duration.minutes(5); + +const decodeEntry = Schema.decodeUnknownOption(DevStackEntry); + +export interface SweepSummary { + readonly scanned: number; + readonly reaped: number; + readonly pruned: number; + readonly active: number; + readonly skipped: number; + readonly durationMs: number; +} + +export class DevStackReaper extends Context.Service< + DevStackReaper, + { + /** Run one sweep now. Exposed so a caller can force one; the fiber drives the rest. */ + readonly sweep: () => Effect.Effect; + } +>()("t3/devStacks/DevStackReaper") {} + +const registryRoot = () => NodePath.join(NodeOS.tmpdir(), DEV_STACK_REGISTRY_DIR); + +const seenPathFor = (stackFile: string) => stackFile.replace(/\.json$/u, ".seen"); + +const listFiles = async (dir: string, suffix: string): Promise> => { + const out: string[] = []; + const projects = await NodeFSP.readdir(dir, { withFileTypes: true }).catch(() => []); + for (const project of projects) { + if (!project.isDirectory()) continue; + const projectDir = NodePath.join(dir, project.name); + const worktrees = await NodeFSP.readdir(projectDir, { withFileTypes: true }).catch(() => []); + for (const worktree of worktrees) { + if (!worktree.isDirectory()) continue; + const worktreeDir = NodePath.join(projectDir, worktree.name); + const entries = await NodeFSP.readdir(worktreeDir).catch(() => []); + for (const name of entries) + if (name.endsWith(suffix)) out.push(NodePath.join(worktreeDir, name)); + } + } + return out; +}; + +const alive = (pid: number) => { + try { + process.kill(pid, 0); + return true; + } catch { + return false; + } +}; + +/** Confirms a PID is still the stack's own process before it is signalled. */ +const ownedBy = async (pid: number, expectedCwd: string) => { + if (!alive(pid)) return false; + try { + const [actual, expected] = await Promise.all([ + NodeFSP.realpath(`/proc/${pid}/cwd`), + NodeFSP.realpath(expectedCwd), + ]); + return actual === expected; + } catch { + return false; + } +}; + +/** + * Local ports with an ESTABLISHED connection, read from /proc so the sweep does + * not shell out. Field 1 is `HEXIP:HEXPORT`, field 3 is the state (01 = ESTABLISHED). + */ +const establishedLocalPorts = async (): Promise> => { + const ports = new Set(); + for (const file of ["/proc/net/tcp", "/proc/net/tcp6"]) { + const text = await NodeFSP.readFile(file, "utf8").catch(() => ""); + for (const line of text.split("\n").slice(1)) { + const fields = line.trim().split(/\s+/u); + if (fields.length < 4 || fields[3] !== "01") continue; + const hexPort = fields[1]?.split(":")[1]; + if (hexPort === undefined) continue; + const port = Number.parseInt(hexPort, 16); + if (Number.isFinite(port)) ports.add(port); + } + } + return ports; +}; + +/** Working directories of live processes whose command line matches any consumer pattern. */ +const consumerCwds = async (patterns: ReadonlySet): Promise> => { + if (patterns.size === 0) return []; + const cwds: string[] = []; + const entries = await NodeFSP.readdir("/proc").catch(() => []); + for (const entry of entries) { + if (!/^\d+$/u.test(entry)) continue; + try { + const cmdline = (await NodeFSP.readFile(`/proc/${entry}/cmdline`, "utf8")).replaceAll( + "\0", + " ", + ); + let matched = false; + for (const pattern of patterns) { + if (cmdline.includes(pattern)) { + matched = true; + break; + } + } + if (!matched) continue; + cwds.push(await NodeFSP.realpath(`/proc/${entry}/cwd`)); + } catch { + // Exited mid-scan, or owned by another user. Either way it is not ours. + } + } + return cwds; +}; + +const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)); + +/** SIGTERM the process group, then SIGKILL what is left. */ +const stopGroup = async (pid: number) => { + try { + process.kill(-pid, "SIGTERM"); + } catch { + return; + } + for (let attempt = 0; attempt < 20 && alive(pid); attempt++) await wait(100); + if (!alive(pid)) return; + try { + process.kill(-pid, "SIGKILL"); + } catch { + // Exited between the check and the signal. + } +}; + +const releaseLease = async (base: string, pid: number, port: number | undefined) => { + if (port === undefined) return; + const file = NodePath.join(base, "leases", `${port}.json`); + try { + const lease: unknown = JSON.parse(await NodeFSP.readFile(file, "utf8")); + if ((lease as { pid?: number }).pid !== pid) return; + } catch { + return; + } + await NodeFSP.rm(file, { force: true }); +}; + +/** + * The producer takes this lock around start and stop. Honouring it keeps the + * sweep from killing a stack that is halfway through coming up, and costs one + * stat per stack. + */ +const isLocked = async (base: string, entry: DevStackEntry) => { + const lock = NodePath.join(base, "locks", `${entry.project}-${entry.worktree}-${entry.instance}`); + try { + const owner: unknown = JSON.parse( + await NodeFSP.readFile(NodePath.join(lock, "owner.json"), "utf8"), + ); + const pid = (owner as { pid?: number }).pid; + return typeof pid === "number" && alive(pid); + } catch { + return false; + } +}; + +/** Reverse start order, so a frontend stops before the API it points at. */ +const teardown = async (base: string, entry: DevStackEntry, stackFile: string) => { + for (const process_ of [...entry.processes].reverse()) { + if (await ownedBy(process_.pid, NodePath.join(entry.root, process_.cwd))) + await stopGroup(process_.pid); + await releaseLease(base, process_.pid, process_.port); + } + await NodeFSP.rm(stackFile, { force: true }); + await NodeFSP.rm(seenPathFor(stackFile), { force: true }); +}; + +export const make = Effect.gen(function* DevStackReaperMake() { + const projectFiles = yield* T3ProjectFileLoader.T3ProjectFileLoader; + + const policyFor = Effect.fn("DevStackReaper.policyFor")(function* (root: string) { + const file = yield* projectFiles.load(root); + return Option.match(file, { + onNone: () => null, + onSome: (loaded) => (loaded.devStacks === undefined ? null : resolvePolicy(loaded.devStacks)), + }); + }); + + const sweep = Effect.fn("DevStackReaper.sweep")(function* () { + const startedAt = Date.now(); + const base = registryRoot(); + const stackFiles = yield* Effect.promise(() => + listFiles(NodePath.join(base, "stacks"), ".json"), + ); + const summary = { scanned: 0, reaped: 0, pruned: 0, active: 0, skipped: 0 }; + if (stackFiles.length === 0) return { ...summary, durationMs: Date.now() - startedAt }; + + const establishedPorts = yield* Effect.promise(establishedLocalPorts); + // Policies are resolved first so one /proc scan can serve every stack. + const resolved: Array<{ file: string; entry: DevStackEntry; policy: DevStackPolicy }> = []; + for (const file of stackFiles) { + summary.scanned++; + const raw = yield* Effect.promise(() => + NodeFSP.readFile(file, "utf8") + .then(JSON.parse) + .catch(() => null), + ); + const decoded = raw === null ? Option.none() : decodeEntry(raw); + if (Option.isNone(decoded)) { + // Not a shape we understand. Only bookkeeping is removed; no signals sent. + yield* Effect.promise(() => NodeFSP.rm(file, { force: true })); + yield* Effect.promise(() => NodeFSP.rm(seenPathFor(file), { force: true })); + summary.pruned++; + continue; + } + const entry = decoded.value; + // A repository opts in by declaring devStacks. Without it, T3 leaves the + // stack alone entirely rather than guessing a policy for someone else's repo. + const policy = yield* policyFor(entry.root); + if (policy === null) { + summary.skipped++; + continue; + } + resolved.push({ file, entry, policy }); + } + if (resolved.length === 0) return { ...summary, durationMs: Date.now() - startedAt }; + + const patterns = new Set(resolved.flatMap(({ policy }) => [...policy.consumers])); + const cwds = yield* Effect.promise(() => consumerCwds(patterns)); + const observation: ActivityObservation = { establishedPorts, consumerCwds: cwds }; + + for (const { file, entry, policy } of resolved) { + if (yield* Effect.promise(() => isLocked(base, entry))) { + summary.skipped++; + continue; + } + const anyProcessAlive = entry.processes.some((process_) => alive(process_.pid)); + const rootExists = yield* Effect.promise(() => + NodeFSP.stat(entry.root) + .then(() => true) + .catch(() => false), + ); + const lastSeenMs = yield* Effect.promise(() => + NodeFSP.stat(seenPathFor(file)) + .then((stat) => stat.mtimeMs) + .catch(() => null), + ); + const decision = decide({ + entry, + policy, + observation, + anyProcessAlive, + rootExists, + lastSeenMs, + now: Date.now(), + }); + + switch (decision._tag) { + case "Active": + case "StartClock": { + const when = new Date(); + yield* Effect.promise(async () => { + await NodeFSP.writeFile(seenPathFor(file), "").catch(() => {}); + await NodeFSP.utimes(seenPathFor(file), when, when).catch(() => {}); + }); + summary.active++; + break; + } + case "Keep": + summary.active++; + break; + case "Prune": + yield* Effect.promise(() => teardown(base, entry, file)); + summary.pruned++; + break; + case "Reap": + yield* Effect.promise(() => teardown(base, entry, file)); + summary.reaped++; + yield* Effect.logInfo("dev stack reaped").pipe( + Effect.annotateLogs({ + project: entry.project, + instance: entry.instance, + root: entry.root, + reason: decision.reason, + }), + ); + break; + } + } + + return { ...summary, durationMs: Date.now() - startedAt }; + }); + + // One layer-scoped fiber. Failures are logged and swallowed: a sweep that + // cannot read /proc must not take the server down with it. + const tick = () => + sweep().pipe( + Effect.flatMap((summary) => + summary.reaped + summary.pruned > 0 || summary.durationMs > 250 + ? // Routine quiet sweeps stay at debug; anything that acted or ran long is + // worth seeing, so "is this bogging the main loop down" stays a query. + Effect.logInfo("dev stack sweep").pipe(Effect.annotateLogs({ ...summary })) + : Effect.logDebug("dev stack sweep").pipe(Effect.annotateLogs({ ...summary })), + ), + Effect.catchCause((cause) => Effect.logWarning("dev stack sweep failed", cause)), + ); + + yield* Effect.forkScoped(tick().pipe(Effect.repeat(Schedule.spaced(SWEEP_INTERVAL)))); + + return { sweep } as const; +}); + +export const layer = Layer.effect(DevStackReaper, make); diff --git a/apps/server/src/diagnostics/HostResourceProbe.test.ts b/apps/server/src/diagnostics/HostResourceProbe.test.ts new file mode 100644 index 000000000000..f993186dbe3d --- /dev/null +++ b/apps/server/src/diagnostics/HostResourceProbe.test.ts @@ -0,0 +1,19 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { calculateCpuPercent, parseProcMemAvailableBytes } from "./HostResourceProbe.ts"; + +describe("HostResourceProbe", () => { + it("calculates aggregate busy CPU from sample deltas", () => { + expect(calculateCpuPercent({ idle: 500, total: 1_000 }, { idle: 525, total: 1_100 })).toBe(75); + }); + + it("rejects invalid CPU deltas", () => { + expect(calculateCpuPercent({ idle: 100, total: 100 }, { idle: 100, total: 100 })).toBeNull(); + }); + + it("reads Linux available memory in bytes", () => { + expect( + parseProcMemAvailableBytes("MemTotal: 8000000 kB\nMemAvailable: 2000000 kB\n"), + ).toBe(2_048_000_000); + }); +}); diff --git a/apps/server/src/diagnostics/HostResourceProbe.ts b/apps/server/src/diagnostics/HostResourceProbe.ts new file mode 100644 index 000000000000..80b077f709b3 --- /dev/null +++ b/apps/server/src/diagnostics/HostResourceProbe.ts @@ -0,0 +1,130 @@ +import type { ServerHostResourceSnapshot } from "@t3tools/contracts"; +import { HostProcessHostname, HostProcessPlatform } from "@t3tools/shared/hostProcess"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as NodeOS from "node:os"; + +export interface CpuTimes { + readonly idle: number; + readonly total: number; +} + +const CPU_SAMPLE_INTERVAL = "75 millis"; +const SNAPSHOT_TTL = "750 millis"; + +export class HostResourceProbe extends Context.Service< + HostResourceProbe, + { readonly read: Effect.Effect } +>()("t3/diagnostics/HostResourceProbe") {} + +function captureCpuTimes(): CpuTimes | null { + const cpus = NodeOS.cpus(); + if (cpus.length === 0) return null; + return cpus.reduce( + (totals, cpu) => { + const total = Object.values(cpu.times).reduce((sum, value) => sum + value, 0); + return { idle: totals.idle + cpu.times.idle, total: totals.total + total }; + }, + { idle: 0, total: 0 }, + ); +} + +export function calculateCpuPercent(before: CpuTimes, after: CpuTimes): number | null { + const totalDelta = after.total - before.total; + const idleDelta = after.idle - before.idle; + if (totalDelta <= 0 || idleDelta < 0) return null; + return Math.min(100, Math.max(0, ((totalDelta - idleDelta) / totalDelta) * 100)); +} + +export function parseProcMemAvailableBytes(contents: string): number | null { + const match = /^MemAvailable:\s+(\d+)\s+kB$/mu.exec(contents); + if (!match?.[1]) return null; + const kibibytes = Number.parseInt(match[1], 10); + return Number.isSafeInteger(kibibytes) && kibibytes >= 0 ? kibibytes * 1024 : null; +} + +const readAvailableMemory = Effect.fn("HostResourceProbe.readAvailableMemory")(function* ( + fileSystem: FileSystem.FileSystem, + hostPlatform: NodeJS.Platform, +) { + if (hostPlatform !== "linux") return { bytes: NodeOS.freemem(), source: "os" as const }; + const procMemInfo = yield* fileSystem.readFileString("/proc/meminfo").pipe(Effect.option); + if (procMemInfo._tag === "Some") { + const bytes = parseProcMemAvailableBytes(procMemInfo.value); + if (bytes !== null) return { bytes, source: "procfs" as const }; + } + return { bytes: NodeOS.freemem(), source: "os" as const }; +}); + +const unavailableSnapshot = (message: string, checkedAt: string): ServerHostResourceSnapshot => ({ + status: "unavailable", + checkedAt, + source: "unavailable", + hostname: null, + platform: null, + cpuPercent: null, + memoryUsedPercent: null, + memoryUsedBytes: null, + memoryAvailableBytes: null, + memoryTotalBytes: null, + loadAverage: null, + logicalCores: null, + message, +}); + +export const make = Effect.gen(function* HostResourceProbeMake() { + const fileSystem = yield* FileSystem.FileSystem; + const hostPlatform = yield* HostProcessPlatform; + const hostHostname = yield* HostProcessHostname; + const probe = Effect.gen(function* HostResourceProbeRead() { + const checkedAt = DateTime.formatIso(yield* DateTime.now); + const before = yield* Effect.sync(captureCpuTimes); + if (before === null) { + return unavailableSnapshot("The host did not report logical CPU data.", checkedAt); + } + + const memory = yield* readAvailableMemory(fileSystem, hostPlatform); + yield* Effect.sleep(CPU_SAMPLE_INTERVAL); + const after = yield* Effect.sync(captureCpuTimes); + if (after === null) { + return unavailableSnapshot("The host stopped reporting logical CPU data.", checkedAt); + } + + const totalMemory = NodeOS.totalmem(); + const availableMemory = Math.min(totalMemory, Math.max(0, memory.bytes)); + const usedMemory = Math.max(0, totalMemory - availableMemory); + const load = NodeOS.loadavg(); + return { + status: "supported" as const, + checkedAt, + source: memory.source, + hostname: hostHostname.trim() || null, + platform: hostPlatform, + cpuPercent: calculateCpuPercent(before, after), + memoryUsedPercent: totalMemory > 0 ? (usedMemory / totalMemory) * 100 : null, + memoryUsedBytes: usedMemory, + memoryAvailableBytes: availableMemory, + memoryTotalBytes: totalMemory > 0 ? totalMemory : null, + loadAverage: { m1: load[0] ?? 0, m5: load[1] ?? 0, m15: load[2] ?? 0 }, + logicalCores: NodeOS.cpus().length, + message: null, + } satisfies ServerHostResourceSnapshot; + }).pipe( + Effect.catchCause((cause) => + Effect.gen(function* HostResourceProbeUnavailable() { + yield* Effect.logDebug("Host resource probe unavailable", cause); + return unavailableSnapshot( + "Host resource metrics are temporarily unavailable.", + DateTime.formatIso(yield* DateTime.now), + ); + }), + ), + ); + const read = yield* Effect.cachedWithTTL(probe, SNAPSHOT_TTL); + return HostResourceProbe.of({ read }); +}); + +export const layer = Layer.effect(HostResourceProbe, make); diff --git a/apps/server/src/externalSessions/GrokTranscriptResync.test.ts b/apps/server/src/externalSessions/GrokTranscriptResync.test.ts new file mode 100644 index 000000000000..81cf4ae84296 --- /dev/null +++ b/apps/server/src/externalSessions/GrokTranscriptResync.test.ts @@ -0,0 +1,391 @@ +// @effect-diagnostics nodeBuiltinImport:off +import { assert, describe, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Stream from "effect/Stream"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { ThreadId, type OrchestrationCommand } from "@t3tools/contracts"; +import * as NodeServices from "@effect/platform-node/NodeServices"; + +import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; +import { OrphanSessionRecovery } from "../orchestration/Services/OrphanSessionRecovery.ts"; +import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import { ProviderSessionRuntimeRepository } from "../persistence/ProviderSessionRuntime.ts"; +import { ProjectionThreadMessageRepository } from "../persistence/Services/ProjectionThreadMessages.ts"; +import { GrokTranscriptResync, make } from "./GrokTranscriptResync.ts"; + +const THREAD_ID = ThreadId.make("thread-1"); + +const update = (sessionUpdate: string, text: string, timestamp: number) => + JSON.stringify({ + timestamp, + method: "session/update", + params: { sessionId: "s1", update: { sessionUpdate, content: { type: "text", text } } }, + }); + +/** + * A grok session log holding one exchange the thread has not seen. Written where + * the service looks for it (~/.grok/sessions//), under + * a cwd key no real session can use. Returns the root to remove afterwards. + */ +function writeUpdatesLog(sessionId: string, cwd: string): string { + const root = NodePath.join(NodeOS.homedir(), ".grok", "sessions", encodeURIComponent(cwd)); + const dir = NodePath.join(root, sessionId); + NodeFS.mkdirSync(dir, { recursive: true }); + const file = NodePath.join(dir, "updates.jsonl"); + NodeFS.writeFileSync( + file, + [ + update("user_message_chunk", "first question", 1700000000), + update("agent_message_chunk", "ANCHOR answer", 1700000001), + update("user_message_chunk", "only in grok", 1700000002), + update("agent_message_chunk", "grok answer only in grok", 1700000003), + ].join("\n"), + ); + return root; +} + +const existingRows = [ + { + messageId: "m1", + threadId: THREAD_ID, + turnId: null, + role: "user" as const, + text: "first question", + isStreaming: false, + createdAt: "2026-07-13T21:00:00.000Z", + updatedAt: "2026-07-13T21:00:00.000Z", + }, + { + messageId: "m2", + threadId: THREAD_ID, + turnId: null, + role: "assistant" as const, + text: "ANCHOR answer", + createdAt: "2026-07-13T21:00:01.000Z", + isStreaming: false, + updatedAt: "2026-07-13T21:00:01.000Z", + }, +]; + +const testLayer = (input: { + readonly status: string; + readonly providerName: string; + readonly sessionId: string; + readonly cwd: string; + readonly dispatched: Array; + /** Orchestration session status (defaults to ready — idle between turns). */ + readonly sessionStatus?: "ready" | "running" | "stopped" | "interrupted"; + readonly activeTurnId?: string | null; + /** Live ACP process present (only blocks resync when also mid-turn). */ + readonly hasLiveProcess?: boolean; + /** When true, settleIfOrphan claims a zombie mid-turn. */ + readonly treatRunningAsOrphan?: boolean; +}) => { + return Layer.effect(GrokTranscriptResync, make).pipe( + Layer.provide( + Layer.mergeAll( + Layer.mock(ProviderSessionRuntimeRepository)({ + getByThreadId: () => + Effect.succeed( + Option.some({ + threadId: THREAD_ID, + providerName: input.providerName, + providerInstanceId: null, + adapterKey: "grok", + runtimeMode: "full-access" as const, + status: input.status as never, + lastSeenAt: "2026-07-14T00:00:00.000Z", + resumeCursor: { sessionId: input.sessionId }, + runtimePayload: { cwd: input.cwd }, + }), + ), + }), + Layer.mock(ProjectionThreadMessageRepository)({ + listByThreadId: () => Effect.succeed(existingRows as never), + }), + Layer.mock(ProjectionSnapshotQuery)({ + getCommandReadModel: () => Effect.die("unused"), + getSnapshot: () => Effect.die("unused"), + getShellSnapshot: () => Effect.die("unused"), + getArchivedShellSnapshot: () => Effect.die("unused"), + getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }), + getCounts: () => Effect.die("unused"), + getActiveProjectByWorkspaceRoot: () => Effect.die("unused"), + getProjectShellById: () => Effect.die("unused"), + getFirstActiveThreadIdByProjectId: () => Effect.die("unused"), + getThreadCheckpointContext: () => Effect.die("unused"), + getFullThreadDiffContext: () => Effect.die("unused"), + getThreadShellById: () => + Effect.succeed( + Option.some({ + id: THREAD_ID, + projectId: "project-1" as never, + title: "t", + session: { + threadId: THREAD_ID, + status: input.sessionStatus ?? "ready", + providerName: "grok", + runtimeMode: "full-access" as const, + activeTurnId: (input.activeTurnId ?? null) as never, + lastError: null, + updatedAt: "2026-07-14T00:00:00.000Z", + }, + } as never), + ), + getThreadDetailById: () => Effect.die("unused"), + getThreadDetailSnapshot: () => Effect.die("unused"), + }), + Layer.mock(OrchestrationEngineService)({ + readEvents: () => Stream.empty, + streamDomainEvents: Stream.empty, + dispatch: (command) => + Effect.sync(() => { + input.dispatched.push(command); + return { sequence: 1 }; + }), + }), + Layer.mock(OrphanSessionRecovery)({ + hasLiveProcess: () => Effect.succeed(input.hasLiveProcess ?? false), + settleThread: () => Effect.void, + settleIfOrphan: () => Effect.succeed(input.treatRunningAsOrphan === true), + settleAllAfterServerRestart: () => + Effect.succeed({ settledSessions: 0, settledRuntimes: 0 }), + }), + ), + ), + Layer.provideMerge(NodeServices.layer), + ); +}; + +describe("GrokTranscriptResync", () => { + it.effect("dispatches a resync when grok's log has run ahead of the thread", () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const cwd = "/tmp/t3-resync-ahead"; + const dir = writeUpdatesLog("s-ahead", cwd); + try { + const resync = yield* GrokTranscriptResync; + yield* resync.resyncThread(THREAD_ID); + assert.strictEqual(dispatched.length, 1); + const command = dispatched[0]!; + assert.strictEqual(command.type, "thread.messages.resync"); + if (command.type !== "thread.messages.resync") return; + // Rewinds to the last known-good message rather than replacing the thread. + assert.strictEqual(command.afterMessageId, "m2"); + assert.deepStrictEqual( + command.messages.map((m) => m.text), + ["only in grok", "grok answer only in grok"], + ); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }).pipe( + Effect.provide( + testLayer({ + status: "stopped", + providerName: "grok", + sessionId: "s-ahead", + cwd: "/tmp/t3-resync-ahead", + dispatched, + }), + ), + ); + }); + + it.effect( + "gives concurrent identical resyncs the same command id so dedup collapses them", + () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const dir = writeUpdatesLog("s-dedup", "/tmp/t3-resync-dedup"); + try { + const resync = yield* GrokTranscriptResync; + // Several clients opening the same thread at once each pass the + // unchanged-log check and compute the same plan before any dispatch + // lands. Command-receipt dedup collapses them only if the command id is + // derived from the plan's content rather than freshly generated. + yield* Effect.all([resync.resyncThread(THREAD_ID), resync.resyncThread(THREAD_ID)], { + concurrency: 2, + }); + assert.strictEqual(dispatched.length, 2); + assert.strictEqual(dispatched[0]!.commandId, dispatched[1]!.commandId); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }).pipe( + Effect.provide( + testLayer({ + status: "stopped", + providerName: "grok", + sessionId: "s-dedup", + cwd: "/tmp/t3-resync-dedup", + dispatched, + }), + ), + ); + }, + ); + + it.effect("does not resync while a live process is mid-turn", () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const cwd = "/tmp/t3-resync-running"; + const dir = writeUpdatesLog("s-running", cwd); + try { + const resync = yield* GrokTranscriptResync; + yield* resync.resyncThread(THREAD_ID); + // The live ACP stream owns a running turn; resyncing would race it. + assert.deepStrictEqual(dispatched, []); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }).pipe( + Effect.provide( + testLayer({ + status: "running", + providerName: "grok", + sessionId: "s-running", + cwd: "/tmp/t3-resync-running", + dispatched, + sessionStatus: "running", + activeTurnId: "turn-live", + hasLiveProcess: true, + }), + ), + ); + }); + + it.effect("resyncs when runtime is running but the turn is idle (session ready)", () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const cwd = "/tmp/t3-resync-idle-hold"; + const dir = writeUpdatesLog("s-idle-hold", cwd); + try { + const resync = yield* GrokTranscriptResync; + yield* resync.resyncThread(THREAD_ID); + // Grok keeps the process/runtime "running" between turns; external CLI + // activity must still be pulled from updates.jsonl on open. + assert.equal(dispatched.length, 1); + assert.equal(dispatched[0]?.type, "thread.messages.resync"); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }).pipe( + Effect.provide( + testLayer({ + status: "running", + providerName: "grok", + sessionId: "s-idle-hold", + cwd: "/tmp/t3-resync-idle-hold", + dispatched, + sessionStatus: "ready", + activeTurnId: null, + hasLiveProcess: true, + }), + ), + ); + }); + + it.effect("settles a zombie mid-turn runtime then resyncs from the session log", () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const cwd = "/tmp/t3-resync-zombie-running"; + const dir = writeUpdatesLog("s-zombie", cwd); + try { + const resync = yield* GrokTranscriptResync; + yield* resync.resyncThread(THREAD_ID); + assert.equal(dispatched.length, 1); + assert.equal(dispatched[0]?.type, "thread.messages.resync"); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }).pipe( + Effect.provide( + testLayer({ + status: "running", + providerName: "grok", + sessionId: "s-zombie", + cwd: "/tmp/t3-resync-zombie-running", + dispatched, + sessionStatus: "running", + activeTurnId: "turn-zombie", + hasLiveProcess: false, + treatRunningAsOrphan: true, + }), + ), + ); + }); + + it.effect("re-opening a thread whose log has not changed does no work", () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const dir = writeUpdatesLog("s-cache", "/tmp/t3-resync-cache"); + try { + const resync = yield* GrokTranscriptResync; + yield* resync.resyncThread(THREAD_ID); + assert.strictEqual(dispatched.length, 1, "first open resyncs"); + + // Thread opens are frequent and these logs reach hundreds of MB, so an + // unchanged log must not be re-read — that cost ~570ms of blocked event + // loop per open before this fingerprint check existed. + yield* resync.resyncThread(THREAD_ID); + yield* resync.resyncThread(THREAD_ID); + assert.strictEqual(dispatched.length, 1, "unchanged log must not resync again"); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }).pipe( + Effect.provide( + testLayer({ + status: "stopped", + providerName: "grok", + sessionId: "s-cache", + cwd: "/tmp/t3-resync-cache", + dispatched, + }), + ), + ); + }); + + it.effect("ignores non-grok threads", () => { + const dispatched: Array = []; + return Effect.gen(function* () { + const resync = yield* GrokTranscriptResync; + yield* resync.resyncThread(THREAD_ID); + assert.deepStrictEqual(dispatched, []); + }).pipe( + Effect.provide( + testLayer({ + status: "stopped", + providerName: "codex", + sessionId: "s-codex", + cwd: "/tmp/t3-resync-codex", + dispatched, + }), + ), + ); + }); + + it.effect("stays silent when the grok log is missing", () => + Effect.gen(function* () { + const resync = yield* GrokTranscriptResync; + // Opening a thread must not fail just because its provider log is gone. + yield* resync.resyncThread(THREAD_ID); + }).pipe( + Effect.provide( + testLayer({ + status: "stopped", + providerName: "grok", + sessionId: "s-missing", + cwd: "/tmp/t3-resync-missing", + dispatched: [], + }), + ), + ), + ); +}); diff --git a/apps/server/src/externalSessions/GrokTranscriptResync.ts b/apps/server/src/externalSessions/GrokTranscriptResync.ts new file mode 100644 index 000000000000..3a5c35e0cbe7 --- /dev/null +++ b/apps/server/src/externalSessions/GrokTranscriptResync.ts @@ -0,0 +1,242 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Detects that a grok session's own log has run ahead of the T3 thread and + * dispatches a resync. + * + * A grok session can advance without T3 seeing it: the ACP stream can drop + * updates, or the session can be driven from another grok client entirely. Grok + * records every message to its `updates.jsonl` regardless of who drives it, so + * that log — not T3's transcript — is the authority on what was said. + * + * This runs when a client opens a thread. Dispatching (rather than writing the + * projection) is what makes it visible: the event flows through the projector + * and out to every subscriber, so an open thread heals in place. + */ +import * as NodeFSP from "node:fs/promises"; + +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; + +import { + CommandId, + MessageId, + TurnId, + type OrchestrationMessage, + type ThreadId, +} from "@t3tools/contracts"; + +import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; +import { OrphanSessionRecovery } from "../orchestration/Services/OrphanSessionRecovery.ts"; +import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import { ProviderSessionRuntimeRepository } from "../persistence/ProviderSessionRuntime.ts"; +import { ProjectionThreadMessageRepository } from "../persistence/Services/ProjectionThreadMessages.ts"; +import { + planGrokBackfill, + readGrokDisplayMessagesTail, + resolveGrokChatHistoryPath, + type ExistingThreadMessage, + type GrokDisplayMessage, +} from "./backfillGrokSession.ts"; +import { stableUuid } from "./sqlite.ts"; + +const GROK_PROVIDER = "grok"; + +/** + * How much of the tail of `updates.jsonl` to read, widening only if the anchor + * is not in the smaller window. + * + * These logs are overwhelmingly tool-call traffic and grow without bound: a 150MB + * log measured here held ~140 transcript messages, i.e. roughly **one message per + * MB**. Windows must be sized against that density, not against intuition — on + * that file a 512KB tail contained zero messages, while 4MB held 8 (11ms) and + * 32MB held 43 (81ms). 4MB therefore covers an in-sync thread, whose anchor is + * its newest message. + * + * We stop at the second window rather than falling back to the whole file: this + * runs on thread open, and no UI interaction should pay a multi-hundred-MB read + * (that cost ~570ms of blocked event loop). A thread stale beyond the last window + * is left to the `backfill-grok` CLI, which is offline and may read everything. + */ +const TAIL_WINDOW_BYTES = [4 * 1024 * 1024, 32 * 1024 * 1024] as const; + +interface LogFingerprint { + readonly mtimeMs: number; + readonly size: number; +} + +function readStringField(value: unknown, field: string): string | null { + if (typeof value !== "object" || value === null) { + return null; + } + const raw = (value as Record)[field]; + return typeof raw === "string" && raw.length > 0 ? raw : null; +} + +export class GrokTranscriptResync extends Context.Service< + GrokTranscriptResync, + { + /** + * Bring the thread's transcript up to date with the grok session log. + * + * Best-effort and side-effect free when there is nothing to do. Never fails: + * a thread must still open if its provider log is unreadable. + */ + readonly resyncThread: (threadId: ThreadId) => Effect.Effect; + } +>()("t3/externalSessions/GrokTranscriptResync") {} + +export const make = Effect.gen(function* () { + const runtimeRepository = yield* ProviderSessionRuntimeRepository; + const messageRepository = yield* ProjectionThreadMessageRepository; + const orchestrationEngine = yield* OrchestrationEngineService; + // Per-thread fingerprint of the grok log as of the last check, so an unchanged + // log costs one stat() instead of a read. In-memory: losing it on restart just + // means one extra read per thread. + const lastSeenLog = new Map(); + const orphanSessionRecovery = yield* OrphanSessionRecovery; + const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; + + const resyncThread = Effect.fn("GrokTranscriptResync.resyncThread")(function* ( + threadId: ThreadId, + ) { + const runtime = yield* runtimeRepository.getByThreadId({ threadId }); + if (Option.isNone(runtime) || runtime.value.providerName !== GROK_PROVIDER) { + return; + } + + // Only skip resync while a *live* process is mid-turn. Grok routinely keeps + // a process + `provider_session_runtime.status=running` after the turn + // settles (`session.status=ready`) so the next prompt is fast — that idle + // hold must NOT block catching up external CLI activity from updates.jsonl. + // + // Mid-turn with no live process is a zombie: settle it, then resync. + const shell = yield* projectionSnapshotQuery.getThreadShellById(threadId).pipe( + Effect.map(Option.getOrUndefined), + Effect.orElseSucceed(() => undefined), + ); + const session = shell?.session ?? null; + const midTurn = session?.status === "running" && session.activeTurnId !== null; + if (midTurn) { + const live = yield* orphanSessionRecovery.hasLiveProcess(threadId); + if (live) { + return; + } + yield* orphanSessionRecovery.settleIfOrphan(threadId, "resync_zombie_running"); + } + + const sessionId = readStringField(runtime.value.resumeCursor, "sessionId"); + const cwd = readStringField(runtime.value.runtimePayload, "cwd"); + if (sessionId === null || cwd === null) { + return; + } + + const updatesPath = resolveGrokChatHistoryPath({ cwd, sessionId }); + + // Nothing can have been appended since we last looked, so there is nothing to + // catch up on. Thread opens are frequent and this is the common case, so it + // must cost a stat() rather than a read. + const stats = yield* Effect.tryPromise(() => NodeFSP.stat(updatesPath)).pipe( + Effect.option, + Effect.map(Option.getOrUndefined), + ); + if (!stats) { + return; + } + const fingerprint: LogFingerprint = { mtimeMs: stats.mtimeMs, size: stats.size }; + const seen = lastSeenLog.get(threadId); + if (seen && seen.mtimeMs === fingerprint.mtimeMs && seen.size === fingerprint.size) { + return; + } + + const existingMessages: ReadonlyArray = + (yield* messageRepository.listByThreadId({ threadId })).map((row) => ({ + messageId: row.messageId, + role: row.role, + text: row.text, + turnId: row.turnId, + attachmentsJson: JSON.stringify(row.attachments ?? []), + createdAt: row.createdAt, + updatedAt: row.updatedAt, + })); + + // Widen only on a miss: a plan error here means the anchor was not inside the + // window, which is indistinguishable from "the anchor is older than what we + // read". Anything else (including "nothing new") is a final answer. + let plan: ReturnType | undefined; + for (const windowBytes of TAIL_WINDOW_BYTES) { + const grokMessages = yield* Effect.tryPromise(() => + readGrokDisplayMessagesTail(updatesPath, windowBytes), + ).pipe(Effect.orElseSucceed(() => [] as ReadonlyArray)); + if (grokMessages.length === 0) { + continue; + } + plan = planGrokBackfill({ grokMessages, existingMessages, sessionId }); + if (plan.error === undefined) { + break; + } + if (windowBytes >= fingerprint.size) { + // We already had the whole file; a wider window cannot help. + break; + } + } + + // Record the fingerprint regardless of outcome: re-reading an unchanged file + // would reach the same conclusion, including "the anchor is too far back". + lastSeenLog.set(threadId, fingerprint); + + if (!plan || plan.error !== undefined || plan.newMessages.length === 0) { + return; + } + + const now = yield* DateTime.now; + // Derived from the resync's content, not a fresh uuid: several clients can + // open the same thread at once and each compute this identical plan before + // any of their dispatches lands. A stable id lets command-receipt dedup + // collapse those into one event instead of a burst of identical ones. + const commandId = stableUuid( + "grok-resync", + `${threadId}:${plan.anchorMessageId ?? "*"}:${plan.tail.map((m) => m.messageId).join(",")}`, + ); + yield* orchestrationEngine.dispatch({ + type: "thread.messages.resync", + commandId: CommandId.make(`grok-resync:${commandId}`), + threadId, + afterMessageId: plan.anchorMessageId === null ? null : MessageId.make(plan.anchorMessageId), + messages: plan.tail.map( + (message) => + ({ + id: MessageId.make(message.messageId), + role: message.role, + text: message.text, + turnId: message.turnId === null ? null : TurnId.make(message.turnId), + streaming: false, + createdAt: message.createdAt, + updatedAt: message.updatedAt, + }) satisfies OrchestrationMessage, + ), + reason: `grok-session:${sessionId}`, + createdAt: DateTime.formatIso(now), + }); + yield* Effect.logInfo("Resynced grok transcript from the session log.", { + threadId, + sessionId, + added: plan.newMessages.length, + }); + }); + + return { + // Opening a thread must never fail because its provider log is unreadable or + // a resync races something else, so swallow everything here. + resyncThread: (threadId: ThreadId) => + resyncThread(threadId).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to resync grok transcript.", { threadId, cause }), + ), + ), + } satisfies GrokTranscriptResync["Service"]; +}); + +export const GrokTranscriptResyncLive = Layer.effect(GrokTranscriptResync, make); diff --git a/apps/server/src/externalSessions/backfillGrokSession.test.ts b/apps/server/src/externalSessions/backfillGrokSession.test.ts new file mode 100644 index 000000000000..f8c9f90d031e --- /dev/null +++ b/apps/server/src/externalSessions/backfillGrokSession.test.ts @@ -0,0 +1,337 @@ +// @effect-diagnostics nodeBuiltinImport:off +import { assert, describe, it } from "@effect/vitest"; + +import { + planGrokBackfill, + readGrokDisplayMessages, + readGrokDisplayMessagesTail, + resolveGrokChatHistoryPath, + type ExistingThreadMessage, + type GrokDisplayMessage, +} from "./backfillGrokSession.ts"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +const SESSION_ID = "session-abc"; + +// A grok history where T3 already has the anchor assistant + two orphan user +// prompts, but is missing every grok answer and a middle prompt. +// emittedAtMs is intentionally far in the past here: the planner must still keep +// the tail ordered against the thread's existing timestamps. +const grokMessage = ( + role: "user" | "assistant", + text: string, + sourceOffset: number, +): GrokDisplayMessage => ({ role, text, sourceOffset, emittedAtMs: 0 }); + +const grok: ReadonlyArray = [ + grokMessage("user", "first question", 2), + grokMessage("assistant", "ANCHOR answer to first", 4), + grokMessage("user", "how will batches stay uptodate?", 10), + grokMessage("assistant", "grok answer to batches", 14), + grokMessage("user", "middle prompt only in grok", 18), + grokMessage("assistant", "grok answer to middle", 22), + grokMessage("user", "what model is this?", 30), + grokMessage("assistant", "grok answer about the model", 34), +]; + +const existingMessage = ( + messageId: string, + role: string, + text: string, + createdAt: string, +): ExistingThreadMessage => ({ + messageId, + role, + text, + turnId: null, + attachmentsJson: "[]", + createdAt, + updatedAt: createdAt, +}); + +const existing: ReadonlyArray = [ + existingMessage("m1", "user", "first question", "2026-07-13T21:00:00.000Z"), + existingMessage("m2", "assistant", "ANCHOR answer to first", "2026-07-13T21:07:33.745Z"), + existingMessage("m3", "user", "how will batches stay uptodate?", "2026-07-14T04:29:58.885Z"), + existingMessage("m4", "user", "what model is this?", "2026-07-14T05:20:41.120Z"), +]; + +describe("planGrokBackfill", () => { + it("adds only the new messages, skipping ones already in the thread", () => { + const plan = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + }); + assert.isUndefined(plan.error); + assert.strictEqual(plan.anchorLineIndex, 4); + // Rewind point is the last known-good message, not the whole thread. + assert.strictEqual(plan.anchorMessageId, "m2"); + // The two orphan prompts already present must be skipped, not duplicated. + assert.strictEqual(plan.skippedExisting, 2); + const added = plan.newMessages.map((m) => m.text); + assert.deepStrictEqual(added, [ + "grok answer to batches", + "middle prompt only in grok", + "grok answer to middle", + "grok answer about the model", + ]); + }); + + it("builds the full authoritative tail, preserving existing message identity", () => { + const plan = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + }); + // The tail is everything after the anchor — existing messages included, in + // their correct positions — so the projector/client can replace it wholesale. + assert.deepStrictEqual( + plan.tail.map((m) => ({ id: m.messageId, isNew: m.isNew })), + [ + { id: "m3", isNew: false }, + { id: plan.tail[1]!.messageId, isNew: true }, + { id: plan.tail[2]!.messageId, isNew: true }, + { id: plan.tail[3]!.messageId, isNew: true }, + { id: "m4", isNew: false }, + { id: plan.tail[5]!.messageId, isNew: true }, + ], + ); + // Messages the thread already had keep their original timestamps. + assert.strictEqual(plan.tail[0]!.createdAt, "2026-07-14T04:29:58.885Z"); + assert.strictEqual(plan.tail[4]!.createdAt, "2026-07-14T05:20:41.120Z"); + }); + + it("interleaves synthesized timestamps in chronological order", () => { + const plan = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + }); + const byText = new Map(plan.newMessages.map((m) => [m.text, m.createdAt])); + // Messages between the two orphan prompts land inside the 04:29 -> 05:20 gap. + assert.isTrue(byText.get("grok answer to batches")! > "2026-07-14T04:29:58.885Z"); + assert.isTrue(byText.get("grok answer to middle")! < "2026-07-14T05:20:41.120Z"); + // The final answer lands strictly after the last orphan prompt. + assert.isTrue(byText.get("grok answer about the model")! > "2026-07-14T05:20:41.120Z"); + // Timestamps are strictly increasing in emission order. + const times = plan.newMessages.map((m) => m.createdAt); + for (let i = 1; i < times.length; i += 1) { + assert.isTrue(times[i]! > times[i - 1]!); + } + }); + + it("is idempotent: re-planning after applying adds nothing", () => { + const plan = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + }); + // Applying replaces everything after the anchor with the tail. + const afterApply: ReadonlyArray = [ + existing[0]!, + existing[1]!, + ...plan.tail.map((m) => existingMessage(m.messageId, m.role, m.text, m.createdAt)), + ]; + const second = planGrokBackfill({ + grokMessages: grok, + existingMessages: afterApply, + sessionId: SESSION_ID, + }); + assert.isUndefined(second.error); + assert.strictEqual(second.newMessages.length, 0); + }); + + it("produces stable message ids across runs", () => { + const a = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + }); + const b = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + }); + assert.deepStrictEqual( + a.newMessages.map((m) => m.messageId), + b.newMessages.map((m) => m.messageId), + ); + }); + + it("rebuildAll replaces the whole transcript with no anchor", () => { + const plan = planGrokBackfill({ + grokMessages: grok, + existingMessages: existing, + sessionId: SESSION_ID, + rebuildAll: true, + }); + assert.isUndefined(plan.error); + // No anchor => the client/projector replace everything they hold. + assert.strictEqual(plan.anchorMessageId, null); + assert.strictEqual(plan.anchorLineIndex, null); + // The tail is the full grok transcript, not just what follows an anchor. + assert.strictEqual(plan.tail.length, grok.length); + assert.deepStrictEqual( + plan.tail.map((m) => m.text), + grok.map((m) => m.text), + ); + }); + + it("rebuildAll still works on a thread with no assistant message to anchor on", () => { + const plan = planGrokBackfill({ + grokMessages: grok, + existingMessages: [], + sessionId: SESSION_ID, + rebuildAll: true, + }); + assert.isUndefined(plan.error); + assert.strictEqual(plan.newMessages.length, grok.length); + }); + + it("refuses to guess when the anchor is missing from grok history", () => { + const plan = planGrokBackfill({ + grokMessages: grok.filter((m) => m.text !== "ANCHOR answer to first"), + existingMessages: existing, + sessionId: SESSION_ID, + }); + assert.isDefined(plan.error); + assert.strictEqual(plan.newMessages.length, 0); + }); +}); + +describe("readGrokDisplayMessages", () => { + const update = (sessionUpdate: string, text: string | undefined, timestamp: number) => ({ + timestamp, + method: "session/update", + params: { + sessionId: "s1", + update: { + sessionUpdate, + ...(text === undefined ? {} : { content: { type: "text", text } }), + }, + }, + }); + + it("keeps user + assistant message chunks with their emit time, drops everything else", () => { + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "grok-backfill-test-")); + const file = NodePath.join(dir, "updates.jsonl"); + const records = [ + update("user_message_chunk", "real prompt", 1700000000), + update("agent_thought_chunk", "thinking out loud", 1700000001), + update("tool_call", undefined, 1700000002), + update("tool_call_update", undefined, 1700000003), + update("agent_message_chunk", "the real answer", 1700000004), + update("hook_execution", undefined, 1700000005), + update("turn_completed", undefined, 1700000006), + update("agent_message_chunk", " ", 1700000007), + ]; + NodeFS.writeFileSync(file, records.map((r) => JSON.stringify(r)).join("\n")); + try { + const messages = readGrokDisplayMessages(file); + assert.deepStrictEqual( + messages.map((m) => ({ role: m.role, text: m.text, emittedAtMs: m.emittedAtMs })), + [ + { role: "user", text: "real prompt", emittedAtMs: 1700000000000 }, + { role: "assistant", text: "the real answer", emittedAtMs: 1700000004000 }, + ], + ); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }); + + it("returns nothing for a missing update log rather than throwing", () => { + assert.deepStrictEqual(readGrokDisplayMessages("/definitely/not/here/updates.jsonl"), []); + }); + + it("tail read yields byte-identical offsets to a full read", async () => { + // The whole point of keying on a byte offset: a windowed read must mint the + // same ids as a full read, or the same message would be backfilled twice + // under different ids depending on how much of the file we happened to read. + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "grok-tail-test-")); + const file = NodePath.join(dir, "updates.jsonl"); + const records: Array = []; + for (let i = 0; i < 40; i += 1) { + // Bulk that dwarfs the transcript, like real tool-call traffic. + records.push(JSON.stringify(update("tool_call_update", "x".repeat(500), 1700000000 + i))); + records.push(JSON.stringify(update("agent_message_chunk", `answer ${i}`, 1700000000 + i))); + } + NodeFS.writeFileSync(file, records.join("\n")); + try { + const full = readGrokDisplayMessages(file); + const size = NodeFS.statSync(file).size; + const tail = await readGrokDisplayMessagesTail(file, Math.floor(size / 4)); + + assert.isAbove(tail.length, 0, "tail window should still find messages"); + assert.isBelow(tail.length, full.length, "a quarter-window should not hold everything"); + // Every tail message matches the full read exactly, offset included. + const fullByOffset = new Map(full.map((m) => [m.sourceOffset, m])); + for (const message of tail) { + assert.deepStrictEqual(message, fullByOffset.get(message.sourceOffset)); + } + // And the tail is the END of the log. + assert.deepStrictEqual(tail.at(-1), full.at(-1)); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }); + + it("reading a window larger than the file equals a full read", async () => { + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "grok-tail-test-")); + const file = NodePath.join(dir, "updates.jsonl"); + NodeFS.writeFileSync( + file, + [ + update("user_message_chunk", "prompt", 1700000000), + update("agent_message_chunk", "answer", 1700000001), + ] + .map((r) => JSON.stringify(r)) + .join("\n"), + ); + try { + assert.deepStrictEqual( + await readGrokDisplayMessagesTail(file, 10_000_000), + readGrokDisplayMessages(file), + ); + } finally { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }); + + it("returns nothing for a missing log rather than throwing (tail)", async () => { + assert.deepStrictEqual(await readGrokDisplayMessagesTail("/nope/updates.jsonl", 1024), []); + }); +}); + +describe("resolveGrokChatHistoryPath", () => { + it("reads updates.jsonl, not the compactable chat_history.jsonl", () => { + // chat_history.jsonl is grok's LLM context and gets rewritten by compaction, + // so it cannot be trusted to still hold the messages T3 missed. + const path = resolveGrokChatHistoryPath({ cwd: "/w", sessionId: "s1" }); + assert.isTrue(path.endsWith("updates.jsonl")); + assert.isFalse(path.includes("chat_history")); + }); +}); + +describe("resolveGrokChatHistoryPath", () => { + it("url-encodes the cwd like the grok CLI does", () => { + const path = resolveGrokChatHistoryPath({ + cwd: "/home/p/.t3/worktrees/scanner/scanner-0d571b34", + sessionId: "019f5cf1", + }); + assert.isTrue( + path.endsWith( + NodePath.join( + ".grok", + "sessions", + "%2Fhome%2Fp%2F.t3%2Fworktrees%2Fscanner%2Fscanner-0d571b34", + "019f5cf1", + "updates.jsonl", + ), + ), + ); + }); +}); diff --git a/apps/server/src/externalSessions/backfillGrokSession.ts b/apps/server/src/externalSessions/backfillGrokSession.ts new file mode 100644 index 000000000000..a6b2e9aa23a1 --- /dev/null +++ b/apps/server/src/externalSessions/backfillGrokSession.ts @@ -0,0 +1,601 @@ +// @effect-diagnostics nodeBuiltinImport:off globalDate:off preferSchemaOverJson:off +// Backfill missing user + assistant messages from a grok CLI session into an +// existing T3 thread. +// +// When a grok ACP session gets wedged (see effect-acp Interrupt-frame leak), or +// the conversation continues outside T3, T3 stops ingesting grok's +// `session/update` notifications while grok keeps persisting them to +// `~/.grok/sessions/.../updates.jsonl`. The T3 transcript is then missing the +// tail. This tool reconstructs that tail: it anchors on T3's last assistant +// message (the last known-good point), walks grok's update log after it, and +// emits a single `thread.messages-resynced` event carrying that anchor plus the +// authoritative tail. Messages the thread already has keep their identity and +// timestamp; new ones carry grok's own emit time. +// +// It deliberately emits an EVENT rather than writing the projection directly: +// clients resume from `afterSequence` and never re-read the projection, so a +// direct write would be invisible to them forever. It is idempotent — re-running +// an identical backfill yields the same event id and changes nothing. +import * as NodeFS from "node:fs"; +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { homePath, sql, sqliteExec, sqliteJson, stableUuid } from "./sqlite.ts"; + +const GROK_PROVIDER = "grok"; + +export interface GrokDisplayMessage { + readonly role: "user" | "assistant"; + readonly text: string; + /** + * Byte offset of the line in updates.jsonl — the stable identity/order key. + * A byte offset (not a line number) so it stays identical whether the file was + * read whole or from a tail window; a line number would depend on where the + * read began and would mint different ids for the same message. + */ + readonly sourceOffset: number; + /** When grok emitted it (ms). */ + readonly emittedAtMs: number; +} + +export interface ExistingThreadMessage { + readonly messageId: string; + readonly role: string; + readonly text: string; + readonly turnId: string | null; + readonly attachmentsJson: string; + readonly createdAt: string; + readonly updatedAt: string; +} + +export interface GrokBackfillMessage { + readonly role: "user" | "assistant"; + readonly text: string; + readonly sourceOffset: number; + readonly messageId: string; + readonly turnId: string | null; + readonly attachmentsJson: string; + readonly createdAt: string; + readonly updatedAt: string; + /** False for messages the thread already had (kept for position/identity). */ + readonly isNew: boolean; +} + +export interface GrokBackfillPlan { + /** Last known-good message: the resync rewinds to just after this one. */ + readonly anchorMessageId: string | null; + readonly anchorLineIndex: number | null; + readonly skippedExisting: number; + /** The complete authoritative transcript after the anchor, in order. */ + readonly tail: ReadonlyArray; + readonly newMessages: ReadonlyArray; + readonly error?: string; +} + +export type GrokBackfillStatus = "backfilled" | "up-to-date" | "dry-run" | "error"; + +export interface GrokBackfillResult { + readonly threadId: string; + readonly sessionId: string | null; + readonly historyPath: string | null; + readonly status: GrokBackfillStatus; + readonly addedCount: number; + readonly skippedExisting: number; + readonly anchorLineIndex: number | null; + readonly newMessages: ReadonlyArray; + readonly error?: string; +} + +export interface RunGrokBackfillOptions { + readonly threadId: string; + readonly sessionId?: string; + readonly historyPath?: string; + readonly cwd?: string; + readonly baseDir?: string; + readonly dbPath?: string; + readonly dryRun: boolean; + /** + * Replace the whole transcript from grok rather than only the tail after the + * anchor. Repairs a thread whose existing messages are wrong, not just + * missing. Destructive: grok's log becomes the sole source of truth. + */ + readonly rebuildAll?: boolean; + /** + * Emit the resync event even when the projection already holds every message. + * Needed when a transcript was repaired out-of-band without an event: the rows + * are right but connected clients never heard about it, so they are stuck on a + * stale cached snapshot until a resync event reaches them. + */ + readonly force?: boolean; +} + +const normalize = (value: string): string => value.replace(/\s+/g, " ").trim(); + +/** + * One `updates.jsonl` record -> a transcript message, if it is one. + * + * Only `user_message_chunk` and `agent_message_chunk` are transcript content; + * thoughts, tool calls, plans and hook/compaction bookkeeping are skipped. + */ +function parseUpdateLine(line: string, sourceOffset: number): GrokDisplayMessage | undefined { + const trimmed = line.trim(); + if (trimmed.length === 0) { + return undefined; + } + let record: Record; + try { + record = JSON.parse(trimmed) as Record; + } catch { + return undefined; + } + const params = record.params; + if (typeof params !== "object" || params === null) { + return undefined; + } + const update = (params as Record).update; + if (typeof update !== "object" || update === null) { + return undefined; + } + const kind = (update as Record).sessionUpdate; + const role = + kind === "user_message_chunk" ? "user" : kind === "agent_message_chunk" ? "assistant" : null; + if (role === null) { + return undefined; + } + const content = (update as Record).content; + const text = + typeof content === "object" && content !== null + ? (content as Record).text + : undefined; + if (typeof text !== "string" || text.trim().length === 0) { + return undefined; + } + // grok stamps unix seconds. + const timestamp = record.timestamp; + const emittedAtMs = typeof timestamp === "number" ? timestamp * 1000 : Number.NaN; + return { role, text, sourceOffset, emittedAtMs }; +} + +function collectFromChunk( + chunk: string, + chunkStartOffset: number, +): ReadonlyArray { + const out: Array = []; + let cursor = 0; + for (const line of chunk.split("\n")) { + const message = parseUpdateLine(line, chunkStartOffset + cursor); + if (message) { + out.push(message); + } + cursor += Buffer.byteLength(line, "utf8") + 1; + } + return out; +} + +/** + * Read grok's `updates.jsonl` — the session/update notification log, the same + * stream T3 ingests live over ACP, and NOT `chat_history.jsonl`. chat_history is + * grok's LLM context: grok compacts it, rewriting and discarding old turns, so + * it is not a transcript and cannot be relied on to still hold what T3 missed. + * `updates.jsonl` is append-only, survives compaction, and carries real emit + * timestamps. + * + * Reads the whole log: blocking and unbounded — these files reach hundreds of MB, + * so this is for offline tooling (the CLI) only. Anything on a request path must + * use `readGrokDisplayMessagesTail`. + */ +export function readGrokDisplayMessages(updatesPath: string): ReadonlyArray { + if (!NodeFS.existsSync(updatesPath)) { + return []; + } + return collectFromChunk(NodeFS.readFileSync(updatesPath, "utf8"), 0); +} + +/** + * Read at most the last `maxBytes` of the log, without loading the rest. + * + * These logs are dominated by tool-call traffic and grow without bound (150MB + * observed for ~140 messages), so reading one whole file cost ~570ms of blocked + * event loop per call. The transcript tail we actually need sits at the end, so + * read backwards from there. + * + * A window that starts mid-line would yield a truncated record, so the first + * partial line is dropped — meaning a caller must tolerate the window missing + * older messages (widen, or give up) rather than treat this as the full log. + */ +export async function readGrokDisplayMessagesTail( + updatesPath: string, + maxBytes: number, +): Promise> { + let handle: NodeFSP.FileHandle; + try { + handle = await NodeFSP.open(updatesPath, "r"); + } catch { + return []; + } + try { + const { size } = await handle.stat(); + const start = Math.max(0, size - maxBytes); + const length = size - start; + if (length <= 0) { + return []; + } + const buffer = Buffer.allocUnsafe(length); + await handle.read(buffer, 0, length, start); + const chunk = buffer.toString("utf8"); + if (start === 0) { + return collectFromChunk(chunk, 0); + } + // Drop the (probably partial) first line and resume at the next boundary. + const firstBreak = chunk.indexOf("\n"); + if (firstBreak === -1) { + return []; + } + const rest = chunk.slice(firstBreak + 1); + return collectFromChunk( + rest, + start + Buffer.byteLength(chunk.slice(0, firstBreak + 1), "utf8"), + ); + } finally { + await handle.close(); + } +} + +/** + * Compute the append plan. Pure: given grok's displayable messages and the + * thread's existing messages, decide which grok messages are new and what + * timestamp each should carry. Anchors on T3's last assistant message; refuses + * to guess if that anchor cannot be located in grok's history. + */ +export function planGrokBackfill(input: { + readonly grokMessages: ReadonlyArray; + readonly existingMessages: ReadonlyArray; + readonly sessionId: string; + /** + * Rebuild the whole transcript from grok instead of only the tail after the + * anchor. For repairing a thread whose existing messages are themselves wrong + * (not merely missing) — grok's log is then the sole source of truth, so only + * do this when it demonstrably covers the entire session. + */ + readonly rebuildAll?: boolean; +}): GrokBackfillPlan { + const { grokMessages, existingMessages, sessionId } = input; + const rebuildAll = input.rebuildAll === true; + + // Everything before the anchor is trusted as-is; a full rebuild trusts nothing + // and replays from the start. + let anchorIndex = -1; + let anchorMessageId: string | null = null; + let cursorMs = 0; + + if (!rebuildAll) { + const assistants = existingMessages.filter((message) => message.role === "assistant"); + if (assistants.length === 0) { + return { + anchorMessageId: null, + anchorLineIndex: null, + skippedExisting: 0, + tail: [], + newMessages: [], + error: "T3 thread has no assistant message to anchor on.", + }; + } + const lastAssistant = assistants[assistants.length - 1]!; + const lastAssistantNorm = normalize(lastAssistant.text); + + // Anchor on the LAST grok assistant message that matches T3's last assistant + // (prefix either way tolerates one side having truncated the text). + for (let i = grokMessages.length - 1; i >= 0; i -= 1) { + const candidate = grokMessages[i]!; + if (candidate.role !== "assistant") { + continue; + } + const candidateNorm = normalize(candidate.text); + if ( + candidateNorm === lastAssistantNorm || + candidateNorm.startsWith(lastAssistantNorm) || + lastAssistantNorm.startsWith(candidateNorm) + ) { + anchorIndex = i; + break; + } + } + if (anchorIndex === -1) { + return { + anchorMessageId: null, + anchorLineIndex: null, + skippedExisting: 0, + tail: [], + newMessages: [], + error: + "Could not locate T3's last assistant message in grok history; refusing to guess the anchor.", + }; + } + anchorMessageId = lastAssistant.messageId; + cursorMs = Date.parse(lastAssistant.createdAt); + } + + const existingByKey = new Map(); + for (const message of existingMessages) { + existingByKey.set(`${message.role}|${normalize(message.text)}`, message); + } + + // Build the complete authoritative transcript after the anchor. Messages the + // thread already has keep their identity and timestamp (they are correct, just + // stranded); genuinely new ones get a stable id and a synthesized timestamp + // that slots them into the real chronological gap. + const tail: Array = []; + const newMessages: Array = []; + let skippedExisting = 0; + + for (const message of grokMessages.slice(anchorIndex + 1)) { + const key = `${message.role}|${normalize(message.text)}`; + const existing = existingByKey.get(key); + if (existing !== undefined) { + const parsed = Date.parse(existing.createdAt); + if (Number.isFinite(parsed)) { + cursorMs = Math.max(cursorMs, parsed); + } + skippedExisting += 1; + tail.push({ + role: message.role, + text: existing.text, + sourceOffset: message.sourceOffset, + messageId: existing.messageId, + turnId: existing.turnId, + attachmentsJson: existing.attachmentsJson, + createdAt: existing.createdAt, + updatedAt: existing.updatedAt, + isNew: false, + }); + continue; + } + // Prefer grok's own emit time, but never let it break ordering against the + // messages we are splicing between (clocks and ingest lag can disagree). + cursorMs = Number.isFinite(message.emittedAtMs) + ? Math.max(cursorMs + 1, message.emittedAtMs) + : cursorMs + 1; + const createdAt = new Date(cursorMs).toISOString(); + const entry: GrokBackfillMessage = { + role: message.role, + text: message.text, + sourceOffset: message.sourceOffset, + messageId: stableUuid("t3-grok-backfill-message", `${sessionId}:${message.sourceOffset}`), + turnId: null, + attachmentsJson: "[]", + createdAt, + updatedAt: createdAt, + isNew: true, + }; + tail.push(entry); + newMessages.push(entry); + } + + return { + anchorMessageId, + anchorLineIndex: anchorIndex === -1 ? null : grokMessages[anchorIndex]!.sourceOffset, + skippedExisting, + tail, + newMessages, + }; +} + +function readExistingThreadMessages( + dbPath: string, + threadId: string, +): ReadonlyArray { + return sqliteJson( + dbPath, + `SELECT message_id, role, text, turn_id, attachments_json, created_at, updated_at + FROM projection_thread_messages + WHERE thread_id = ${sql(threadId)} ORDER BY created_at ASC, message_id ASC`, + ).map((row) => ({ + messageId: String(row.message_id), + role: String(row.role), + text: String(row.text ?? ""), + turnId: row.turn_id == null ? null : String(row.turn_id), + attachmentsJson: row.attachments_json == null ? "[]" : String(row.attachments_json), + createdAt: String(row.created_at), + updatedAt: String(row.updated_at ?? row.created_at), + })); +} + +function resolveGrokSessionMeta( + dbPath: string, + threadId: string, +): { readonly sessionId: string | null; readonly cwd: string | null } { + const row = sqliteJson( + dbPath, + `SELECT json_extract(resume_cursor_json, '$.sessionId') AS session_id, + json_extract(runtime_payload_json, '$.cwd') AS cwd + FROM provider_session_runtime + WHERE thread_id = ${sql(threadId)} AND provider_name = ${sql(GROK_PROVIDER)} + LIMIT 1`, + )[0]; + return { + sessionId: row && row.session_id != null ? String(row.session_id) : null, + cwd: row && row.cwd != null ? String(row.cwd) : null, + }; +} + +/** + * Grok persists sessions under ~/.grok/sessions///. + * + * We read `updates.jsonl` (the append-only session/update log), not + * `chat_history.jsonl` — see readGrokDisplayMessages for why. + */ +export function resolveGrokChatHistoryPath(input: { + readonly cwd: string; + readonly sessionId: string; +}): string { + return NodePath.join( + NodeOS.homedir(), + ".grok", + "sessions", + encodeURIComponent(input.cwd), + input.sessionId, + "updates.jsonl", + ); +} + +/** + * Append the resync as a single domain event. + * + * The event — not a direct projection write — is what makes the rebuild real: + * the projector materializes it into `projection_thread_messages`, and clients + * (which resume from `afterSequence` and never re-read the projection on their + * own) receive it through the ordinary catch-up replay and splice their cached + * transcript. Writing the projection directly would be invisible to them. + */ +function appendResyncEvent( + dbPath: string, + threadId: string, + sessionId: string, + plan: GrokBackfillPlan, +): void { + const payload = { + threadId, + afterMessageId: plan.anchorMessageId, + messages: plan.tail.map((message) => ({ + id: message.messageId, + role: message.role, + text: message.text, + attachments: JSON.parse(message.attachmentsJson) as ReadonlyArray, + turnId: message.turnId, + streaming: false, + createdAt: message.createdAt, + updatedAt: message.updatedAt, + })), + reason: `grok-backfill:${sessionId}`, + }; + const versionRow = sqliteJson( + dbPath, + `SELECT COALESCE(MAX(stream_version), -1) AS max_version FROM orchestration_events + WHERE aggregate_kind = 'thread' AND stream_id = ${sql(threadId)}`, + )[0]; + const nextVersion = Number(versionRow?.max_version ?? -1) + 1; + const occurredAt = plan.tail[plan.tail.length - 1]?.updatedAt ?? new Date().toISOString(); + // Keyed by the resulting tail, so re-running an identical backfill cannot + // append a second event. + const eventId = stableUuid( + "t3-grok-backfill-event", + `${threadId}:${plan.anchorMessageId ?? "*"}:${plan.tail.map((m) => m.messageId).join(",")}`, + ); + sqliteExec( + dbPath, + `BEGIN; +INSERT OR IGNORE INTO orchestration_events (event_id,aggregate_kind,stream_id,stream_version,event_type,occurred_at,command_id,causation_event_id,correlation_id,actor_kind,payload_json,metadata_json) +VALUES (${sql(eventId)},'thread',${sql(threadId)},${nextVersion},'thread.messages-resynced',${sql(occurredAt)},NULL,NULL,NULL,'system',${sql(JSON.stringify(payload))},'{}'); +COMMIT;`, + ); +} + +export function runGrokBackfill(options: RunGrokBackfillOptions): GrokBackfillResult { + const baseDir = homePath(options.baseDir ?? process.env.T3CODE_HOME ?? "~/.t3"); + const dbPath = options.dbPath ?? NodePath.join(baseDir, "userdata", "state.sqlite"); + + const meta = resolveGrokSessionMeta(dbPath, options.threadId); + const sessionId = options.sessionId ?? meta.sessionId; + const cwd = options.cwd ?? meta.cwd; + + const base = { + threadId: options.threadId, + sessionId, + historyPath: null, + addedCount: 0, + skippedExisting: 0, + anchorLineIndex: null, + newMessages: [] as ReadonlyArray, + }; + + if (!sessionId) { + return { + ...base, + status: "error", + error: `No grok session id found for thread ${options.threadId} (pass --session-id).`, + }; + } + const historyPath = + options.historyPath ?? (cwd ? resolveGrokChatHistoryPath({ cwd, sessionId }) : null); + if (!historyPath) { + return { + ...base, + sessionId, + status: "error", + error: `No grok cwd found for thread ${options.threadId} (pass --history or --cwd).`, + }; + } + if (!NodeFS.existsSync(historyPath)) { + return { + ...base, + sessionId, + historyPath, + status: "error", + error: `Grok history file not found: ${historyPath}`, + }; + } + + const grokMessages = readGrokDisplayMessages(historyPath); + const existingMessages = readExistingThreadMessages(dbPath, options.threadId); + const plan = planGrokBackfill({ + grokMessages, + existingMessages, + sessionId, + ...(options.rebuildAll === true ? { rebuildAll: true } : {}), + }); + + if (plan.error) { + return { + ...base, + sessionId, + historyPath, + status: "error", + skippedExisting: plan.skippedExisting, + anchorLineIndex: plan.anchorLineIndex, + error: plan.error, + }; + } + + const resultBase = { + threadId: options.threadId, + sessionId, + historyPath, + addedCount: plan.newMessages.length, + skippedExisting: plan.skippedExisting, + anchorLineIndex: plan.anchorLineIndex, + newMessages: plan.newMessages, + }; + + if (options.dryRun) { + return { ...resultBase, status: "dry-run" }; + } + if (plan.newMessages.length === 0 && options.force !== true && options.rebuildAll !== true) { + return { ...resultBase, status: "up-to-date" }; + } + appendResyncEvent(dbPath, options.threadId, sessionId, plan); + return { ...resultBase, status: "backfilled" }; +} + +export function formatGrokBackfillResult( + result: GrokBackfillResult, + options: { readonly json: boolean }, +): string { + if (options.json) { + return JSON.stringify(result, null, 2); + } + if (result.status === "error") { + return `error\t${result.threadId}\t${result.error ?? "unknown error"}`; + } + const header = + `${result.status}\tthread=${result.threadId}\tsession=${result.sessionId ?? "?"}\t` + + `added=${result.addedCount}\tskipped=${result.skippedExisting}\tanchor-line=${result.anchorLineIndex ?? "?"}`; + const detail = result.newMessages + .map( + (message) => + ` + [${message.role}] @${message.sourceOffset} ${message.createdAt} ` + + JSON.stringify(normalize(message.text).slice(0, 80)), + ) + .join("\n"); + return detail.length > 0 ? `${header}\n${detail}` : header; +} diff --git a/apps/server/src/externalSessions/sqlite.ts b/apps/server/src/externalSessions/sqlite.ts new file mode 100644 index 000000000000..4a9e58b5377c --- /dev/null +++ b/apps/server/src/externalSessions/sqlite.ts @@ -0,0 +1,52 @@ +// @effect-diagnostics nodeBuiltinImport:off globalDate:off preferSchemaOverJson:off +// Shared sqlite / id helpers for external-session recovery and backfill tooling. +// These deliberately shell out to the `sqlite3` CLI so the tooling can run as a +// plain script against an on-disk state DB without pulling in a native driver. +import * as NodeChildProcess from "node:child_process"; +import * as NodeCrypto from "node:crypto"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +const SQLITE_MAX_BUFFER = 256 * 1024 * 1024; + +export function homePath(value: string): string { + return value === "~" || value.startsWith("~/") + ? NodePath.join(NodeOS.homedir(), value.slice(value === "~" ? 1 : 2)) + : value; +} + +/** Deterministic RFC-4122-shaped UUID from a namespace + key (stable across runs). */ +export function stableUuid(kind: string, key: string): string { + const bytes = NodeCrypto.createHash("sha256").update(`${kind}:${key}`).digest().subarray(0, 16); + bytes[6] = (bytes[6]! & 0x0f) | 0x50; + bytes[8] = (bytes[8]! & 0x3f) | 0x80; + const hex = bytes.toString("hex"); + return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`; +} + +/** Quote a value as a SQL string literal (or NULL), escaping single quotes. */ +export function sql(value: unknown): string { + if (value === null || value === undefined) { + return "NULL"; + } + return `'${String(value).replaceAll("'", "''")}'`; +} + +export function sqliteJson(dbPath: string, query: string): Array> { + if (!NodeFS.existsSync(dbPath)) { + return []; + } + const out = NodeChildProcess.execFileSync("sqlite3", ["-json", dbPath, query], { + encoding: "utf8", + maxBuffer: SQLITE_MAX_BUFFER, + }).trim(); + return out.length === 0 ? [] : (JSON.parse(out) as Array>); +} + +export function sqliteExec(dbPath: string, script: string): void { + NodeChildProcess.execFileSync("sqlite3", [dbPath], { + input: script, + maxBuffer: SQLITE_MAX_BUFFER, + }); +} diff --git a/apps/server/src/git/GitManager.test.ts b/apps/server/src/git/GitManager.test.ts index 999a0c202216..3e6e3e945a7b 100644 --- a/apps/server/src/git/GitManager.test.ts +++ b/apps/server/src/git/GitManager.test.ts @@ -44,6 +44,7 @@ import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.t import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as GitManager from "./GitManager.ts"; +import * as PrLookupFreeze from "./PrLookupFreeze.ts"; const encodeCliJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown)); @@ -60,6 +61,7 @@ interface FakeGhScenario { baseRefName: string; headRefName: string; state?: "open" | "closed" | "merged"; + hasFailingChecks?: boolean; isDraft?: boolean; isCrossRepository?: boolean; headRepositoryNameWithOwner?: string | null; @@ -234,6 +236,7 @@ function initRepo( yield* runGit(cwd, ["init", "--initial-branch=main"]); yield* runGit(cwd, ["config", "user.email", "test@example.com"]); yield* runGit(cwd, ["config", "user.name", "Test User"]); + yield* runGit(cwd, ["config", "commit.gpgSign", "false"]); yield* fs.writeFileString(NodePath.join(cwd, "README.md"), "hello\n"); yield* runGit(cwd, ["add", "README.md"]); yield* runGit(cwd, ["commit", "-m", "Initial commit"]); @@ -566,6 +569,8 @@ function createGitHubCliWithFakeGh(scenario: FakeGhScenario = {}): { }).pipe( Effect.map((result) => JSON.parse(result.stdout) as GitHubCli.GitHubPullRequestSummary), ), + getPullRequestHasFailingChecks: () => + Effect.succeed(scenario.pullRequest?.hasFailingChecks === true), getRepositoryCloneUrls: (input) => execute({ cwd: input.cwd, @@ -597,6 +602,7 @@ function runStackedAction( actionId?: string; commitMessage?: string; featureBranch?: boolean; + disableCommitSigning?: boolean; filePaths?: readonly string[]; }, options?: Parameters[1], @@ -610,6 +616,21 @@ function runStackedAction( ); } +const configureFailingCommitSigner = Effect.fn("configureFailingCommitSigner")(function* ( + repoDir: string, +) { + const signerPath = NodePath.join(repoDir, "failing-signer.sh"); + NodeFS.writeFileSync( + signerPath, + "#!/bin/sh\necho 'gpg: signing failed: No secret key' >&2\nexit 1\n", + { mode: 0o755 }, + ); + yield* runGit(repoDir, ["config", "commit.gpgSign", "true"]); + // Host global config may set gpg.format=ssh, which ignores gpg.program. + yield* runGit(repoDir, ["config", "gpg.format", "openpgp"]); + yield* runGit(repoDir, ["config", "gpg.program", signerPath]); +}); + function resolvePullRequest( manager: GitManager.GitManager["Service"], input: { cwd: string; reference: string }, @@ -695,12 +716,14 @@ function makeManager(input?: { ), vcsDriverLayer, serverSettingsLayer, + PrLookupFreeze.layer, ).pipe(Layer.provideMerge(sourceControlRegistryLayer), Layer.provideMerge(NodeServices.layer)); - return GitManager.make.pipe( - Effect.provide(managerLayer), - Effect.map((manager) => ({ manager, ghCalls })), - ); + return Effect.gen(function* () { + const manager = yield* GitManager.make; + const prLookupFreeze = yield* PrLookupFreeze.PrLookupFreeze; + return { manager, ghCalls, prLookupFreeze }; + }).pipe(Effect.provide(managerLayer)); } const asThreadId = (threadId: string) => threadId as ThreadId; @@ -712,6 +735,29 @@ const GitManagerTestLayer = GitVcsDriver.layer.pipe( ); it.layer(GitManagerTestLayer)("GitManager", (it) => { + it.effect("status includes the GitHub repository URL for repository actions", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, [ + "remote", + "add", + "origin", + "git@github.com:pingdotgg/codething-mvp.git", + ]); + + const { manager } = yield* makeManager(); + const status = yield* manager.status({ cwd: repoDir }); + + expect(status.sourceControlProvider).toEqual({ + kind: "github", + name: "GitHub", + baseUrl: "https://github.com", + repositoryUrl: "https://github.com/pingdotgg/codething-mvp", + }); + }), + ); + it.effect("status includes draft PR metadata when branch already has a draft PR", () => Effect.gen(function* () { const repoDir = yield* makeTempDir("t3code-git-manager-"); @@ -2150,6 +2196,101 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { }), ); + it.effect("status does not re-list PRs after observing a merged PR (terminal freeze)", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, ["checkout", "-b", "feature/terminal-freeze"]); + + const mergedPr = { + number: 44, + title: "Done", + url: "https://github.com/pingdotgg/codething-mvp/pull/44", + baseRefName: "main", + headRefName: "feature/terminal-freeze", + state: "MERGED", + mergedAt: "2026-01-30T10:00:00Z", + updatedAt: "2026-01-30T10:00:00Z", + }; + const { manager, ghCalls } = yield* makeManager({ + ghScenario: { + // Two list answers: first observation freezes; invalidateStatus re-lists. + // @effect-diagnostics-next-line preferSchemaOverJson:off + prListSequence: [JSON.stringify([mergedPr]), JSON.stringify([mergedPr])], + }, + }); + + const first = yield* manager.remoteStatus({ cwd: repoDir }); + expect(first?.pr?.state).toBe("merged"); + const listCallsAfterFirst = ghCalls.filter((call) => call.startsWith("pr list ")).length; + expect(listCallsAfterFirst).toBe(1); + + // Bypass remote status result cache (same as list-mode poll) without + // bumping the PR lookup epoch (that is only for explicit invalidateStatus). + const second = yield* manager.remoteStatus({ cwd: repoDir }, { refreshUpstream: false }); + expect(second?.pr?.number).toBe(44); + expect(second?.pr?.state).toBe("merged"); + expect(ghCalls.filter((call) => call.startsWith("pr list ")).length).toBe( + listCallsAfterFirst, + ); + + // Explicit refresh re-opens the freeze (epoch bump). + yield* manager.invalidateStatus(repoDir); + const third = yield* manager.remoteStatus({ cwd: repoDir }, { refreshUpstream: false }); + expect(third?.pr?.number).toBe(44); + expect(ghCalls.filter((call) => call.startsWith("pr list ")).length).toBeGreaterThan( + listCallsAfterFirst, + ); + }), + ); + + it.effect( + "status skips PR list while the worktree is settle-frozen and resumes on unsettle", + () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, ["checkout", "-b", "feature/settle-freeze"]); + + const openPr = { + number: 55, + title: "In review", + url: "https://github.com/pingdotgg/codething-mvp/pull/55", + baseRefName: "main", + headRefName: "feature/settle-freeze", + state: "OPEN", + updatedAt: "2026-01-30T10:00:00Z", + }; + const { manager, ghCalls, prLookupFreeze } = yield* makeManager({ + ghScenario: { + // @effect-diagnostics-next-line preferSchemaOverJson:off + prListSequence: [JSON.stringify([openPr]), JSON.stringify([openPr])], + }, + }); + + const first = yield* manager.remoteStatus({ cwd: repoDir }, { refreshUpstream: false }); + expect(first?.pr?.number).toBe(55); + const listCallsAfterFirst = ghCalls.filter((call) => call.startsWith("pr list ")).length; + expect(listCallsAfterFirst).toBe(1); + + yield* prLookupFreeze.noteWorktreeSettled(repoDir); + yield* manager.invalidateRemoteStatus(repoDir); + const settled = yield* manager.remoteStatus({ cwd: repoDir }, { refreshUpstream: false }); + expect(settled?.pr?.number).toBe(55); + expect(ghCalls.filter((call) => call.startsWith("pr list ")).length).toBe( + listCallsAfterFirst, + ); + + yield* prLookupFreeze.noteWorktreeUnsettled(repoDir); + yield* manager.invalidateStatus(repoDir); + const resumed = yield* manager.remoteStatus({ cwd: repoDir }, { refreshUpstream: false }); + expect(resumed?.pr?.number).toBe(55); + expect(ghCalls.filter((call) => call.startsWith("pr list ")).length).toBeGreaterThan( + listCallsAfterFirst, + ); + }), + ); + it.effect("status hides merged PRs on the default branch", () => Effect.gen(function* () { const repoDir = yield* makeTempDir("t3code-git-manager-"); @@ -2181,6 +2322,140 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { }), ); + it.effect("resolveBranchChangeRequest returns PR for a branch that is not checked out", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, ["checkout", "-b", "feature/sidebar-pr"]); + yield* runGit(repoDir, ["checkout", "main"]); + + const { manager } = yield* makeManager({ + ghScenario: { + prListSequence: [ + // @effect-diagnostics-next-line preferSchemaOverJson:off + JSON.stringify([ + { + number: 31, + title: "Sidebar PR lookup", + url: "https://github.com/pingdotgg/codething-mvp/pull/31", + baseRefName: "main", + headRefName: "feature/sidebar-pr", + state: "OPEN", + updatedAt: "2026-01-30T10:00:00Z", + }, + ]), + ], + }, + }); + + const resolved = yield* manager.resolveBranchChangeRequest({ + cwd: repoDir, + refName: "feature/sidebar-pr", + }); + expect(resolved.pr).toEqual({ + number: 31, + title: "Sidebar PR lookup", + url: "https://github.com/pingdotgg/codething-mvp/pull/31", + baseRef: "main", + headRef: "feature/sidebar-pr", + state: "open", + updatedAt: "2026-01-30T10:00:00.000Z", + }); + }), + ); + + it.effect("resolveBranchChangeRequest surfaces failing GitHub checks for open PRs", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, ["checkout", "-b", "feature/failing-checks"]); + yield* runGit(repoDir, ["checkout", "main"]); + + const { manager } = yield* makeManager({ + ghScenario: { + prListSequence: [ + '[{"number":41,"title":"Failing checks PR","url":"https://github.com/pingdotgg/codething-mvp/pull/41","baseRefName":"main","headRefName":"feature/failing-checks","state":"OPEN","updatedAt":"2026-01-30T10:00:00Z"}]', + ], + pullRequest: { + number: 41, + title: "Failing checks PR", + url: "https://github.com/pingdotgg/codething-mvp/pull/41", + baseRefName: "main", + headRefName: "feature/failing-checks", + state: "open", + hasFailingChecks: true, + }, + }, + }); + + const resolved = yield* manager.resolveBranchChangeRequest({ + cwd: repoDir, + refName: "feature/failing-checks", + }); + expect(resolved.pr).toEqual({ + number: 41, + title: "Failing checks PR", + url: "https://github.com/pingdotgg/codething-mvp/pull/41", + baseRef: "main", + headRef: "feature/failing-checks", + state: "open", + updatedAt: "2026-01-30T10:00:00.000Z", + hasFailingChecks: true, + }); + }), + ); + + it.effect( + "resolveBranchChangeRequest falls back to a direct GitHub head lookup when the primary lookup returns null", + () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, [ + "config", + "remote.origin.url", + "https://github.com/pingdotgg/codething-mvp.git", + ]); + yield* runGit(repoDir, ["checkout", "-b", "feature/direct-fallback"]); + yield* runGit(repoDir, ["checkout", "main"]); + + const { manager } = yield* makeManager({ + ghScenario: { + prListSequence: [ + "[]", + // @effect-diagnostics-next-line preferSchemaOverJson:off + JSON.stringify([ + { + number: 44, + title: "Fallback PR lookup", + url: "https://github.com/pingdotgg/codething-mvp/pull/44", + baseRefName: "main", + headRefName: "feature/direct-fallback", + state: "MERGED", + mergedAt: "2026-01-30T10:00:00Z", + updatedAt: "2026-01-30T10:00:00Z", + }, + ]), + ], + }, + }); + + const resolved = yield* manager.resolveBranchChangeRequest({ + cwd: repoDir, + refName: "feature/direct-fallback", + }); + expect(resolved.pr).toEqual({ + number: 44, + title: "Fallback PR lookup", + url: "https://github.com/pingdotgg/codething-mvp/pull/44", + baseRef: "main", + headRef: "feature/direct-fallback", + state: "merged", + updatedAt: "2026-01-30T10:00:00.000Z", + }); + }), + ); + it.effect("status does not inherit a merged PR from a feature branch's default upstream", () => Effect.gen(function* () { const repoDir = yield* makeTempDir("t3code-git-manager-"); @@ -5708,6 +5983,64 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { }), ); + it.effect("does not attribute ambiguous output to the wrong commit hook", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + NodeFS.writeFileSync(NodePath.join(repoDir, "multi-hook.txt"), "multi hook\n"); + NodeFS.writeFileSync( + NodePath.join(repoDir, ".git", "hooks", "pre-commit"), + // Brief sleep gives TRACE2 time to mark the hook active before stderr lands. + '#!/bin/sh\nsleep 0.05\necho "output from pre-commit" >&2\nsleep 0.05\n', + { mode: 0o755 }, + ); + NodeFS.writeFileSync( + NodePath.join(repoDir, ".git", "hooks", "commit-msg"), + '#!/bin/sh\nsleep 0.05\necho "output from commit-msg" >&2\nsleep 0.05\n', + { mode: 0o755 }, + ); + + const { manager } = yield* makeManager(); + const events: GitActionProgressEvent[] = []; + + const result = yield* runStackedAction( + manager, + { + cwd: repoDir, + action: "commit", + commitMessage: "test: preserve hook output attribution", + }, + { + actionId: "action-multi-hook", + progressReporter: { + publish: (event) => + Effect.sync(() => { + events.push(event); + }), + }, + }, + ); + + expect(result.commit.status).toBe("created"); + const hookOutput = events.filter((event) => event.kind === "hook_output"); + const preCommitOutput = hookOutput.find((event) => + event.text.includes("output from pre-commit"), + ); + const commitMsgOutput = hookOutput.find((event) => + event.text.includes("output from commit-msg"), + ); + const gitOutput = hookOutput.find((event) => + event.text.includes("test: preserve hook output attribution"), + ); + + expect(preCommitOutput).toBeDefined(); + expect(preCommitOutput).toMatchObject({ hookName: null }); + expect(commitMsgOutput).toBeDefined(); + expect(commitMsgOutput).toMatchObject({ hookName: null }); + expect(gitOutput).toMatchObject({ hookName: null }); + }), + ); + it.effect("emits action_failed when a commit hook rejects", () => Effect.gen(function* () { const repoDir = yield* makeTempDir("t3code-git-manager-"); @@ -5757,12 +6090,155 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { expect.objectContaining({ kind: "action_failed", phase: "commit", + failureKind: "unknown", }), ]), ); }), ); + it.effect( + "classifies signing failures and retries a created feature branch without branching again", + () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + NodeFS.writeFileSync(NodePath.join(repoDir, "signing.txt"), "signing retry\n"); + yield* configureFailingCommitSigner(repoDir); + + const { manager } = yield* makeManager(); + const events: GitActionProgressEvent[] = []; + yield* runStackedAction( + manager, + { + cwd: repoDir, + action: "commit", + commitMessage: "feat: signing retry", + featureBranch: true, + }, + { + progressReporter: { + publish: (event) => + Effect.sync(() => { + events.push(event); + }), + }, + }, + ).pipe(Effect.flip); + + expect(events).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + kind: "action_failed", + phase: "commit", + failureKind: "commit_signing_failed", + }), + ]), + ); + expect( + events.some( + (event) => event.kind === "hook_output" && event.text.includes("No secret key"), + ), + ).toBe(false); + const branchAfterFailure = yield* runGit(repoDir, ["branch", "--show-current"]).pipe( + Effect.map((result) => result.stdout.trim()), + ); + const branchCountAfterFailure = yield* runGit(repoDir, [ + "branch", + "--format=%(refname)", + ]).pipe(Effect.map((result) => result.stdout.trim().split("\n").length)); + + const retried = yield* runStackedAction(manager, { + cwd: repoDir, + action: "commit", + commitMessage: "feat: signing retry", + disableCommitSigning: true, + }); + const branchCountAfterRetry = yield* runGit(repoDir, [ + "branch", + "--format=%(refname)", + ]).pipe(Effect.map((result) => result.stdout.trim().split("\n").length)); + + expect(retried.commit.status).toBe("created"); + expect(retried.branch.status).toBe("skipped_not_requested"); + expect(branchAfterFailure).toBe("feature/feat-signing-retry"); + expect(branchCountAfterRetry).toBe(branchCountAfterFailure); + }), + ); + + for (const action of ["commit", "commit_push", "commit_push_pr"] as const) { + it.effect(`forwards the unsigned override for ${action}`, () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + if (action !== "commit") { + const remoteDir = yield* createBareRemote(); + yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]); + yield* runGit(repoDir, ["push", "-u", "origin", "main"]); + yield* runGit(repoDir, ["checkout", "-b", `feature/unsigned-${action}`]); + } + NodeFS.writeFileSync(NodePath.join(repoDir, `${action}.txt`), `${action}\n`); + yield* configureFailingCommitSigner(repoDir); + + const { manager } = yield* makeManager(); + const result = yield* runStackedAction(manager, { + cwd: repoDir, + action, + commitMessage: `test: ${action} unsigned`, + disableCommitSigning: true, + }); + + expect(result.commit.status).toBe("created"); + if (action !== "commit") { + expect(result.push.status).toBe("pushed"); + } + if (action === "commit_push_pr") { + expect(result.pr.status).toBe("created"); + } + }), + ); + } + + it.effect("does not advertise another retry when an unsigned attempt fails", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + NodeFS.writeFileSync(NodePath.join(repoDir, "unsigned-hook.txt"), "hook failure\n"); + NodeFS.writeFileSync( + NodePath.join(repoDir, ".git", "hooks", "pre-commit"), + "#!/bin/sh\necho 'error: gpg failed to sign the data' >&2\nexit 1\n", + { mode: 0o755 }, + ); + + const { manager } = yield* makeManager(); + const events: GitActionProgressEvent[] = []; + yield* runStackedAction( + manager, + { + cwd: repoDir, + action: "commit", + commitMessage: "test: unsigned hook failure", + disableCommitSigning: true, + }, + { + progressReporter: { + publish: (event) => + Effect.sync(() => { + events.push(event); + }), + }, + }, + ).pipe(Effect.flip); + + const failure = events.find((event) => event.kind === "action_failed"); + expect(failure).toMatchObject({ + kind: "action_failed", + phase: "commit", + failureKind: "unknown", + }); + }), + ); + it.effect("create_pr emits only the PR phase when the branch is already pushed", () => Effect.gen(function* () { const repoDir = yield* makeTempDir("t3code-git-manager-"); diff --git a/apps/server/src/git/GitManager.ts b/apps/server/src/git/GitManager.ts index f60eb2781872..3c797f5ce8d0 100644 --- a/apps/server/src/git/GitManager.ts +++ b/apps/server/src/git/GitManager.ts @@ -28,6 +28,8 @@ import { type VcsStatusLocalResult, type VcsStatusRemoteResult, VcsStatusResult, + VcsResolveBranchChangeRequestInput, + VcsResolveBranchChangeRequestResult, ModelSelection, SourceControlProviderError, type SourceControlWritingStyleSettings, @@ -62,6 +64,7 @@ import * as GitVcsDriver from "../vcs/GitVcsDriver.ts"; import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts"; import { detectPrTemplate } from "../sourceControl/PrTemplateDetection.ts"; import type { ChangeRequest } from "@t3tools/contracts"; +import { PrLookupFreeze } from "./PrLookupFreeze.ts"; export interface GitActionProgressReporter { readonly publish: (event: GitActionProgressEvent) => Effect.Effect; @@ -113,6 +116,9 @@ export class GitManager extends Context.Service< readonly resolvePullRequest: ( input: GitPullRequestRefInput, ) => Effect.Effect; + readonly resolveBranchChangeRequest: ( + input: VcsResolveBranchChangeRequestInput, + ) => Effect.Effect; readonly preparePullRequestThread: ( input: GitPreparePullRequestThreadInput, ) => Effect.Effect; @@ -127,7 +133,17 @@ const COMMIT_TIMEOUT_MS = 10 * 60_000; const MAX_PROGRESS_TEXT_LENGTH = 500; const SHORT_SHA_LENGTH = 7; const TOAST_DESCRIPTION_MAX = 72; -const STATUS_RESULT_CACHE_TTL = Duration.seconds(1); +/** + * Local status is multi-process but still cheaper than remote. Coalesce reconnect + * storms and near-simultaneous sidebar subscribers for the same worktree. + */ +const STATUS_RESULT_CACHE_TTL = Duration.seconds(5); +/** + * Remote status (PR list/view/checks via `gh`) is expensive. Keep TTL **≥** the + * default 30s poll/list cadence so concurrent subscribers still coalesce, but short + * enough that PR number/state badges update within about one refresh cycle. + */ +const REMOTE_STATUS_RESULT_CACHE_TTL = Duration.seconds(35); const STATUS_RESULT_CACHE_CAPACITY = 2_048; // Matches the automatic settlement sweep cadence so every background sweep // reads fresh branch state: an external merge settles within about a minute @@ -156,6 +172,13 @@ export function prLookupFailureTtl(consecutiveFailures: number): Duration.Durati const backoffMs = Duration.toMillis(PR_LOOKUP_FAILURE_BASE_TTL) * Math.pow(2, exponent); return Duration.min(Duration.millis(backoffMs), PR_LOOKUP_FAILURE_MAX_TTL); } + +/** Merged/closed last-known badges do not re-hit the hosting provider until invalidateStatus. */ +export function isTerminalStatusPrState( + state: "open" | "closed" | "merged" | null | undefined, +): boolean { + return state === "merged" || state === "closed"; +} type StripProgressContext = T extends any ? Omit : never; type GitActionProgressPayload = StripProgressContext; type GitActionProgressEmitter = (event: GitActionProgressPayload) => Effect.Effect; @@ -178,6 +201,7 @@ interface PullRequestInfo extends OpenPrInfo, PullRequestHeadRemoteInfo { closedAt?: string | null; mergedAt?: string | null; updatedAt: Option.Option; + hasFailingChecks?: boolean; } const pullRequestUpdatedAtDescOrder: Order.Order = Order.mapInput( @@ -192,6 +216,7 @@ interface ResolvedPullRequest { baseBranch: string; headBranch: string; state: "open" | "closed" | "merged"; + hasFailingChecks?: boolean; } interface PullRequestHeadRemoteInfo { @@ -442,6 +467,9 @@ function toPullRequestInfo(summary: ChangeRequest): PullRequestInfo { ...(summary.headRepositoryOwnerLogin !== undefined ? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin } : {}), + ...(summary.hasFailingChecks !== undefined + ? { hasFailingChecks: summary.hasFailingChecks } + : {}), }; } @@ -586,6 +614,7 @@ function toStatusPr(pr: PullRequestInfo): { baseRef: string; headRef: string; state: "open" | "closed" | "merged"; + hasFailingChecks?: boolean; isDraft?: boolean; updatedAt: string | null; } { @@ -596,6 +625,7 @@ function toStatusPr(pr: PullRequestInfo): { baseRef: pr.baseRefName, headRef: pr.headRefName, state: pr.state, + ...(pr.hasFailingChecks !== undefined ? { hasFailingChecks: pr.hasFailingChecks } : {}), ...(pr.isDraft === true ? { isDraft: true } : {}), updatedAt: Option.match(pr.updatedAt, { onNone: () => null, @@ -617,6 +647,7 @@ function toResolvedPullRequest(pr: { baseRefName: string; headRefName: string; state?: "open" | "closed" | "merged"; + hasFailingChecks?: boolean | undefined; }): ResolvedPullRequest { return { number: pr.number, @@ -625,6 +656,7 @@ function toResolvedPullRequest(pr: { baseBranch: pr.baseRefName, headBranch: pr.headRefName, state: pr.state ?? "open", + ...(pr.hasFailingChecks !== undefined ? { hasFailingChecks: pr.hasFailingChecks } : {}), }; } @@ -1076,12 +1108,14 @@ export const make = Effect.gen(function* () { // already-known PR badge, so the last successful answer per branch sticks // around as the fallback. Keep the resolved head context with it so a // branch retargeted to another remote/fork cannot inherit the old badge. + // `epoch` ties the entry to invalidateStatus so terminal freeze can re-open. interface LastKnownPr { readonly pr: ReturnType | null; readonly upstreamRef: string | null; readonly headBranch: string; readonly remoteName: string | null; readonly headRemoteUrlKey: string | null; + readonly epoch: number; } const lastKnownPrByBranchKey = new Map(); const rememberLastKnownPr = (branchKey: string, entry: LastKnownPr) => { @@ -1130,6 +1164,7 @@ export const make = Effect.gen(function* () { } return lastKnown.pr; }; + const prLookupFreeze = yield* PrLookupFreeze; const lookupStatusPr = Effect.fn("lookupStatusPr")(function* ( cwd: string, details: { @@ -1143,6 +1178,43 @@ export const make = Effect.gen(function* () { // Keyed by (cwd, branch) only: the upstream ref changing (e.g. a first // `push -u`) must not orphan the fallback value for the same branch. const branchKey = `${cwd}\u0000${details.branch}`; + const epoch = prLookupEpoch(cwd); + + // Durable settle freeze: skip hosting-provider calls while every thread on + // this worktree is settled. Resume when the last settled interest drops + // (unsettle / activity) — next poll hits the live path again. + if (yield* prLookupFreeze.isWorktreeSettledFrozen(cwd)) { + const headContext = yield* resolveBranchHeadContext(cwd, details); + return resolveLastKnownPr(branchKey, { + upstreamRef: details.upstreamRef, + headBranch: headContext.headBranch, + remoteName: headContext.remoteName, + headRemoteUrlKey: headContext.headRemoteUrlKey, + }); + } + + // Terminal freeze: once we have observed merged/closed for this head under + // the current invalidate epoch, do not re-list PRs on every poll (Discord + // bridges + sidebar list mode otherwise re-hit gh forever). + const prior = lastKnownPrByBranchKey.get(branchKey); + if ( + prior !== undefined && + prior.epoch === epoch && + prior.pr !== null && + isTerminalStatusPrState(prior.pr.state) + ) { + const headContext = yield* resolveBranchHeadContext(cwd, details); + const frozen = resolveLastKnownPr(branchKey, { + upstreamRef: details.upstreamRef, + headBranch: headContext.headBranch, + remoteName: headContext.remoteName, + headRemoteUrlKey: headContext.headRemoteUrlKey, + }); + if (frozen !== null && isTerminalStatusPrState(frozen.state)) { + return frozen; + } + } + const cacheKey = prLookupCacheKey(cwd, details); if (refreshMissingPullRequest) { const cached = yield* Cache.getOption(prLookupCache, cacheKey).pipe( @@ -1170,6 +1242,7 @@ export const make = Effect.gen(function* () { headBranch: headContext.headBranch, remoteName: headContext.remoteName, headRemoteUrlKey: headContext.headRemoteUrlKey, + epoch, }), ), ), @@ -1240,7 +1313,7 @@ export const make = Effect.gen(function* () { }); const remoteStatusResultCache = yield* Cache.makeWith((cwd: string) => readRemoteStatus(cwd), { capacity: STATUS_RESULT_CACHE_CAPACITY, - timeToLive: (exit) => (Exit.isSuccess(exit) ? STATUS_RESULT_CACHE_TTL : Duration.zero), + timeToLive: (exit) => (Exit.isSuccess(exit) ? REMOTE_STATUS_RESULT_CACHE_TTL : Duration.zero), }); const invalidateRemoteStatusResultCache = (cwd: string) => normalizeStatusCacheKey(cwd).pipe( @@ -1262,7 +1335,19 @@ export const make = Effect.gen(function* () { (yield* readConfigValueNullable(cwd, `remote.${preferredRemoteName}.url`)) ?? (yield* readConfigValueNullable(cwd, "remote.origin.url")); - return remoteUrl ? detectSourceControlProviderFromGitRemoteUrl(remoteUrl) : null; + if (!remoteUrl) { + return null; + } + + const provider = detectSourceControlProviderFromGitRemoteUrl(remoteUrl); + if (!provider) { + return null; + } + + const repositoryNameWithOwner = parseRepositoryNameWithOwnerFromRemoteUrl(remoteUrl); + return repositoryNameWithOwner + ? { ...provider, repositoryUrl: `${provider.baseUrl}/${repositoryNameWithOwner}` } + : provider; }); const resolveRemoteRepositoryContext = Effect.fn("resolveRemoteRepositoryContext")(function* ( @@ -1588,6 +1673,54 @@ export const make = Effect.gen(function* () { } return parsed[0] ?? null; }); + const findLatestPrByHeadSelectorDirect = Effect.fn("findLatestPrByHeadSelectorDirect")(function* ( + cwd: string, + branch: string, + ) { + const pullRequests = yield* (yield* sourceControlProvider(cwd)).listChangeRequests({ + cwd, + headSelector: branch, + state: "all", + limit: 20, + }); + + const parsed = Arr.sort( + pullRequests + .map(toPullRequestInfo) + .filter((pullRequest) => pullRequest.headRefName === branch), + pullRequestUpdatedAtDescOrder, + ); + const latestOpenPr = parsed.find((pr) => pr.state === "open"); + if (latestOpenPr) { + return latestOpenPr; + } + return parsed[0] ?? null; + }); + + const hydrateOpenPrChecks = Effect.fn("hydrateOpenPrChecks")(function* ( + cwd: string, + pullRequest: PullRequestInfo | null, + ) { + if (pullRequest === null || pullRequest.state !== "open") { + return pullRequest; + } + + return yield* (yield* sourceControlProvider(cwd)) + .getChangeRequest({ + cwd, + reference: String(pullRequest.number), + }) + .pipe( + Effect.map((changeRequest) => ({ + ...pullRequest, + ...(changeRequest.hasFailingChecks !== undefined + ? { hasFailingChecks: changeRequest.hasFailingChecks } + : {}), + })), + Effect.orElseSucceed(() => pullRequest), + ); + }); + const buildCompletionToast = Effect.fn("buildCompletionToast")(function* ( cwd: string, result: Pick, @@ -1802,6 +1935,7 @@ export const make = Effect.gen(function* () { commitMessage?: string, preResolvedSuggestion?: CommitAndBranchSuggestion, filePaths?: readonly string[], + disableSigning?: boolean, progressReporter?: GitActionProgressReporter, actionId?: string, ) { @@ -1844,28 +1978,52 @@ export const make = Effect.gen(function* () { }); let currentHookName: string | null = null; + let sawCommitHook = false; + let pendingUnattributedOutput: Array<{ stream: "stdout" | "stderr"; text: string }> = []; + const emitHookOutput = ( + hookName: string | null, + { stream, text }: { stream: "stdout" | "stderr"; text: string }, + ) => { + const sanitized = sanitizeProgressText(text); + if (!sanitized) { + return Effect.void; + } + return emit({ + kind: "hook_output", + hookName, + stream, + text: sanitized, + }); + }; + const finalizeUnattributedOutput = (shouldEmit: boolean) => + Effect.suspend(() => { + const pending = pendingUnattributedOutput; + pendingUnattributedOutput = []; + return shouldEmit + ? Effect.forEach(pending, (output) => emitHookOutput(null, output), { discard: true }) + : Effect.void; + }); const commitProgress = progressReporter && actionId ? { - onOutputLine: ({ stream, text }: { stream: "stdout" | "stderr"; text: string }) => { - const sanitized = sanitizeProgressText(text); - if (!sanitized) { + onOutputLine: (output: { stream: "stdout" | "stderr"; text: string }) => + Effect.suspend(() => { + // Trace2 hook lifecycle events and child-process output arrive over + // independent streams, so their relative delivery order cannot + // safely identify which hook produced a line. Buffer output and + // emit it without attribution once Git confirms that hooks ran. + pendingUnattributedOutput.push(output); return Effect.void; - } - return emit({ - kind: "hook_output", - hookName: currentHookName, - stream, - text: sanitized, - }); - }, - onHookStarted: (hookName: string) => { - currentHookName = hookName; - return emit({ - kind: "hook_started", - hookName, - }); - }, + }), + onHookStarted: (hookName: string) => + Effect.suspend(() => { + sawCommitHook = true; + currentHookName = hookName; + return emit({ + kind: "hook_started", + hookName, + }); + }), onHookFinished: ({ hookName, exitCode, @@ -1887,10 +2045,19 @@ export const make = Effect.gen(function* () { }, } : null; - const { commitSha } = yield* gitCore.commit(cwd, suggestion.subject, suggestion.body, { - timeoutMs: COMMIT_TIMEOUT_MS, - ...(commitProgress ? { progress: commitProgress } : {}), - }); + const { commitSha } = yield* gitCore + .commit(cwd, suggestion.subject, suggestion.body, { + timeoutMs: COMMIT_TIMEOUT_MS, + ...(disableSigning ? { disableSigning: true } : {}), + ...(commitProgress ? { progress: commitProgress } : {}), + }) + .pipe( + Effect.tapError((error) => + finalizeUnattributedOutput( + sawCommitHook && error.failureKind !== "commit_signing_failed", + ), + ), + ); if (currentHookName !== null) { yield* emit({ kind: "hook_finished", @@ -1900,6 +2067,7 @@ export const make = Effect.gen(function* () { }); currentHookName = null; } + yield* finalizeUnattributedOutput(sawCommitHook); return { status: "created" as const, commitSha, @@ -2233,6 +2401,42 @@ export const make = Effect.gen(function* () { return { pullRequest }; }); + const resolveBranchChangeRequest: GitManager["Service"]["resolveBranchChangeRequest"] = Effect.fn( + "resolveBranchChangeRequest", + )(function* (input) { + const details = yield* gitCore + .statusDetailsLocal(input.cwd) + .pipe( + Effect.catchIf(isNotGitRepositoryError, () => Effect.succeed(nonRepositoryStatusDetails)), + ); + if (!details.isRepo) { + return { pr: null }; + } + + const upstreamRef = yield* readConfigValueNullable(input.cwd, `branch.${input.refName}.merge`); + const hostingProvider = yield* resolveHostingProvider(input.cwd, input.refName); + const latestPr = yield* resolveBranchHeadContext(input.cwd, { + branch: input.refName, + upstreamRef, + }).pipe( + Effect.flatMap((headContext) => findLatestPrForHeadContext(input.cwd, headContext)), + Effect.orElseSucceed(() => null), + ); + const fallbackPr = + latestPr === null && hostingProvider?.kind === "github" + ? yield* findLatestPrByHeadSelectorDirect(input.cwd, input.refName).pipe( + Effect.orElseSucceed(() => null), + ) + : null; + const resolvedPr = yield* hydrateOpenPrChecks(input.cwd, latestPr ?? fallbackPr); + const pr = resolvedPr ? toStatusPr(resolvedPr) : null; + + return { + pr, + ...(hostingProvider ? { sourceControlProvider: hostingProvider } : {}), + }; + }); + const preparePullRequestThread: GitManager["Service"]["preparePullRequestThread"] = Effect.fn( "preparePullRequestThread", )(function* (input) { @@ -2669,6 +2873,7 @@ export const make = Effect.gen(function* () { commitMessageForStep, preResolvedCommitSuggestion, input.filePaths, + input.disableCommitSigning, options?.progressReporter, progress.actionId, ), @@ -2735,6 +2940,10 @@ export const make = Effect.gen(function* () { kind: "action_failed", phase: Option.getOrNull(phase), message: error.message, + failureKind: + !input.disableCommitSigning && error._tag === "GitCommandError" + ? error.failureKind + : "unknown", }), ), ), @@ -2751,6 +2960,7 @@ export const make = Effect.gen(function* () { invalidateRemoteStatus, invalidateStatus, resolvePullRequest, + resolveBranchChangeRequest, preparePullRequestThread, runStackedAction, }); diff --git a/apps/server/src/git/GitWorkflowService.test.ts b/apps/server/src/git/GitWorkflowService.test.ts index 2ea14b951fe2..38cb188ecb8c 100644 --- a/apps/server/src/git/GitWorkflowService.test.ts +++ b/apps/server/src/git/GitWorkflowService.test.ts @@ -1,28 +1,67 @@ import { assert, describe, expect, it, vi } from "@effect/vitest"; +import * as DateTime from "effect/DateTime"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; import { VcsRepositoryDetectionError } from "@t3tools/contracts"; import * as GitManager from "./GitManager.ts"; import * as GitWorkflowService from "./GitWorkflowService.ts"; +import * as ProjectLifecycleScriptRunner from "../project/ProjectLifecycleScriptRunner.ts"; import * as GitVcsDriver from "../vcs/GitVcsDriver.ts"; +import * as VcsDriver from "../vcs/VcsDriver.ts"; import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts"; +const lifecycleScriptRunnerMock = Layer.mock( + ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner, +)({ + runWorktreeRemove: () => Effect.succeed({ status: "no-script" as const }), + runPrMerged: () => Effect.succeed({ status: "no-script" as const }), +}); + function makeLayer(input: { readonly detect: VcsDriverRegistry.VcsDriverRegistry["Service"]["detect"]; + readonly resolve?: VcsDriverRegistry.VcsDriverRegistry["Service"]["resolve"]; + readonly driver?: Record; }) { return GitWorkflowService.layer.pipe( Layer.provide( Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({ detect: input.detect, + ...(input.resolve ? { resolve: input.resolve } : {}), }), ), - Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})), + Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)(input.driver ?? {})), Layer.provide(Layer.mock(GitManager.GitManager)({})), + Layer.provide(lifecycleScriptRunnerMock), ); } +const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"); + +/** + * A repository with no checkout of its own — the shape a bare worktree source + * repo (or a repo whose `core.bare` says so) detects as. + */ +function bareHandle(cwd: string): VcsDriverRegistry.VcsDriverHandle { + return { + kind: "git", + repository: { + kind: "git", + rootPath: `${cwd}/.git`, + metadataPath: `${cwd}/.git`, + bare: true, + freshness: { + source: "live-local", + observedAt: TEST_EPOCH, + expiresAt: Option.none(), + }, + }, + driver: {} as unknown as VcsDriver.VcsDriver["Service"], + }; +} + describe("GitWorkflowService", () => { it.effect("returns an empty local status when no VCS repository is detected", () => Effect.gen(function* () { @@ -100,6 +139,7 @@ describe("GitWorkflowService", () => { status, }), ), + Layer.provide(lifecycleScriptRunnerMock), ); return Effect.gen(function* () { @@ -189,4 +229,160 @@ describe("GitWorkflowService", () => { ), ); }); + + describe("bare repositories", () => { + it.effect("creates a worktree from a bare repository", () => { + // The service builds driver effects eagerly, so execution has to be + // recorded from inside the effect rather than from a call count. + let ran = false; + const createWorktree = () => + Effect.sync(() => { + ran = true; + return { worktree: { path: "/worktrees/feature", refName: "feature" } }; + }); + + return Effect.gen(function* () { + const workflow = yield* GitWorkflowService.GitWorkflowService; + const result = yield* workflow.createWorktree({ + cwd: "/bare-repo", + refName: "main", + newRefName: "feature", + path: null, + }); + + assert.deepStrictEqual(result.worktree, { + path: "/worktrees/feature", + refName: "feature", + }); + assert.isTrue(ran); + }).pipe( + Effect.provide( + makeLayer({ + detect: () => Effect.succeed(bareHandle("/bare-repo")), + resolve: () => Effect.succeed(bareHandle("/bare-repo")), + driver: { createWorktree }, + }), + ), + ); + }); + + it.effect("fetches into a bare repository", () => { + let ran = false; + const fetchRemote = () => + Effect.sync(() => { + ran = true; + }); + + return Effect.gen(function* () { + const workflow = yield* GitWorkflowService.GitWorkflowService; + yield* workflow.fetchRemote({ cwd: "/bare-repo", remoteName: "origin" }); + + assert.isTrue(ran); + }).pipe( + Effect.provide( + makeLayer({ + detect: () => Effect.succeed(bareHandle("/bare-repo")), + resolve: () => Effect.succeed(bareHandle("/bare-repo")), + driver: { fetchRemote }, + }), + ), + ); + }); + + it.effect("checks remotes and prunes worktrees in a bare repository", () => { + // The service builds driver effects eagerly, so execution has to be + // recorded from inside the effect rather than from a call count. + const ran: Array = []; + const remoteExists = () => + Effect.sync(() => { + ran.push("remoteExists"); + return true; + }); + const remoteBranchExists = () => + Effect.sync(() => { + ran.push("remoteBranchExists"); + return true; + }); + const pruneWorktrees = () => + Effect.sync(() => { + ran.push("pruneWorktrees"); + }); + + return Effect.gen(function* () { + const workflow = yield* GitWorkflowService.GitWorkflowService; + + assert.isTrue(yield* workflow.remoteExists({ cwd: "/bare-repo", remoteName: "origin" })); + assert.isTrue( + yield* workflow.remoteBranchExists({ + cwd: "/bare-repo", + remoteName: "origin", + refName: "main", + }), + ); + yield* workflow.pruneWorktrees({ cwd: "/bare-repo" }); + + assert.deepStrictEqual(ran, ["remoteExists", "remoteBranchExists", "pruneWorktrees"]); + }).pipe( + Effect.provide( + makeLayer({ + detect: () => Effect.succeed(bareHandle("/bare-repo")), + resolve: () => Effect.succeed(bareHandle("/bare-repo")), + driver: { remoteExists, remoteBranchExists, pruneWorktrees }, + }), + ), + ); + }); + + it.effect("rejects a checkout-dependent command with an actionable reason", () => { + let ran = false; + const switchRef = () => + Effect.sync(() => { + ran = true; + return { refName: "main" }; + }); + + return Effect.gen(function* () { + const workflow = yield* GitWorkflowService.GitWorkflowService; + const error = yield* workflow + .switchRef({ cwd: "/bare-repo", refName: "main" }) + .pipe(Effect.flip); + + expect(error).toMatchObject({ + _tag: "GitCommandError", + operation: "GitWorkflowService.switchRef", + command: "vcs-route", + cwd: "/bare-repo", + }); + expect(error.detail).toContain("needs a working tree"); + expect(error.detail).toContain("bare Git repository"); + // The gate must short-circuit before the driver command runs. + assert.isFalse(ran); + }).pipe( + Effect.provide( + makeLayer({ + detect: () => Effect.succeed(bareHandle("/bare-repo")), + resolve: () => Effect.succeed(bareHandle("/bare-repo")), + driver: { switchRef }, + }), + ), + ); + }); + + it.effect("reports a bare repository as having no working tree status", () => + Effect.gen(function* () { + const workflow = yield* GitWorkflowService.GitWorkflowService; + const status = yield* workflow.localStatus({ cwd: "/bare-repo" }); + + assert.equal(status.isRepo, false); + assert.equal(status.hasWorkingTreeChanges, false); + }).pipe( + Effect.provide( + makeLayer({ + detect: () => Effect.succeed(bareHandle("/bare-repo")), + resolve: () => Effect.succeed(bareHandle("/bare-repo")), + }), + ), + ), + ); + }); }); diff --git a/apps/server/src/git/GitWorkflowService.ts b/apps/server/src/git/GitWorkflowService.ts index e90a59fae8f1..60ae7d4b215c 100644 --- a/apps/server/src/git/GitWorkflowService.ts +++ b/apps/server/src/git/GitWorkflowService.ts @@ -26,9 +26,12 @@ import { type VcsStatusLocalResult, type VcsStatusRemoteResult, type VcsStatusResult, + type VcsResolveBranchChangeRequestInput, + type VcsResolveBranchChangeRequestResult, } from "@t3tools/contracts"; import * as GitManager from "./GitManager.ts"; +import * as ProjectLifecycleScriptRunner from "../project/ProjectLifecycleScriptRunner.ts"; import * as GitVcsDriver from "../vcs/GitVcsDriver.ts"; import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts"; @@ -56,6 +59,9 @@ export class GitWorkflowService extends Context.Service< readonly resolvePullRequest: ( input: GitPullRequestRefInput, ) => Effect.Effect; + readonly resolveBranchChangeRequest: ( + input: VcsResolveBranchChangeRequestInput, + ) => Effect.Effect; readonly preparePullRequestThread: ( input: GitPreparePullRequestThreadInput, ) => Effect.Effect; @@ -142,15 +148,58 @@ function nonRepositoryListRefs(): VcsListRefsResult { }; } +function lifecycleScriptToGitCommandError( + operation: string, + input: VcsRemoveWorktreeInput, + error: ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunnerError, +): GitCommandError { + if (error._tag === "ProjectLifecycleScriptFailedError") { + const detailParts = [ + error.message, + error.stderr.trim().length > 0 ? error.stderr.trim() : null, + error.stdout.trim().length > 0 ? error.stdout.trim() : null, + ].filter((part): part is string => part !== null); + return new GitCommandError({ + operation, + command: `lifecycle:${error.lifecycle}`, + cwd: input.path, + exitCode: error.exitCode ?? undefined, + failureKind: "unknown", + detail: detailParts.join("\n"), + cause: error, + }); + } + return new GitCommandError({ + operation, + command: `lifecycle:${error.lifecycle}`, + cwd: input.path, + failureKind: "unknown", + detail: error.message, + cause: error, + }); +} + /** @public Service construction is part of the canonical Effect module API. */ export const make = Effect.gen(function* () { const registry = yield* VcsDriverRegistry.VcsDriverRegistry; const git = yield* GitVcsDriver.GitVcsDriver; const gitManager = yield* GitManager.GitManager; + const lifecycleScriptRunner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + + /** + * Bare repositories have no checkout, but stay valid sources for ref, fetch, + * and `worktree add` plumbing — which is exactly what starting a thread needs, + * since the thread then runs in the worktree it just created. Such routes opt + * in with `allowBare: true`; everything that touches a checkout keeps the + * default and reports this reason instead of a blanket routing failure. + */ + const bareRepositoryDetail = (operation: string, cwd: string) => + `The ${operation} operation needs a working tree, but ${cwd} is a bare Git repository (no checkout of its own). Run it inside a worktree, or give the project a checkout.`; const ensureGit = Effect.fn("GitWorkflowService.ensureGit")(function* ( operation: string, cwd: string, + options?: { readonly allowBare?: boolean }, ) { const handle = yield* registry.resolve({ cwd }).pipe( Effect.mapError( @@ -170,11 +219,19 @@ export const make = Effect.gen(function* () { detail: `The ${operation} workflow currently supports Git repositories only; detected ${handle.kind}. (${cwd})`, }); } + if (handle.repository.bare && options?.allowBare !== true) { + return yield* new GitManagerError({ + operation, + cwd, + detail: bareRepositoryDetail(operation, cwd), + }); + } }); const ensureGitCommand = Effect.fn("GitWorkflowService.ensureGitCommand")(function* ( operation: string, cwd: string, + options?: { readonly allowBare?: boolean }, ) { const handle = yield* registry.resolve({ cwd }).pipe( Effect.mapError( @@ -183,6 +240,7 @@ export const make = Effect.gen(function* () { operation, command: "vcs-route", cwd, + failureKind: "unknown", detail: "Failed to resolve the VCS driver for this Git command.", cause, }), @@ -193,9 +251,19 @@ export const make = Effect.gen(function* () { operation, command: "vcs-route", cwd, + failureKind: "unknown", detail: `The ${operation} command currently supports Git repositories only; detected ${handle.kind}.`, }); } + if (handle.repository.bare && options?.allowBare !== true) { + return yield* new GitCommandError({ + operation, + command: "vcs-route", + cwd, + failureKind: "unknown", + detail: bareRepositoryDetail(operation, cwd), + }); + } }); const detectGitRepositoryForStatus = Effect.fn("GitWorkflowService.detectGitRepositoryForStatus")( @@ -221,6 +289,12 @@ export const make = Effect.gen(function* () { detail: `The ${operation} workflow currently supports Git repositories only; detected ${handle.kind}. (${cwd})`, }); } + // Status describes a working tree, and a bare repository has none. These + // paths are polled continuously, so report "no workspace here" instead of + // failing every poll with an error nobody can act on. + if (handle.repository.bare) { + return false; + } return true; }, ); @@ -235,6 +309,7 @@ export const make = Effect.gen(function* () { operation, command: "vcs-route", cwd, + failureKind: "unknown", detail: "Failed to detect a VCS repository for this Git command.", cause, }), @@ -248,6 +323,7 @@ export const make = Effect.gen(function* () { operation, command: "vcs-route", cwd, + failureKind: "unknown", detail: `The ${operation} command currently supports Git repositories only; detected ${handle.kind}.`, }); } @@ -298,6 +374,10 @@ export const make = Effect.gen(function* () { "GitWorkflowService.resolvePullRequest", gitManager.resolvePullRequest, ), + resolveBranchChangeRequest: routeGitManager( + "GitWorkflowService.resolveBranchChangeRequest", + gitManager.resolveBranchChangeRequest, + ), preparePullRequestThread: routeGitManager( "GitWorkflowService.preparePullRequestThread", gitManager.preparePullRequestThread, @@ -308,44 +388,85 @@ export const make = Effect.gen(function* () { isGitRepository ? git.listRefs(input) : Effect.succeed(nonRepositoryListRefs()), ), ), + // `git worktree add` is the whole point of a bare source repository: the + // thread gets its own checkout, so the source never needs one. createWorktree: (input) => - ensureGitCommand("GitWorkflowService.createWorktree", input.cwd).pipe( + ensureGitCommand("GitWorkflowService.createWorktree", input.cwd, { allowBare: true }).pipe( Effect.andThen(git.createWorktree(input)), ), fetchRemote: (input) => - ensureGitCommand("GitWorkflowService.fetchRemote", input.cwd).pipe( + ensureGitCommand("GitWorkflowService.fetchRemote", input.cwd, { allowBare: true }).pipe( Effect.andThen(git.fetchRemote(input)), ), remoteExists: (input) => - ensureGitCommand("GitWorkflowService.remoteExists", input.cwd).pipe( + ensureGitCommand("GitWorkflowService.remoteExists", input.cwd, { allowBare: true }).pipe( Effect.andThen(git.remoteExists(input)), ), remoteBranchExists: (input) => - ensureGitCommand("GitWorkflowService.remoteBranchExists", input.cwd).pipe( - Effect.andThen(git.remoteBranchExists(input)), - ), + ensureGitCommand("GitWorkflowService.remoteBranchExists", input.cwd, { + allowBare: true, + }).pipe(Effect.andThen(git.remoteBranchExists(input))), resolveRemoteTrackingCommit: (input) => - ensureGitCommand("GitWorkflowService.resolveRemoteTrackingCommit", input.cwd).pipe( - Effect.andThen(git.resolveRemoteTrackingCommit(input)), - ), + ensureGitCommand("GitWorkflowService.resolveRemoteTrackingCommit", input.cwd, { + allowBare: true, + }).pipe(Effect.andThen(git.resolveRemoteTrackingCommit(input))), removeWorktree: (input) => - ensureGitCommand("GitWorkflowService.removeWorktree", input.cwd).pipe( - Effect.andThen(git.removeWorktree(input)), + ensureGitCommand("GitWorkflowService.removeWorktree", input.cwd, { allowBare: true }).pipe( + Effect.andThen( + Effect.gen(function* () { + // Prefer the PR associated with the worktree branch (status cwd = worktree path). + const associatedPr = yield* gitManager.remoteStatus({ cwd: input.path }).pipe( + Effect.map((remote) => remote?.pr ?? null), + Effect.orElseSucceed(() => null), + ); + + // Teardown must finish successfully before the worktree directory is removed. + // PR-merged lifecycle is a separate trigger (status transition), not part of remove. + yield* lifecycleScriptRunner + .runWorktreeRemove({ + projectCwd: input.cwd, + worktreePath: input.path, + pr: associatedPr + ? { + number: associatedPr.number, + url: associatedPr.url, + title: associatedPr.title, + baseRef: associatedPr.baseRef, + headRef: associatedPr.headRef, + state: associatedPr.state, + } + : null, + }) + .pipe( + Effect.mapError((error) => + lifecycleScriptToGitCommandError( + "GitWorkflowService.removeWorktree", + input, + error, + ), + ), + ); + + yield* git.removeWorktree(input); + }), + ), ), pruneWorktrees: (input) => - ensureGitCommand("GitWorkflowService.pruneWorktrees", input.cwd).pipe( + ensureGitCommand("GitWorkflowService.pruneWorktrees", input.cwd, { allowBare: true }).pipe( Effect.andThen(git.pruneWorktrees(input)), ), createRef: (input) => - ensureGitCommand("GitWorkflowService.createRef", input.cwd).pipe( - Effect.andThen(git.createRef(input)), - ), + ensureGitCommand("GitWorkflowService.createRef", input.cwd, { + // Creating the branch is pure ref plumbing; only checking it out after + // creation needs a working tree. + allowBare: input.switchRef !== true, + }).pipe(Effect.andThen(git.createRef(input))), switchRef: (input) => ensureGitCommand("GitWorkflowService.switchRef", input.cwd).pipe( Effect.andThen(Effect.scoped(git.switchRef(input))), ), renameBranch: (input) => - ensureGit("GitWorkflowService.renameBranch", input.cwd).pipe( + ensureGit("GitWorkflowService.renameBranch", input.cwd, { allowBare: true }).pipe( Effect.andThen(git.renameBranch(input)), ), }); diff --git a/apps/server/src/git/PrLookupFreeze.test.ts b/apps/server/src/git/PrLookupFreeze.test.ts new file mode 100644 index 000000000000..a472599d71bb --- /dev/null +++ b/apps/server/src/git/PrLookupFreeze.test.ts @@ -0,0 +1,41 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +import * as PrLookupFreeze from "./PrLookupFreeze.ts"; + +const TestLayer = PrLookupFreeze.layer.pipe(Layer.provideMerge(NodeServices.layer)); + +it.layer(TestLayer)("PrLookupFreeze", (it) => { + it.effect("refcounts settled interest per worktree path", () => + Effect.gen(function* () { + const freeze = yield* PrLookupFreeze.PrLookupFreeze; + const cwd = process.cwd(); + + assert.equal(yield* freeze.isWorktreeSettledFrozen(cwd), false); + + yield* freeze.noteWorktreeSettled(cwd); + assert.equal(yield* freeze.isWorktreeSettledFrozen(cwd), true); + + yield* freeze.noteWorktreeSettled(cwd); + assert.equal(yield* freeze.isWorktreeSettledFrozen(cwd), true); + + yield* freeze.noteWorktreeUnsettled(cwd); + assert.equal(yield* freeze.isWorktreeSettledFrozen(cwd), true); + + yield* freeze.noteWorktreeUnsettled(cwd); + assert.equal(yield* freeze.isWorktreeSettledFrozen(cwd), false); + }), + ); + + it.effect("ignores null and empty worktree paths", () => + Effect.gen(function* () { + const freeze = yield* PrLookupFreeze.PrLookupFreeze; + yield* freeze.noteWorktreeSettled(null); + yield* freeze.noteWorktreeSettled(" "); + yield* freeze.noteWorktreeUnsettled(undefined); + assert.equal(yield* freeze.isWorktreeSettledFrozen(process.cwd()), false); + }), + ); +}); diff --git a/apps/server/src/git/PrLookupFreeze.ts b/apps/server/src/git/PrLookupFreeze.ts new file mode 100644 index 000000000000..7ea921227e2a --- /dev/null +++ b/apps/server/src/git/PrLookupFreeze.ts @@ -0,0 +1,71 @@ +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; + +/** + * Durable-settle freeze for PR hosting lookups (gh/glab/…). + * + * VCS remote status is keyed by worktree cwd, not thread id. Projection maps + * `thread.settled` / `thread.unsettled` onto worktree paths with a refcount so a + * shared path only freezes while every interested thread remains settled. + * + * Terminal PR freeze (merged/closed last-known) lives in GitManager and does not + * need this service — it stops re-hitting the provider even when no settle event + * was written (client-only effective settle on merge). + */ +export class PrLookupFreeze extends Context.Service< + PrLookupFreeze, + { + /** +1 settled thread using this worktree (no-op when path is null/empty). */ + readonly noteWorktreeSettled: (worktreePath: string | null | undefined) => Effect.Effect; + /** −1 after unsettle; at 0, PR lookup resumes on the next status poll. */ + readonly noteWorktreeUnsettled: ( + worktreePath: string | null | undefined, + ) => Effect.Effect; + /** True when at least one settled thread still owns this cwd. */ + readonly isWorktreeSettledFrozen: (cwd: string) => Effect.Effect; + } +>()("t3/git/PrLookupFreeze") {} + +export const make = Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const settledRefCountByCwd = yield* Ref.make(new Map()); + + const normalizeWorktreeKey = (cwd: string) => + fs.realPath(cwd).pipe(Effect.orElseSucceed(() => cwd)); + + const adjust = (worktreePath: string | null | undefined, delta: 1 | -1) => + Effect.gen(function* () { + const trimmed = worktreePath?.trim() ?? ""; + if (trimmed.length === 0) { + return; + } + const key = yield* normalizeWorktreeKey(trimmed); + yield* Ref.update(settledRefCountByCwd, (current) => { + const next = new Map(current); + const previous = next.get(key) ?? 0; + const value = Math.max(0, previous + delta); + if (value === 0) { + next.delete(key); + } else { + next.set(key, value); + } + return next; + }); + }); + + return PrLookupFreeze.of({ + noteWorktreeSettled: (worktreePath) => adjust(worktreePath, 1), + noteWorktreeUnsettled: (worktreePath) => adjust(worktreePath, -1), + isWorktreeSettledFrozen: (cwd) => + Effect.gen(function* () { + const key = yield* normalizeWorktreeKey(cwd); + const counts = yield* Ref.get(settledRefCountByCwd); + return (counts.get(key) ?? 0) > 0; + }), + }); +}); + +export const layer = Layer.effect(PrLookupFreeze, make); diff --git a/apps/server/src/github/GitHubAppClient.ts b/apps/server/src/github/GitHubAppClient.ts new file mode 100644 index 000000000000..b48061888b28 --- /dev/null +++ b/apps/server/src/github/GitHubAppClient.ts @@ -0,0 +1,456 @@ +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"; + +import { GitHubAppConfig } from "./GitHubAppConfig.ts"; +import { createGitHubAppJwt } from "./GitHubWebhookSecurity.ts"; +import { + type GitHubPullRequestStackContext, + inferPullRequestStack, +} from "./GitHubPullRequestStack.ts"; + +const GITHUB_API_URL = "https://api.github.com"; +const GITHUB_API_VERSION = "2022-11-28"; + +const InstallationTokenResponse = Schema.Struct({ + token: Schema.String, + expires_at: Schema.String, +}); + +const PermissionResponse = Schema.Struct({ + permission: Schema.String, +}); + +const CommentResponse = Schema.Struct({ + id: Schema.Number, + html_url: Schema.String, +}); + +const ReactionResponse = Schema.Struct({ + id: Schema.Number, +}); + +const PullRequestStackSummary = Schema.Struct({ + number: Schema.Number, + base: Schema.Struct({ ref: Schema.String }), +}); + +const PullRequestResponse = Schema.Struct({ + number: Schema.Number, + head: Schema.Struct({ ref: Schema.String, sha: Schema.String }), + base: Schema.Struct({ ref: Schema.String }), + stack: Schema.optional(Schema.NullOr(PullRequestStackSummary)), +}); + +const PullRequestListResponse = Schema.Array(PullRequestResponse); + +const StackResponse = Schema.Struct({ + number: Schema.Number, + base: Schema.Struct({ ref: Schema.String }), + pull_requests: Schema.Array( + Schema.Struct({ + number: Schema.Number, + head: Schema.Struct({ ref: Schema.String, sha: Schema.String }), + }), + ), +}); + +export interface GitHubComment { + readonly id: number; + readonly url: string; +} + +export class GitHubAppClientError extends Schema.TaggedError()( + "GitHubAppClientError", + { + operation: Schema.String, + status: Schema.NullOr(Schema.Number), + cause: Schema.optional(Schema.Defect()), + }, +) { + override get message(): string { + return this.status === null + ? `GitHub App request failed during ${this.operation}.` + : `GitHub App request failed during ${this.operation} with HTTP ${this.status}.`; + } +} + +export class GitHubAppClient extends Context.Service< + GitHubAppClient, + { + readonly repositoryPermission: (input: { + readonly installationId: number; + readonly repository: string; + readonly actorLogin: string; + }) => Effect.Effect; + readonly createComment: (input: { + readonly installationId: number; + readonly repository: string; + readonly pullRequestNumber: number; + readonly body: string; + }) => Effect.Effect; + readonly updateComment: (input: { + readonly installationId: number; + readonly repository: string; + readonly commentId: number; + readonly body: string; + }) => Effect.Effect; + readonly addCommentReaction: (input: { + readonly installationId: number; + readonly repository: string; + readonly commentId: number; + readonly content: "eyes"; + }) => Effect.Effect; + readonly deleteCommentReaction: (input: { + readonly installationId: number; + readonly repository: string; + readonly commentId: number; + readonly reactionId: number; + }) => Effect.Effect; + /** Reply in an inline review-comment thread (Files changed). */ + readonly createReviewCommentReply: (input: { + readonly installationId: number; + readonly repository: string; + readonly pullRequestNumber: number; + readonly inReplyToCommentId: number; + readonly body: string; + }) => Effect.Effect; + readonly updateReviewComment: (input: { + readonly installationId: number; + readonly repository: string; + readonly commentId: number; + readonly body: string; + }) => Effect.Effect; + readonly addReviewCommentReaction: (input: { + readonly installationId: number; + readonly repository: string; + readonly commentId: number; + readonly content: "eyes"; + }) => Effect.Effect; + readonly deleteReviewCommentReaction: (input: { + readonly installationId: number; + readonly repository: string; + readonly commentId: number; + readonly reactionId: number; + }) => Effect.Effect; + readonly pullRequestStack: (input: { + readonly installationId: number; + readonly repository: string; + readonly pullRequestNumber: number; + }) => Effect.Effect; + } +>()("t3/github/GitHubAppClient") {} + +interface CachedInstallationToken { + readonly token: string; + readonly expiresAtMs: number; +} + +function repositoryPath(repository: string): string { + return repository + .split("/") + .map((segment) => encodeURIComponent(segment)) + .join("/"); +} + +export const make = Effect.gen(function* () { + const config = yield* GitHubAppConfig; + const httpClient = yield* HttpClient.HttpClient; + const fileSystem = yield* FileSystem.FileSystem; + const tokenCache = yield* Ref.make(new Map()); + + const executeJson = ( + operation: string, + request: HttpClientRequest.HttpClientRequest, + schema: S, + ): Effect.Effect => + httpClient + .execute( + request.pipe( + HttpClientRequest.acceptJson, + HttpClientRequest.setHeaders({ + "x-github-api-version": GITHUB_API_VERSION, + "user-agent": "t3-code-github-app", + }), + ), + ) + .pipe( + Effect.mapError((cause) => new GitHubAppClientError({ operation, status: null, cause })), + Effect.flatMap((response) => + HttpClientResponse.matchStatus({ + "2xx": (success) => + HttpClientResponse.schemaBodyJson(schema)(success).pipe( + Effect.mapError( + (cause) => new GitHubAppClientError({ operation, status: success.status, cause }), + ), + ), + orElse: (failure) => + failure.text.pipe( + Effect.ignore, + Effect.andThen( + Effect.fail(new GitHubAppClientError({ operation, status: failure.status })), + ), + ), + })(response), + ), + ); + + const installationToken = Effect.fn("GitHubAppClient.installationToken")(function* ( + installationId: number, + ) { + if (!config.enabled) { + return yield* new GitHubAppClientError({ operation: "configuration", status: null }); + } + const nowMs = yield* Clock.currentTimeMillis; + const cached = (yield* Ref.get(tokenCache)).get(installationId); + if (cached && cached.expiresAtMs - nowMs > 60_000) return cached.token; + + const privateKey = yield* fileSystem + .readFileString(config.privateKeyPath) + .pipe( + Effect.mapError( + (cause) => + new GitHubAppClientError({ operation: "read-private-key", status: null, cause }), + ), + ); + const jwt = yield* Effect.try({ + try: () => + createGitHubAppJwt({ + appId: config.appId, + privateKey, + nowSeconds: Math.floor(nowMs / 1_000), + }), + catch: (cause) => + new GitHubAppClientError({ operation: "sign-app-jwt", status: null, cause }), + }); + const response = yield* executeJson( + "create-installation-token", + HttpClientRequest.post( + `${GITHUB_API_URL}/app/installations/${encodeURIComponent(String(installationId))}/access_tokens`, + ).pipe(HttpClientRequest.bearerToken(jwt), HttpClientRequest.bodyJsonUnsafe({})), + InstallationTokenResponse, + ); + yield* Ref.update(tokenCache, (cache) => { + const next = new Map(cache); + next.set(installationId, { + token: response.token, + expiresAtMs: nowMs + 5 * 60_000, + }); + return next; + }); + return response.token; + }); + + const executeVoid = ( + operation: string, + request: HttpClientRequest.HttpClientRequest, + ): Effect.Effect => + httpClient + .execute( + request.pipe( + HttpClientRequest.acceptJson, + HttpClientRequest.setHeaders({ + "x-github-api-version": GITHUB_API_VERSION, + "user-agent": "t3-code-github-app", + }), + ), + ) + .pipe( + Effect.mapError((cause) => new GitHubAppClientError({ operation, status: null, cause })), + Effect.flatMap( + HttpClientResponse.matchStatus({ + "2xx": () => Effect.void, + orElse: (failure) => + Effect.fail(new GitHubAppClientError({ operation, status: failure.status })), + }), + ), + ); + + const authenticatedRequest = Effect.fn("GitHubAppClient.authenticatedRequest")(function* ( + installationId: number, + request: HttpClientRequest.HttpClientRequest, + ) { + const token = yield* installationToken(installationId); + return request.pipe(HttpClientRequest.bearerToken(token)); + }); + + return GitHubAppClient.of({ + pullRequestStack: Effect.fn("GitHubAppClient.pullRequestStack")(function* (input) { + const repository = repositoryPath(input.repository); + const pullRequestRequest = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.get( + `${GITHUB_API_URL}/repos/${repository}/pulls/${input.pullRequestNumber}`, + ), + ); + const pullRequest = yield* executeJson( + "get-pull-request-stack", + pullRequestRequest, + PullRequestResponse, + ); + + if (pullRequest.stack !== undefined && pullRequest.stack !== null) { + const stackRequest = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.get( + `${GITHUB_API_URL}/repos/${repository}/stacks/${pullRequest.stack.number}`, + ), + ); + const stack = yield* executeJson("get-stack", stackRequest, StackResponse); + return { + source: "github" as const, + stackNumber: stack.number, + baseBranch: stack.base.ref, + pullRequests: stack.pull_requests.map((candidate) => ({ + number: candidate.number, + headBranch: candidate.head.ref, + headSha: candidate.head.sha, + })), + }; + } + + const openPullRequests = yield* Effect.gen(function* () { + const collected: Array = []; + for (let page = 1; ; page += 1) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.get( + `${GITHUB_API_URL}/repos/${repository}/pulls?state=open&per_page=100&page=${page}`, + ), + ); + const response = yield* executeJson( + "list-open-pull-requests-for-stack-inference", + request, + PullRequestListResponse, + ); + collected.push(...response); + if (response.length < 100) break; + } + return collected; + }); + return inferPullRequestStack({ + target: { + number: pullRequest.number, + headBranch: pullRequest.head.ref, + headSha: pullRequest.head.sha, + baseBranch: pullRequest.base.ref, + }, + openPullRequests: openPullRequests.map((candidate) => ({ + number: candidate.number, + headBranch: candidate.head.ref, + headSha: candidate.head.sha, + baseBranch: candidate.base.ref, + })), + }); + }), + repositoryPermission: Effect.fn("GitHubAppClient.repositoryPermission")(function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.get( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/collaborators/${encodeURIComponent(input.actorLogin)}/permission`, + ), + ); + const response = yield* executeJson("repository-permission", request, PermissionResponse); + return response.permission; + }), + createComment: Effect.fn("GitHubAppClient.createComment")(function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.post( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/issues/${input.pullRequestNumber}/comments`, + ).pipe(HttpClientRequest.bodyJsonUnsafe({ body: input.body })), + ); + const response = yield* executeJson("create-comment", request, CommentResponse); + return { id: response.id, url: response.html_url }; + }), + updateComment: Effect.fn("GitHubAppClient.updateComment")(function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.patch( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/issues/comments/${input.commentId}`, + ).pipe(HttpClientRequest.bodyJsonUnsafe({ body: input.body })), + ); + const response = yield* executeJson("update-comment", request, CommentResponse); + return { id: response.id, url: response.html_url }; + }), + addCommentReaction: Effect.fn("GitHubAppClient.addCommentReaction")(function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.post( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/issues/comments/${input.commentId}/reactions`, + ).pipe(HttpClientRequest.bodyJsonUnsafe({ content: input.content })), + ); + const response = yield* executeJson("add-comment-reaction", request, ReactionResponse); + return response.id; + }), + deleteCommentReaction: Effect.fn("GitHubAppClient.deleteCommentReaction")(function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.delete( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/issues/comments/${input.commentId}/reactions/${input.reactionId}`, + ), + ); + yield* executeVoid("delete-comment-reaction", request); + }), + createReviewCommentReply: Effect.fn("GitHubAppClient.createReviewCommentReply")( + function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.post( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/pulls/${input.pullRequestNumber}/comments/${input.inReplyToCommentId}/replies`, + ).pipe(HttpClientRequest.bodyJsonUnsafe({ body: input.body })), + ); + const response = yield* executeJson( + "create-review-comment-reply", + request, + CommentResponse, + ); + return { id: response.id, url: response.html_url }; + }, + ), + updateReviewComment: Effect.fn("GitHubAppClient.updateReviewComment")(function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.patch( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/pulls/comments/${input.commentId}`, + ).pipe(HttpClientRequest.bodyJsonUnsafe({ body: input.body })), + ); + const response = yield* executeJson("update-review-comment", request, CommentResponse); + return { id: response.id, url: response.html_url }; + }), + addReviewCommentReaction: Effect.fn("GitHubAppClient.addReviewCommentReaction")( + function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.post( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/pulls/comments/${input.commentId}/reactions`, + ).pipe(HttpClientRequest.bodyJsonUnsafe({ content: input.content })), + ); + const response = yield* executeJson( + "add-review-comment-reaction", + request, + ReactionResponse, + ); + return response.id; + }, + ), + deleteReviewCommentReaction: Effect.fn("GitHubAppClient.deleteReviewCommentReaction")( + function* (input) { + const request = yield* authenticatedRequest( + input.installationId, + HttpClientRequest.delete( + `${GITHUB_API_URL}/repos/${repositoryPath(input.repository)}/pulls/comments/${input.commentId}/reactions/${input.reactionId}`, + ), + ); + yield* executeVoid("delete-review-comment-reaction", request); + }, + ), + }); +}); + +export const layer = Layer.effect(GitHubAppClient, make); diff --git a/apps/server/src/github/GitHubAppConfig.ts b/apps/server/src/github/GitHubAppConfig.ts new file mode 100644 index 000000000000..1581f6992aed --- /dev/null +++ b/apps/server/src/github/GitHubAppConfig.ts @@ -0,0 +1,90 @@ +import * as Config from "effect/Config"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Redacted from "effect/Redacted"; + +export type GitHubRepositoryPermission = "read" | "triage" | "write" | "maintain" | "admin"; + +export interface EnabledGitHubAppConfig { + readonly enabled: true; + readonly appId: string; + readonly privateKeyPath: string; + readonly webhookSecret: string; + readonly mention: string; + readonly allowedRepositories: ReadonlySet; + readonly minimumPermission: GitHubRepositoryPermission; + readonly turnTimeoutMs: number; +} + +export interface DisabledGitHubAppConfig { + readonly enabled: false; + readonly missing: ReadonlyArray; +} + +export type GitHubAppConfigValue = EnabledGitHubAppConfig | DisabledGitHubAppConfig; + +export class GitHubAppConfig extends Context.Service()( + "t3/github/GitHubAppConfig", +) {} + +const optionalString = (name: string) => + Config.string(name).pipe(Config.option, Config.map(Option.getOrUndefined)); + +const optionalSecret = (name: string) => + Config.redacted(name).pipe( + Config.option, + Config.map(Option.map(Redacted.value)), + Config.map(Option.getOrUndefined), + ); + +const configEffect = Effect.gen(function* () { + const values = yield* Config.all({ + appId: optionalString("T3CODE_GITHUB_APP_ID"), + privateKeyPath: optionalString("T3CODE_GITHUB_APP_PRIVATE_KEY_PATH"), + webhookSecret: optionalSecret("T3CODE_GITHUB_WEBHOOK_SECRET"), + mention: optionalString("T3CODE_GITHUB_APP_MENTION"), + allowedRepositories: Config.string("T3CODE_GITHUB_ALLOWED_REPOSITORIES").pipe( + Config.withDefault(""), + ), + minimumPermission: Config.literals( + ["read", "triage", "write", "maintain", "admin"] as const, + "T3CODE_GITHUB_MIN_PERMISSION", + ).pipe(Config.withDefault("write" as const)), + turnTimeoutMs: Config.number("T3CODE_GITHUB_TURN_TIMEOUT_MS").pipe( + Config.withDefault(30 * 60_000), + ), + }); + + const required = [ + ["T3CODE_GITHUB_APP_ID", values.appId], + ["T3CODE_GITHUB_APP_PRIVATE_KEY_PATH", values.privateKeyPath], + ["T3CODE_GITHUB_WEBHOOK_SECRET", values.webhookSecret], + ["T3CODE_GITHUB_APP_MENTION", values.mention], + ] as const; + const missing = required.filter(([, value]) => !value?.trim()).map(([name]) => name); + if (missing.length > 0) { + return GitHubAppConfig.of({ enabled: false, missing }); + } + + const allowedRepositories = new Set( + values.allowedRepositories + .split(",") + .map((repository) => repository.trim().toLowerCase()) + .filter(Boolean), + ); + const mention = values.mention!.trim().replace(/^@/u, ""); + return GitHubAppConfig.of({ + enabled: true, + appId: values.appId!.trim(), + privateKeyPath: values.privateKeyPath!.trim(), + webhookSecret: values.webhookSecret!, + mention, + allowedRepositories, + minimumPermission: values.minimumPermission, + turnTimeoutMs: Math.max(10_000, values.turnTimeoutMs), + }); +}); + +export const layer = Layer.effect(GitHubAppConfig, configEffect); diff --git a/apps/server/src/github/GitHubDeliveryStore.ts b/apps/server/src/github/GitHubDeliveryStore.ts new file mode 100644 index 000000000000..444fc67a2f53 --- /dev/null +++ b/apps/server/src/github/GitHubDeliveryStore.ts @@ -0,0 +1,197 @@ +import type { ThreadId, TurnId } from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; + +import { writeFileStringAtomically } from "../atomicWrite.ts"; +import { ServerConfig } from "../config.ts"; + +const MAX_DELIVERIES = 2_000; + +export const GitHubDelivery = Schema.Struct({ + deliveryId: Schema.String, + installationId: Schema.Number, + repository: Schema.String, + pullRequestNumber: Schema.Number, + sourceCommentId: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))), + /** + * Where the source mention lived and where responses are posted. + * - `issue`: PR conversation comment (Issues API) + * - `review`: inline Files-changed review comment (Pulls review-comment API) + */ + commentSurface: Schema.Literals(["issue", "review"]).pipe( + Schema.withDecodingDefault(Effect.succeed("issue" as const)), + ), + /** + * Review-thread parent for replies (top-level review comment id). Defaults to + * `sourceCommentId` for legacy deliveries and issue-surface comments. + */ + replyToCommentId: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))), + acknowledgmentReactionId: Schema.NullOr(Schema.Number).pipe( + Schema.withDecodingDefault(Effect.succeed(null)), + ), + responseCommentId: Schema.NullOr(Schema.Number), + threadId: Schema.NullOr(Schema.String), + previousTurnId: Schema.NullOr(Schema.String), + /** User message id dispatched for this delivery (stable anchor across restarts). */ + userMessageId: Schema.NullOr(Schema.String).pipe( + Schema.withDecodingDefault(Effect.succeed(null)), + ), + /** + * Turn id this delivery is waiting to finalize. Discovered once assistants appear for the + * dispatched user message; preferred over `latestTurn` which can move or go null. + */ + targetTurnId: Schema.NullOr(Schema.String).pipe(Schema.withDecodingDefault(Effect.succeed(null))), + status: Schema.Literals(["received", "processing", "completed", "rejected"]), + createdAt: Schema.String, + updatedAt: Schema.String, +}); +export type StoredGitHubDelivery = { + readonly deliveryId: string; + readonly installationId: number; + readonly repository: string; + readonly pullRequestNumber: number; + readonly sourceCommentId: number; + readonly commentSurface: "issue" | "review"; + readonly replyToCommentId: number; + readonly acknowledgmentReactionId: number | null; + readonly responseCommentId: number | null; + readonly threadId: ThreadId | null; + readonly previousTurnId: TurnId | null; + readonly userMessageId: string | null; + readonly targetTurnId: TurnId | null; + readonly status: "received" | "processing" | "completed" | "rejected"; + readonly createdAt: string; + readonly updatedAt: string; +}; + +const decodeDeliveries = Schema.decodeUnknownSync( + Schema.fromJsonString(Schema.Array(GitHubDelivery)), +); + +export class GitHubDeliveryStore extends Context.Service< + GitHubDeliveryStore, + { + readonly get: (deliveryId: string) => Effect.Effect; + readonly claim: (delivery: StoredGitHubDelivery) => Effect.Effect; + readonly put: (delivery: StoredGitHubDelivery) => Effect.Effect; + readonly listProcessing: () => Effect.Effect>; + /** + * Most recent delivery that bound a T3 thread to a GitHub inline review discussion + * (keyed by review root comment id / replyToCommentId). + */ + readonly findLatestReviewThreadAssignment: (input: { + readonly repository: string; + readonly pullRequestNumber: number; + readonly reviewRootCommentId: number; + }) => Effect.Effect; + } +>()("t3/github/GitHubDeliveryStore") {} + +export const make = Effect.gen(function* () { + const config = yield* ServerConfig; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const filePath = path.join(config.stateDir, "github-webhook-deliveries.json"); + const initial = yield* fileSystem.readFileString(filePath).pipe( + Effect.map((raw) => { + try { + return decodeDeliveries(raw).map((delivery): StoredGitHubDelivery => { + // Older deliveries lack replyToCommentId; fall back to the source comment. + const replyToCommentId = + delivery.replyToCommentId > 0 ? delivery.replyToCommentId : delivery.sourceCommentId; + return { + ...delivery, + replyToCommentId, + threadId: delivery.threadId as ThreadId | null, + previousTurnId: delivery.previousTurnId as TurnId | null, + targetTurnId: delivery.targetTurnId as TurnId | null, + }; + }); + } catch { + return []; + } + }), + Effect.orElseSucceed((): StoredGitHubDelivery[] => []), + ); + const state = yield* Ref.make( + new Map(initial.map((delivery) => [delivery.deliveryId, delivery])), + ); + const lock = yield* Semaphore.make(1); + + const persist = (deliveries: ReadonlyMap) => { + const retained = [...deliveries.values()] + .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)) + .slice(0, MAX_DELIVERIES); + return writeFileStringAtomically({ + filePath, + contents: `${JSON.stringify(retained, null, 2)}\n`, + }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + Effect.orDie, + ); + }; + + return GitHubDeliveryStore.of({ + get: (deliveryId) => + Ref.get(state).pipe(Effect.map((deliveries) => deliveries.get(deliveryId) ?? null)), + claim: (delivery) => + lock.withPermit( + Effect.gen(function* () { + const claimed = yield* Ref.modify(state, (deliveries) => { + if (deliveries.has(delivery.deliveryId)) return [false, deliveries] as const; + const updated = new Map(deliveries); + updated.set(delivery.deliveryId, delivery); + return [true, updated] as const; + }); + if (claimed) yield* persist(yield* Ref.get(state)); + return claimed; + }), + ), + put: (delivery) => + lock.withPermit( + Effect.gen(function* () { + const next = yield* Ref.updateAndGet(state, (deliveries) => { + const updated = new Map(deliveries); + updated.set(delivery.deliveryId, delivery); + return updated; + }); + yield* persist(next); + }), + ), + listProcessing: () => + Ref.get(state).pipe( + Effect.map((deliveries) => + [...deliveries.values()].filter((delivery) => delivery.status === "processing"), + ), + ), + findLatestReviewThreadAssignment: (input) => + Ref.get(state).pipe( + Effect.map((deliveries) => { + const expectedRepo = input.repository.trim().toLowerCase(); + const rootId = input.reviewRootCommentId; + const matches = [...deliveries.values()] + .filter( + (delivery) => + delivery.commentSurface === "review" && + delivery.threadId !== null && + delivery.pullRequestNumber === input.pullRequestNumber && + delivery.repository.trim().toLowerCase() === expectedRepo && + (delivery.replyToCommentId > 0 + ? delivery.replyToCommentId + : delivery.sourceCommentId) === rootId, + ) + .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)); + return matches[0] ?? null; + }), + ), + }); +}); + +export const layer = Layer.effect(GitHubDeliveryStore, make); diff --git a/apps/server/src/github/GitHubPrBridge.ts b/apps/server/src/github/GitHubPrBridge.ts new file mode 100644 index 000000000000..8c738ccbd501 --- /dev/null +++ b/apps/server/src/github/GitHubPrBridge.ts @@ -0,0 +1,1516 @@ +import { + CommandId, + DEFAULT_PROVIDER_INTERACTION_MODE, + MessageId, + type OrchestrationThread, + type OrchestrationThreadShell, + type ModelSelection, + type RepositoryIdentity, + ThreadId, + type TurnId, + type VcsStatusLocalResult, +} from "@t3tools/contracts"; +import { + DISCORD_LINK_REQUEST_MARKER, + parseProviderModelFlags, + resolveProviderModelSelection, +} from "@t3tools/shared/providerModelSelection"; +import { + appendTurnResponseStatsFooter, + formatTurnResponseStatsLine, +} from "@t3tools/shared/turnResponseStats"; +import * as Cause from "effect/Cause"; +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Semaphore from "effect/Semaphore"; + +import * as IdentityService from "../identity/IdentityService.ts"; +import { buildIntegrationSourceRef } from "../identity/stampSource.ts"; +import * as GitWorkflowService from "../git/GitWorkflowService.ts"; +import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; +import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import { ProjectSetupScriptRunner } from "../project/ProjectSetupScriptRunner.ts"; +import { ProviderRegistry } from "../provider/Services/ProviderRegistry.ts"; +import { getAutoBootstrapThreadModelSelection } from "../serverRuntimeStartup.ts"; +import { + extractJiraIssueKeysFromText, + ThreadWorkItemStore, +} from "../workItems/ThreadWorkItemStore.ts"; +import { GitHubAppClient } from "./GitHubAppClient.ts"; +import { GitHubAppConfig, type GitHubRepositoryPermission } from "./GitHubAppConfig.ts"; +import { GitHubDeliveryStore, type StoredGitHubDelivery } from "./GitHubDeliveryStore.ts"; +import { + defaultGitHubThreadMode, + type GitHubPrInvocation, + type GitHubThreadMode, + parseGitHubThreadMode, +} from "./GitHubWebhookPayload.ts"; +import { + type GitHubPullRequestStackContext, + stackBranchesForMatching, +} from "./GitHubPullRequestStack.ts"; +import { classifyGitHubActorTrust } from "./githubActorTrust.ts"; + +const BUSY_RESPONSE = + "This T3 thread is already working. Try again after the current turn finishes."; +const FAILED_RESPONSE = + "T3 could not complete this request. Check the linked T3 thread for details."; +const PROVISION_NO_PROJECT_RESPONSE = + "T3 has no project linked to this repository, so it could not open a thread for this pull request."; +const PROVISION_AMBIGUOUS_PROJECT_RESPONSE = + "T3 has more than one project linked to this repository, so it could not pick which one to use for this pull request."; +const PROVISION_WORKTREE_FAILED_RESPONSE = + "T3 could not create a worktree for this pull request. Check the server logs for details."; +const PROVISION_FAILED_RESPONSE = + "T3 could not open a thread for this pull request. Check the server logs for details."; +const EMPTY_PROMPT_RESPONSE = + "Provide a prompt after the mention. Conversation comments use the PR work thread; inline review reuses that discussion's session (first tag creates it). Override with `main-thread` or `sibling-thread`."; +const IDENTITY_DENIED_RESPONSE = + "Not authorized to run agent turns from this GitHub account. When the T3 identity map is enabled, only mapped operators (`github.login` / `github.id`) can invoke the bot — repository write access alone is not enough (including on public repos)."; +const MAX_GITHUB_COMMENT_LENGTH = 65_536; + +const PERMISSION_RANK: Readonly> = { + read: 0, + triage: 1, + write: 2, + maintain: 3, + admin: 4, +}; + +export function hasRequiredGitHubPermission( + actual: string, + minimum: GitHubRepositoryPermission, +): boolean { + return (PERMISSION_RANK[actual as GitHubRepositoryPermission] ?? -1) >= PERMISSION_RANK[minimum]; +} + +function normalizePullRequestUrl(value: string): string { + return value.trim().replace(/\/+$/u, "").toLowerCase(); +} + +/** Jira keys from PR title and the mention comment body (after @bot is stripped). */ +export function extractJiraIssueKeysFromGitHubInvocation( + invocation: Pick, +): ReadonlyArray { + return extractJiraIssueKeysFromText(`${invocation.pullRequestTitle}\n${invocation.prompt}`); +} + +/** Empty allowlist permits every installed repo. Entries are `owner/name` or `owner/*`. */ +export function isGitHubRepositoryAllowed( + allowedRepositories: ReadonlySet, + repository: string, +): boolean { + if (allowedRepositories.size === 0) return true; + const normalized = repository.trim().toLowerCase(); + if (allowedRepositories.has(normalized)) return true; + const separator = normalized.indexOf("/"); + if (separator <= 0 || normalized.indexOf("/", separator + 1) !== -1) return false; + const repoName = normalized.slice(separator + 1); + if (repoName.length === 0) return false; + return allowedRepositories.has(`${normalized.slice(0, separator)}/*`); +} + +function remoteMatchesGitHubRepository( + remote: { + readonly canonicalKey: string; + readonly provider?: string | undefined; + readonly owner?: string | undefined; + readonly name?: string | undefined; + }, + expected: string, +): boolean { + if (remote.provider?.toLowerCase() !== "github") return false; + const ownerAndName = + remote.owner && remote.name ? `${remote.owner}/${remote.name}`.toLowerCase() : null; + return ( + ownerAndName === expected || remote.canonicalKey.toLowerCase() === `github.com/${expected}` + ); +} + +export function matchesGitHubRepository( + identity: RepositoryIdentity | null | undefined, + repository: string, +): boolean { + if (!identity) return false; + const expected = repository.trim().toLowerCase(); + // A fork answers to every repository it has a remote for — `origin` for the fork + // itself and `upstream` for the repository it was forked from. Matching only the + // primary remote drops webhooks from the other one. + return ( + remoteMatchesGitHubRepository(identity, expected) || + (identity.remotes ?? []).some((remote) => remoteMatchesGitHubRepository(remote, expected)) + ); +} + +// Provisioning fails for reasons the PR author can act on differently — an unlinked +// repository is not a broken worktree — so the outcome carries the reply to post. +type ProvisionOutcome = + | { readonly _tag: "provisioned"; readonly thread: OrchestrationThreadShell } + | { readonly _tag: "failed"; readonly response: string }; + +function provisioned(thread: OrchestrationThreadShell): ProvisionOutcome { + return { _tag: "provisioned", thread }; +} + +function provisionFailed(response: string): ProvisionOutcome { + return { _tag: "failed", response }; +} + +export function liveWorktreeRef( + thread: Pick, + local: Pick, +): { readonly cwd: string; readonly refName: string } | null { + if (thread.worktreePath === null || !local.isRepo || local.refName === null) return null; + return { cwd: thread.worktreePath, refName: local.refName }; +} + +function isThreadBusy(thread: OrchestrationThreadShell): boolean { + return ( + thread.latestTurn?.state === "running" || + thread.session?.status === "starting" || + thread.session?.status === "running" + ); +} + +function assistantMessagesForTurn( + thread: OrchestrationThread, + turnId: string | null, +): ReadonlyArray { + if (turnId !== null) { + return thread.messages.filter( + (message) => message.role === "assistant" && message.turnId === turnId, + ); + } + let lastUserIndex = -1; + for (let index = thread.messages.length - 1; index >= 0; index -= 1) { + if (thread.messages[index]?.role === "user") { + lastUserIndex = index; + break; + } + } + return thread.messages.slice(lastUserIndex + 1).filter((message) => message.role === "assistant"); +} + +/** + * Prefer the dispatched turn's assistants. Falling back to "after last user" re-posts a later + * Discord/GH wake-up body when the original turn already finished (the PR #865 bug). + */ +export function githubFinalAnswerText( + thread: OrchestrationThread, + turnId: string | null = null, +): string { + const texts = assistantMessagesForTurn(thread, turnId) + .map((message) => message.text.trimEnd()) + .filter((text) => text.trim() !== ""); + if (texts.length === 0) return ""; + if (texts.length === 1) return texts[0]!; + const last = texts[texts.length - 1]!; + const longest = texts.reduce((left, right) => (left.length >= right.length ? left : right)); + return longest.length >= 800 && last.length < longest.length * 0.5 ? longest : last; +} + +/** Final GH comment body: assistant answer + small italic turn stats footer when available. */ +export function githubFinalAnswerWithStats( + thread: OrchestrationThread, + turnId: string | null = null, +): string { + const answer = githubFinalAnswerText(thread, turnId); + if (answer.trim() === "") return ""; + return appendTurnResponseStatsFooter( + answer, + formatTurnResponseStatsLine({ + modelSelection: thread.modelSelection, + activities: thread.activities, + turnId, + latestTurn: thread.latestTurn, + }), + ); +} + +/** + * Discover the turn id that belongs to a GitHub-dispatched delivery. + * + * Order matters for restore / legacy deliveries (no userMessageId): + * 1. Already-persisted targetTurnId + * 2. Assistants after the dispatched user message + * 3. First assistant turn *after* previousTurnId in message order (the original turn), + * never the newest latestTurn alone — a later GH/Discord wake-up would steal the delivery + * and double-post the wake-up body (PR #865 duplicate comments). + * 4. latestTurn only when it is the sole signal (no later history after previous yet) + */ +export function discoverGitHubTargetTurnId( + thread: OrchestrationThread, + options: { + readonly userMessageId: string | null; + readonly previousTurnId: string | null; + readonly knownTargetTurnId: string | null; + }, +): string | null { + if (options.knownTargetTurnId !== null) return options.knownTargetTurnId; + + if (options.userMessageId !== null) { + const userIndex = thread.messages.findIndex((message) => message.id === options.userMessageId); + if (userIndex >= 0) { + for (let index = userIndex + 1; index < thread.messages.length; index += 1) { + const message = thread.messages[index]!; + if (message.role === "assistant" && message.turnId !== null) { + return message.turnId; + } + } + } + } + + // Legacy deliveries and restores without userMessageId: walk message order so a + // completed original turn is chosen before any subsequent wake-up turn. + if (options.previousTurnId !== null) { + let seenPrevious = false; + let previousPresentInHistory = false; + for (const message of thread.messages) { + if (message.turnId === options.previousTurnId) { + previousPresentInHistory = true; + seenPrevious = true; + continue; + } + if (!seenPrevious) continue; + if ( + message.role === "assistant" && + message.turnId !== null && + message.turnId !== options.previousTurnId + ) { + return message.turnId; + } + } + // Detail snapshots drop older messages. If previousTurnId is gone, every retained + // assistant is newer — pick the earliest distinct turn (original), not latest. + if (!previousPresentInHistory) { + for (const message of thread.messages) { + if ( + message.role === "assistant" && + message.turnId !== null && + message.turnId !== options.previousTurnId + ) { + return message.turnId; + } + } + } + } + + const latestTurnId = thread.latestTurn?.turnId ?? null; + if (latestTurnId !== null && latestTurnId !== options.previousTurnId) { + return latestTurnId; + } + return null; +} + +export type GitHubBridgeTurnOutcome = + | { readonly _tag: "waiting" } + | { + readonly _tag: "terminal"; + readonly status: "completed" | "rejected"; + readonly body: string; + readonly targetTurnId: string | null; + }; + +/** + * Decide whether the delivery's target turn is done without requiring latestTurn to still + * point at that turn (session-set used to clear latest_turn_id; later turns can also move it). + */ +export function resolveGitHubBridgeTurnOutcome( + thread: OrchestrationThread, + options: { + readonly userMessageId: string | null; + readonly previousTurnId: string | null; + readonly knownTargetTurnId: string | null; + }, +): GitHubBridgeTurnOutcome { + const targetTurnId = discoverGitHubTargetTurnId(thread, options); + if (targetTurnId === null) return { _tag: "waiting" }; + + const latest = thread.latestTurn; + const session = thread.session; + const assistants = assistantMessagesForTurn(thread, targetTurnId); + const anyStreaming = assistants.some((message) => message.streaming); + + const activelyRunningThisTurn = + anyStreaming || + (latest !== null && latest.turnId === targetTurnId && latest.state === "running") || + (session !== null && + session.activeTurnId === targetTurnId && + (session.status === "running" || session.status === "starting")); + + if (activelyRunningThisTurn) return { _tag: "waiting" }; + + if (latest !== null && latest.turnId === targetTurnId) { + if (latest.state === "running") return { _tag: "waiting" }; + if (latest.state === "completed") { + return { + _tag: "terminal", + status: "completed", + body: githubFinalAnswerWithStats(thread, targetTurnId) || FAILED_RESPONSE, + targetTurnId, + }; + } + return { + _tag: "terminal", + status: "rejected", + body: FAILED_RESPONSE, + targetTurnId, + }; + } + + // Target turn is no longer latest (or latest_turn_id was wiped). If we already have + // non-streaming assistants, or a checkpoint, the turn finished. + const hasCheckpoint = thread.checkpoints.some((checkpoint) => checkpoint.turnId === targetTurnId); + const laterTurnObserved = + (latest !== null && latest.turnId !== targetTurnId) || + thread.messages.some( + (message) => + message.turnId !== null && + message.turnId !== targetTurnId && + message.turnId !== options.previousTurnId && + assistants.length > 0, + ); + + if (assistants.length > 0 || hasCheckpoint || laterTurnObserved) { + const body = githubFinalAnswerWithStats(thread, targetTurnId); + if (body.trim() !== "" || hasCheckpoint || laterTurnObserved) { + return { + _tag: "terminal", + status: body.trim() !== "" ? "completed" : "rejected", + body: body || FAILED_RESPONSE, + targetTurnId, + }; + } + } + + return { _tag: "waiting" }; +} + +export function formatGitHubComment(body: string): string { + const normalized = body.trim() || FAILED_RESPONSE; + const truncated = + normalized.length <= MAX_GITHUB_COMMENT_LENGTH + ? normalized + : `${normalized.slice(0, MAX_GITHUB_COMMENT_LENGTH - 24).trimEnd()}\n\n[response truncated]`; + return truncated; +} + +function formatReviewContextLines( + review: NonNullable, +): ReadonlyArray { + const line = + review.line !== null + ? String(review.line) + : review.originalLine !== null + ? `${review.originalLine} (original)` + : "unknown"; + const lines = [ + `File: ${review.path}`, + `Line: ${line}`, + ...(review.side === null ? [] : [`Side: ${review.side}`]), + ...(review.commitId === null ? [] : [`Commit: ${review.commitId}`]), + ]; + if (review.diffHunk !== null && review.diffHunk.trim() !== "") { + lines.push("Diff hunk:", "```diff", review.diffHunk.trimEnd(), "```"); + } + return lines; +} + +export function buildGitHubTurnPrompt( + invocation: GitHubPrInvocation, + options?: { + readonly discordLinkRequested?: boolean; + readonly stackContext?: GitHubPullRequestStackContext | null; + readonly threadMode?: GitHubThreadMode; + }, +): string { + const stack = options?.stackContext; + const threadMode = options?.threadMode ?? "sibling"; + const surfaceLabel = + invocation.commentSurface === "review" ? "inline review thread" : "pull request conversation"; + const sessionLabel = + threadMode === "main" + ? "the PR implementation thread (full prior history)" + : "a fresh sibling session on the PR worktree (no prior implementation history)"; + return [ + "", + "", + `From GH [${invocation.actorLogin}](https://github.com/${encodeURIComponent(invocation.actorLogin)}) on [PR #${invocation.pullRequestNumber}](${invocation.commentUrl}): ${invocation.prompt}`, + ].join("\n"); +} + +function githubCommentThreadTitle(invocation: GitHubPrInvocation, mode: GitHubThreadMode): string { + const seed = invocation.prompt.trim().replace(/\s+/gu, " ").slice(0, 60); + if (mode === "main") { + return `PR #${invocation.pullRequestNumber}: ${invocation.pullRequestTitle}`; + } + return seed.length > 0 + ? `PR #${invocation.pullRequestNumber} GH: ${seed}` + : `PR #${invocation.pullRequestNumber} GH comment`; +} + +export class GitHubPrBridge extends Context.Service< + GitHubPrBridge, + { + readonly handle: (input: { + readonly deliveryId: string; + readonly invocation: GitHubPrInvocation; + }) => Effect.Effect; + readonly restore: Effect.Effect; + } +>()("t3/github/GitHubPrBridge") {} + +export const make = Effect.gen(function* () { + const config = yield* GitHubAppConfig; + const github = yield* GitHubAppClient; + const deliveries = yield* GitHubDeliveryStore; + const workItems = yield* ThreadWorkItemStore; + const projection = yield* ProjectionSnapshotQuery; + const gitWorkflow = yield* GitWorkflowService.GitWorkflowService; + const engine = yield* OrchestrationEngineService; + const projectSetupScriptRunner = yield* ProjectSetupScriptRunner; + const providerRegistry = yield* ProviderRegistry; + const identity = yield* IdentityService.IdentityService; + const crypto = yield* Crypto.Crypto; + const provisionLock = yield* Semaphore.make(1); + + if (config.enabled) { + yield* Effect.logInfo("GitHub PR bridge enabled", { + mention: config.mention, + allowedRepositories: [...config.allowedRepositories], + minimumPermission: config.minimumPermission, + turnTimeoutMs: config.turnTimeoutMs, + }); + } else { + yield* Effect.logInfo("GitHub PR bridge disabled", { missing: config.missing }); + } + + const updateDelivery = (delivery: StoredGitHubDelivery, patch: Partial) => + DateTime.now.pipe( + Effect.flatMap((now) => + deliveries.put({ ...delivery, ...patch, updatedAt: DateTime.formatIso(now) }), + ), + ); + + const updateResponse = (delivery: StoredGitHubDelivery, body: string) => { + if (delivery.responseCommentId === null) return Effect.void; + const formatted = formatGitHubComment(body); + if (delivery.commentSurface === "review") { + return github + .updateReviewComment({ + installationId: delivery.installationId, + repository: delivery.repository, + commentId: delivery.responseCommentId, + body: formatted, + }) + .pipe(Effect.asVoid); + } + return github + .updateComment({ + installationId: delivery.installationId, + repository: delivery.repository, + commentId: delivery.responseCommentId, + body: formatted, + }) + .pipe(Effect.asVoid); + }; + + const publishResponse = Effect.fn("GitHubPrBridge.publishResponse")(function* ( + delivery: StoredGitHubDelivery, + body: string, + ) { + if (delivery.responseCommentId !== null) { + yield* updateResponse(delivery, body); + return delivery.responseCommentId; + } + const formatted = formatGitHubComment(body); + if (delivery.commentSurface === "review") { + // Must target the top-level review comment; nested reply ids 422. + const inReplyToCommentId = + delivery.replyToCommentId > 0 ? delivery.replyToCommentId : delivery.sourceCommentId; + const response = yield* github.createReviewCommentReply({ + installationId: delivery.installationId, + repository: delivery.repository, + pullRequestNumber: delivery.pullRequestNumber, + inReplyToCommentId, + body: formatted, + }); + return response.id; + } + const response = yield* github.createComment({ + installationId: delivery.installationId, + repository: delivery.repository, + pullRequestNumber: delivery.pullRequestNumber, + body: formatted, + }); + return response.id; + }); + + const removeAcknowledgment = (delivery: StoredGitHubDelivery) => { + if (delivery.acknowledgmentReactionId === null || delivery.sourceCommentId === 0) { + return Effect.void; + } + if (delivery.commentSurface === "review") { + return github + .deleteReviewCommentReaction({ + installationId: delivery.installationId, + repository: delivery.repository, + commentId: delivery.sourceCommentId, + reactionId: delivery.acknowledgmentReactionId, + }) + .pipe(Effect.asVoid); + } + return github + .deleteCommentReaction({ + installationId: delivery.installationId, + repository: delivery.repository, + commentId: delivery.sourceCommentId, + reactionId: delivery.acknowledgmentReactionId, + }) + .pipe(Effect.asVoid); + }; + + const finishDelivery = Effect.fn("GitHubPrBridge.finishDelivery")(function* ( + delivery: StoredGitHubDelivery, + body: string, + status: "completed" | "rejected", + ) { + const responseCommentId = yield* publishResponse(delivery, body); + yield* removeAcknowledgment(delivery).pipe(Effect.ignore); + yield* updateDelivery(delivery, { + responseCommentId, + acknowledgmentReactionId: null, + status, + }); + }); + + const resolveLinkedThread = Effect.fn("GitHubPrBridge.resolveLinkedThread")(function* ( + invocation: GitHubPrInvocation, + stackContext: GitHubPullRequestStackContext | null, + ) { + const shell = yield* projection.getShellSnapshot().pipe(Effect.orElseSucceed(() => null)); + if (shell === null) return null; + const expectedUrl = normalizePullRequestUrl(invocation.pullRequestUrl); + const projects = shell.projects.filter((project) => + matchesGitHubRepository(project.repositoryIdentity, invocation.repository), + ); + const projectIds = new Set(projects.map((project) => project.id)); + const candidates = shell.threads.filter( + (thread) => thread.worktreePath !== null && projectIds.has(thread.projectId), + ); + yield* Effect.logInfo("Resolving GitHub PR to a live T3 worktree", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + matchingProjectCount: projects.length, + candidateCount: candidates.length, + stackSource: stackContext?.source ?? null, + stackNumber: stackContext?.stackNumber ?? null, + stackPullRequestNumbers: + stackContext?.pullRequests.map((pullRequest) => pullRequest.number) ?? [], + }); + + const resolvedProjects = yield* Effect.forEach( + projects, + (project) => + gitWorkflow + .resolvePullRequest({ + cwd: project.workspaceRoot, + reference: String(invocation.pullRequestNumber), + }) + .pipe( + Effect.map(({ pullRequest }) => ({ project, pullRequest })), + Effect.catchCause((cause) => + Effect.logWarning("Failed to resolve GitHub PR in matching T3 project", { + projectId: project.id, + workspaceRoot: project.workspaceRoot, + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + cause, + }).pipe(Effect.as(null)), + ), + ), + { concurrency: 2 }, + ); + const pullRequestsByProjectId = new Map( + resolvedProjects.flatMap((resolved) => { + if ( + resolved === null || + resolved.pullRequest.number !== invocation.pullRequestNumber || + normalizePullRequestUrl(resolved.pullRequest.url) !== expectedUrl + ) { + return []; + } + return [[resolved.project.id, resolved.pullRequest] as const]; + }), + ); + const matches = yield* Effect.forEach( + candidates, + (thread) => + Effect.gen(function* () { + const pullRequest = pullRequestsByProjectId.get(thread.projectId); + if (!pullRequest) return null; + const cwd = thread.worktreePath!; + // The projection's branch can lag behind a branch switch. Resolve from the live + // worktree so a newly checked-out PR is linkable immediately. + const local = yield* gitWorkflow.localStatus({ cwd }); + const liveRef = liveWorktreeRef(thread, local); + if (liveRef === null) { + yield* Effect.logDebug("Skipping GitHub PR link candidate without a live branch", { + threadId: thread.id, + worktreePath: cwd, + projectedBranch: thread.branch, + isRepository: local.isRepo, + liveRefName: local.refName, + }); + return null; + } + const matchBranches = + stackContext === null + ? [pullRequest.headBranch] + : stackBranchesForMatching(stackContext, invocation.pullRequestNumber); + const matchPriority = matchBranches.indexOf(liveRef.refName); + const matchesInvocation = matchPriority >= 0; + yield* Effect.logDebug("Resolved GitHub PR link candidate", { + threadId: thread.id, + worktreePath: liveRef.cwd, + projectedBranch: thread.branch, + liveRefName: liveRef.refName, + resolvedPullRequestNumber: pullRequest.number, + resolvedPullRequestHeadBranch: pullRequest.headBranch, + matchPriority, + matchesInvocation, + }); + return matchesInvocation ? { thread, matchPriority } : null; + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to resolve GitHub PR link candidate", { + threadId: thread.id, + worktreePath: thread.worktreePath, + projectedBranch: thread.branch, + cause, + }).pipe(Effect.as(null)), + ), + ), + { concurrency: 4 }, + ); + const linked = matches.filter( + ( + match, + ): match is { readonly thread: OrchestrationThreadShell; readonly matchPriority: number } => + match !== null, + ); + const exact = linked.filter((match) => match.matchPriority === 0); + const selected = + exact.length === 1 ? exact[0]!.thread : linked.length === 1 ? linked[0]!.thread : null; + yield* Effect.logInfo("Finished resolving GitHub PR to a live T3 worktree", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + matchingProjectCount: projects.length, + candidateCount: candidates.length, + matchCount: linked.length, + matchedThreadIds: linked.map((match) => match.thread.id), + selectedThreadId: selected?.id ?? null, + }); + return selected; + }); + + const createThreadOnWorktree = Effect.fn("GitHubPrBridge.createThreadOnWorktree")( + function* (input: { + readonly invocation: GitHubPrInvocation; + readonly projectId: OrchestrationThreadShell["projectId"]; + readonly projectCwd: string; + readonly branch: string; + readonly worktreePath: string; + readonly modelSelection: ModelSelection; + readonly threadMode: GitHubThreadMode; + readonly runSetup: boolean; + }) { + const threadId = ThreadId.make(yield* crypto.randomUUIDv4); + const createdAt = DateTime.formatIso(yield* DateTime.now); + const title = githubCommentThreadTitle(input.invocation, input.threadMode); + yield* Effect.logInfo("Creating T3 thread for GitHub PR comment", { + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + projectId: input.projectId, + threadId, + worktreePath: input.worktreePath, + branch: input.branch, + threadMode: input.threadMode, + runSetup: input.runSetup, + }); + yield* engine.dispatch({ + type: "thread.create", + commandId: CommandId.make(yield* crypto.randomUUIDv4), + threadId, + projectId: input.projectId, + title, + modelSelection: input.modelSelection, + runtimeMode: "full-access", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + branch: input.branch, + worktreePath: input.worktreePath, + createdAt, + }); + if (input.runSetup) { + yield* projectSetupScriptRunner + .runForThread({ + threadId, + projectId: input.projectId, + projectCwd: input.projectCwd, + worktreePath: input.worktreePath, + }) + .pipe( + Effect.catch((cause) => + Effect.logWarning("GitHub-provisioned T3 thread setup script failed", { + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + projectId: input.projectId, + threadId, + worktreePath: input.worktreePath, + cause, + }), + ), + ); + } + return provisioned({ + id: threadId, + projectId: input.projectId, + title, + modelSelection: input.modelSelection, + runtimeMode: "full-access" as const, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + branch: input.branch, + worktreePath: input.worktreePath, + pullRequests: [], + latestTurn: null, + createdAt, + updatedAt: createdAt, + archivedAt: null, + settledAt: null, + settledOverride: null, + session: null, + latestUserMessageAt: null, + hasPendingApprovals: false, + hasPendingUserInput: false, + hasActionableProposedPlan: false, + } satisfies OrchestrationThreadShell); + }, + ); + + type PreparedWorktree = + | ProvisionOutcome + | { + readonly _tag: "worktree"; + readonly projectId: OrchestrationThreadShell["projectId"]; + readonly projectCwd: string; + readonly branch: string; + readonly worktreePath: string; + }; + + const preparePullRequestWorktree = Effect.fn("GitHubPrBridge.preparePullRequestWorktree")( + function* (invocation: GitHubPrInvocation) { + const shell = yield* projection.getShellSnapshot(); + const projects = shell.projects.filter((project) => + matchesGitHubRepository(project.repositoryIdentity, invocation.repository), + ); + if (projects.length !== 1) { + yield* Effect.logWarning("Cannot provision GitHub PR without a unique T3 project", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + matchingProjectCount: projects.length, + matchingProjectIds: projects.map((project) => project.id), + }); + return provisionFailed( + projects.length === 0 + ? PROVISION_NO_PROJECT_RESPONSE + : PROVISION_AMBIGUOUS_PROJECT_RESPONSE, + ) satisfies PreparedWorktree; + } + + const project = projects[0]!; + yield* Effect.logInfo("Preparing T3 worktree for GitHub PR", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + projectId: project.id, + workspaceRoot: project.workspaceRoot, + }); + // preparePullRequestThread shells out to `gh` for PR metadata. Transient App + // installation-token 401s are retried inside the guest `gh-app-wrapper` + // (remint --no-cache after a short delay) so every gh caller benefits—not + // only this bridge. Follow-ups: resolve PR via GitHubAppClient, surface real + // provision errors on the PR comment, always pass `-R owner/repo`. + const prepared = yield* gitWorkflow.preparePullRequestThread({ + cwd: project.workspaceRoot, + reference: String(invocation.pullRequestNumber), + mode: "worktree", + }); + if (prepared.worktreePath === null) { + yield* Effect.logWarning("GitHub PR provisioning did not create a worktree", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + projectId: project.id, + branch: prepared.branch, + }); + return provisionFailed(PROVISION_WORKTREE_FAILED_RESPONSE) satisfies PreparedWorktree; + } + return { + _tag: "worktree" as const, + projectId: project.id, + projectCwd: project.workspaceRoot, + branch: prepared.branch, + worktreePath: prepared.worktreePath, + } satisfies PreparedWorktree; + }, + ); + + const resolveAssignedReviewThread = Effect.fn("GitHubPrBridge.resolveAssignedReviewThread")( + function* (invocation: GitHubPrInvocation) { + if (invocation.commentSurface !== "review") return null; + const rootCommentId = + invocation.replyToCommentId > 0 ? invocation.replyToCommentId : invocation.commentId; + const assignment = yield* deliveries.findLatestReviewThreadAssignment({ + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + reviewRootCommentId: rootCommentId, + }); + if (assignment?.threadId === null || assignment === null) return null; + const threadId = assignment.threadId as ThreadId; + const detail = yield* projection + .getThreadShellById(threadId) + .pipe(Effect.orElseSucceed(() => Option.none())); + if (Option.isNone(detail)) { + yield* Effect.logInfo("Review discussion T3 thread no longer exists; will create sibling", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + reviewRootCommentId: rootCommentId, + threadId, + }); + return null; + } + yield* Effect.logInfo("Reusing T3 thread assigned to GitHub review discussion", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + reviewRootCommentId: rootCommentId, + threadId, + priorDeliveryId: assignment.deliveryId, + }); + return detail.value; + }, + ); + + /** + * Join a thread already associated via ThreadWorkItemStore (PR URL or Jira keys from + * PR title / mention comment). Prefer store join so Jira-first / Discord-first sessions continue. + */ + const resolveThreadFromWorkItemStore = Effect.fn("GitHubPrBridge.resolveThreadFromWorkItemStore")( + function* (invocation: GitHubPrInvocation) { + const loadShell = (threadId: ThreadId) => + projection.getThreadShellById(threadId).pipe(Effect.orElseSucceed(() => Option.none())); + + const byPr = yield* workItems.resolveGitHubPullRequest(invocation.pullRequestUrl); + if (byPr._tag === "linked") { + const shell = yield* loadShell(byPr.threadId); + if (Option.isSome(shell) && shell.value.archivedAt === null) { + yield* Effect.logInfo("Joined T3 thread via work-item store PR association", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + threadId: byPr.threadId, + }); + return shell.value; + } + } + + const jiraKeys = extractJiraIssueKeysFromGitHubInvocation(invocation); + const threadIds = new Set(); + for (const key of jiraKeys) { + const hit = yield* workItems.resolveJiraIssue(key); + if (hit._tag === "linked") threadIds.add(hit.threadId); + } + if (threadIds.size === 1) { + const [only] = threadIds; + const shell = yield* loadShell(only as ThreadId); + if (Option.isSome(shell) && shell.value.archivedAt === null) { + yield* Effect.logInfo("Joined T3 thread via work-item store Jira key from PR/comment", { + repository: invocation.repository, + pullRequestNumber: invocation.pullRequestNumber, + threadId: only, + jiraKeys, + }); + return shell.value; + } + } + return null; + }, + ); + + /** + * Resolve where the GitHub turn runs: + * - `main`: reuse store-linked or unique live PR/Discord work thread, or provision one + * - `sibling`: for inline review, reuse the T3 thread already bound to that GH discussion + * (first mention creates it); create a new thread when forced or unbound + * + * Defaults: conversation → main; inline review → sibling (with discussion affinity). + */ + const resolveOrProvisionThread = Effect.fn("GitHubPrBridge.resolveOrProvisionThread")(function* ( + invocation: GitHubPrInvocation, + requestedModelSelection: ModelSelection, + stackContext: GitHubPullRequestStackContext | null, + threadMode: GitHubThreadMode, + forceNewSibling: boolean, + ) { + const fromStore = yield* resolveThreadFromWorkItemStore(invocation); + if (fromStore !== null && threadMode === "main") { + return provisioned(fromStore); + } + + const linked = yield* resolveLinkedThread(invocation, stackContext); + + if (threadMode === "main") { + if (linked !== null) return provisioned(linked); + + return yield* provisionLock.withPermit( + Effect.gen(function* () { + const rechecked = yield* resolveLinkedThread(invocation, stackContext); + if (rechecked !== null) return provisioned(rechecked); + + const prepared = yield* preparePullRequestWorktree(invocation); + if (prepared._tag !== "worktree") return prepared; + return yield* createThreadOnWorktree({ + invocation, + projectId: prepared.projectId, + projectCwd: prepared.projectCwd, + branch: prepared.branch, + worktreePath: prepared.worktreePath, + modelSelection: requestedModelSelection, + threadMode: "main", + runSetup: true, + }); + }), + ); + } + + // Sibling: continue an existing assignment for this GH review discussion unless forced new. + if (!forceNewSibling && invocation.commentSurface === "review") { + const assigned = yield* resolveAssignedReviewThread(invocation); + if (assigned !== null) return provisioned(assigned); + } + + // Create a new sibling session on the PR worktree. + if (linked !== null && linked.worktreePath !== null) { + const branch = linked.branch ?? "HEAD"; + const shell = yield* projection.getShellSnapshot().pipe(Effect.orElseSucceed(() => null)); + const project = shell?.projects.find((candidate) => candidate.id === linked.projectId); + return yield* createThreadOnWorktree({ + invocation, + projectId: linked.projectId, + projectCwd: project?.workspaceRoot ?? linked.worktreePath, + branch, + worktreePath: linked.worktreePath, + modelSelection: requestedModelSelection, + threadMode: "sibling", + runSetup: false, + }); + } + + return yield* provisionLock.withPermit( + Effect.gen(function* () { + const rechecked = yield* resolveLinkedThread(invocation, stackContext); + if (rechecked !== null && rechecked.worktreePath !== null) { + const shell = yield* projection.getShellSnapshot(); + const project = shell.projects.find((candidate) => candidate.id === rechecked.projectId); + return yield* createThreadOnWorktree({ + invocation, + projectId: rechecked.projectId, + projectCwd: project?.workspaceRoot ?? rechecked.worktreePath, + branch: rechecked.branch ?? "HEAD", + worktreePath: rechecked.worktreePath, + modelSelection: requestedModelSelection, + threadMode: "sibling", + runSetup: false, + }); + } + + const prepared = yield* preparePullRequestWorktree(invocation); + if (prepared._tag !== "worktree") return prepared; + return yield* createThreadOnWorktree({ + invocation, + projectId: prepared.projectId, + projectCwd: prepared.projectCwd, + branch: prepared.branch, + worktreePath: prepared.worktreePath, + modelSelection: requestedModelSelection, + threadMode: "sibling", + runSetup: true, + }); + }), + ); + }); + + const resolveGitHubModelSelection = Effect.fn("GitHubPrBridge.resolveModelSelection")(function* ( + invocation: GitHubPrInvocation, + preferredSelection?: ModelSelection, + ) { + const shell = yield* projection.getShellSnapshot(); + const project = shell.projects.find((candidate) => + matchesGitHubRepository(candidate.repositoryIdentity, invocation.repository), + ); + const fallbackSelection = getAutoBootstrapThreadModelSelection(); + const flags = parseProviderModelFlags(invocation.prompt); + return resolveProviderModelSelection({ + providers: yield* providerRegistry.getProviders, + projectDefault: project?.defaultModelSelection ?? null, + preferredSelection: preferredSelection ?? project?.defaultModelSelection ?? fallbackSelection, + fallbackSelection, + ...(flags.provider === undefined ? {} : { overrideInstanceId: flags.provider }), + ...(flags.model === undefined ? {} : { overrideModel: flags.model }), + }); + }); + + const bridgeTurn = Effect.fn("GitHubPrBridge.bridgeTurn")(function* ( + delivery: StoredGitHubDelivery, + ) { + if (delivery.threadId === null) return; + const startedAt = yield* Clock.currentTimeMillis; + let tracked: StoredGitHubDelivery = delivery; + + while ( + (yield* Clock.currentTimeMillis) - startedAt < + (config.enabled ? config.turnTimeoutMs : 0) + ) { + const snapshot = yield* projection + .getThreadDetailById(tracked.threadId!) + .pipe(Effect.orElseSucceed(() => Option.none())); + if (Option.isNone(snapshot)) { + yield* finishDelivery(tracked, FAILED_RESPONSE, "rejected"); + return; + } + const thread = snapshot.value; + const resolveOptions = { + userMessageId: tracked.userMessageId, + previousTurnId: tracked.previousTurnId, + knownTargetTurnId: tracked.targetTurnId, + }; + const discoveredTurnId = discoverGitHubTargetTurnId(thread, resolveOptions); + if (discoveredTurnId !== null && discoveredTurnId !== tracked.targetTurnId) { + tracked = { + ...tracked, + targetTurnId: discoveredTurnId as TurnId, + updatedAt: DateTime.formatIso(yield* DateTime.now), + }; + yield* deliveries.put(tracked); + } + + const outcome = resolveGitHubBridgeTurnOutcome(thread, { + ...resolveOptions, + knownTargetTurnId: tracked.targetTurnId, + }); + if (outcome._tag === "terminal") { + yield* finishDelivery(tracked, outcome.body, outcome.status); + return; + } + + yield* Effect.sleep("1 second"); + } + + yield* finishDelivery( + tracked, + "T3 is still working. Open the linked T3 thread to continue monitoring this turn.", + "completed", + ); + }); + + const handleUnsafe = Effect.fn("GitHubPrBridge.handleUnsafe")(function* (input: { + readonly deliveryId: string; + readonly invocation: GitHubPrInvocation; + }) { + if (!config.enabled) return; + const now = DateTime.formatIso(yield* DateTime.now); + const initial: StoredGitHubDelivery = { + deliveryId: input.deliveryId, + installationId: input.invocation.installationId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + sourceCommentId: input.invocation.commentId, + commentSurface: input.invocation.commentSurface, + replyToCommentId: input.invocation.replyToCommentId, + acknowledgmentReactionId: null, + responseCommentId: null, + threadId: null, + previousTurnId: null, + userMessageId: null, + targetTurnId: null, + status: "received", + createdAt: now, + updatedAt: now, + }; + if (!(yield* deliveries.claim(initial))) return; + + const threadModeParsed = parseGitHubThreadMode(input.invocation.prompt); + const parsedCommand = parseProviderModelFlags(threadModeParsed.prompt); + const threadMode = + threadModeParsed.mode ?? defaultGitHubThreadMode(input.invocation.commentSurface); + // Explicit sibling/new forces a brand-new T3 session even if a review discussion already has one. + const forceNewSibling = threadModeParsed.mode === "sibling"; + + yield* Effect.logInfo("Accepted GitHub PR invocation", { + deliveryId: input.deliveryId, + installationId: input.invocation.installationId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + commentSurface: input.invocation.commentSurface, + threadMode, + forceNewSibling, + reviewRootCommentId: + input.invocation.commentSurface === "review" + ? input.invocation.replyToCommentId > 0 + ? input.invocation.replyToCommentId + : input.invocation.commentId + : null, + actorId: input.invocation.actorId, + actorLogin: input.invocation.actorLogin, + }); + + const repositoryAllowed = isGitHubRepositoryAllowed( + config.allowedRepositories, + input.invocation.repository, + ); + const permission = repositoryAllowed + ? yield* github + .repositoryPermission({ + installationId: input.invocation.installationId, + repository: input.invocation.repository, + actorLogin: input.invocation.actorLogin, + }) + .pipe(Effect.orElseSucceed(() => "")) + : ""; + if (!repositoryAllowed || !hasRequiredGitHubPermission(permission, config.minimumPermission)) { + yield* Effect.logWarning("Rejected unauthorized GitHub PR invocation", { + deliveryId: input.deliveryId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + actorLogin: input.invocation.actorLogin, + repositoryAllowed, + actualPermission: permission || null, + minimumPermission: config.minimumPermission, + }); + yield* updateDelivery(initial, { status: "rejected" }); + return; + } + + // Closed-set identity map is required for agent turns (fail-closed when the + // map is off/empty). Public-repo write / outside collaborators cannot drive + // the host unless listed; permission floor alone is never enough. + const mapEnabled = yield* identity.isMapEnabled(); + const mapPeople = yield* identity.listMapPeople(); + const trust = classifyGitHubActorTrust({ + identityMapEnabled: mapEnabled, + actorId: input.invocation.actorId, + actorLogin: input.invocation.actorLogin, + people: mapPeople, + }); + if (trust.mode === "denied") { + yield* Effect.logWarning("Rejected GitHub PR invocation from unmapped identity", { + deliveryId: input.deliveryId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + actorId: input.invocation.actorId, + actorLogin: input.invocation.actorLogin, + reason: trust.reason, + }); + yield* finishDelivery(initial, IDENTITY_DENIED_RESPONSE, "rejected"); + return; + } + yield* Effect.logInfo("Classified GitHub actor trust", { + deliveryId: input.deliveryId, + actorLogin: input.invocation.actorLogin, + actorId: input.invocation.actorId, + mode: trust.mode, + reason: trust.reason, + personId: trust.person?.personId ?? null, + }); + + const addAckReaction = + input.invocation.commentSurface === "review" + ? github.addReviewCommentReaction({ + installationId: input.invocation.installationId, + repository: input.invocation.repository, + commentId: input.invocation.commentId, + content: "eyes", + }) + : github.addCommentReaction({ + installationId: input.invocation.installationId, + repository: input.invocation.repository, + commentId: input.invocation.commentId, + content: "eyes", + }); + const acknowledgmentReactionId = yield* addAckReaction.pipe( + Effect.tapError((cause) => + Effect.logWarning("Failed to add GitHub PR acknowledgment reaction", { + deliveryId: input.deliveryId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + commentId: input.invocation.commentId, + commentSurface: input.invocation.commentSurface, + cause, + }), + ), + Effect.orElseSucceed(() => null), + ); + const acknowledged: StoredGitHubDelivery = { + ...initial, + acknowledgmentReactionId, + updatedAt: DateTime.formatIso(yield* DateTime.now), + }; + yield* deliveries.put(acknowledged); + + if (parsedCommand.prompt.trim().length === 0) { + yield* finishDelivery(acknowledged, EMPTY_PROMPT_RESPONSE, "rejected"); + return; + } + + const turnInvocation = { + ...input.invocation, + prompt: parsedCommand.prompt, + }; + const initialModelSelection = yield* resolveGitHubModelSelection(turnInvocation); + + const stackContext = yield* github + .pullRequestStack({ + installationId: input.invocation.installationId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + }) + .pipe( + Effect.tap((context) => + Effect.logInfo("Resolved GitHub PR stack context", { + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + source: context.source, + stackNumber: context.stackNumber, + stackBaseBranch: context.baseBranch, + stackPullRequestNumbers: context.pullRequests.map((pullRequest) => pullRequest.number), + }), + ), + Effect.catchCause((cause) => + Effect.logWarning("Failed to resolve GitHub PR stack context; using exact PR matching", { + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + cause, + }).pipe(Effect.as(null)), + ), + ); + + const outcome = yield* resolveOrProvisionThread( + turnInvocation, + initialModelSelection, + stackContext, + threadMode, + forceNewSibling, + ).pipe( + Effect.catchCause((cause) => + Effect.logError("Failed to resolve or provision GitHub PR thread", { + deliveryId: input.deliveryId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + threadMode, + forceNewSibling, + cause: Cause.pretty(cause), + }).pipe(Effect.as(provisionFailed(PROVISION_FAILED_RESPONSE))), + ), + ); + if (outcome._tag === "failed") { + yield* finishDelivery(acknowledged, outcome.response, "rejected"); + return; + } + const thread = outcome.thread; + + // Durable PR ↔ thread association (+ Jira keys from title and mention comment). + const jiraIssueKeys = extractJiraIssueKeysFromGitHubInvocation(input.invocation); + yield* workItems + .appendForThread({ + threadId: thread.id, + githubPullRequests: [input.invocation.pullRequestUrl], + ...(jiraIssueKeys.length > 0 ? { jiraIssueKeys } : {}), + source: "github-webhook", + }) + .pipe(Effect.ignore); + + if (isThreadBusy(thread)) { + yield* Effect.logInfo("GitHub PR invocation matched a busy T3 thread", { + deliveryId: input.deliveryId, + threadId: thread.id, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + }); + yield* finishDelivery({ ...acknowledged, threadId: thread.id }, BUSY_RESPONSE, "completed"); + return; + } + + const commandId = CommandId.make(yield* crypto.randomUUIDv4); + const messageId = MessageId.make(yield* crypto.randomUUIDv4); + const processing: StoredGitHubDelivery = { + ...acknowledged, + threadId: thread.id, + previousTurnId: thread.latestTurn?.turnId ?? null, + userMessageId: messageId, + targetTurnId: null, + status: "processing", + updatedAt: DateTime.formatIso(yield* DateTime.now), + }; + yield* deliveries.put(processing); + + yield* Effect.logInfo("Dispatching GitHub PR invocation to T3 thread", { + deliveryId: input.deliveryId, + threadId: thread.id, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + liveWorktreePath: thread.worktreePath, + projectedBranch: thread.branch, + userMessageId: messageId, + }); + + const hasExplicitModelSelection = + parsedCommand.provider !== undefined || parsedCommand.model !== undefined; + const turnModelSelection = hasExplicitModelSelection + ? yield* resolveGitHubModelSelection(turnInvocation, thread.modelSelection) + : thread.modelSelection; + const sourcePeople = yield* identity.listMapPeople(); + const [repoOwner, repoName] = turnInvocation.repository.split("/"); + const source = buildIntegrationSourceRef({ + people: sourcePeople, + channel: "github", + platformId: String(turnInvocation.actorId), + displayName: turnInvocation.actorLogin, + location: { + owner: repoOwner ?? turnInvocation.repository, + repo: repoName ?? turnInvocation.repository, + number: turnInvocation.pullRequestNumber, + kind: "pr", + }, + }); + const dispatched = yield* engine + .dispatch({ + type: "thread.turn.start", + commandId, + threadId: thread.id, + message: { + messageId, + role: "user", + text: buildGitHubTurnPrompt(turnInvocation, { + discordLinkRequested: parsedCommand.discord, + stackContext, + threadMode, + }), + attachments: [], + }, + modelSelection: turnModelSelection, + titleSeed: turnInvocation.prompt.slice(0, 80) || "GitHub PR comment", + runtimeMode: thread.runtimeMode, + interactionMode: thread.interactionMode, + source, + createdAt: DateTime.formatIso(yield* DateTime.now), + }) + .pipe( + Effect.as(true), + Effect.catch((cause) => + finishDelivery(processing, FAILED_RESPONSE, "rejected").pipe( + Effect.andThen(Effect.logError("Failed to dispatch GitHub PR turn", { cause })), + Effect.as(false), + ), + ), + ); + if (!dispatched) return; + yield* Effect.forkDetach( + bridgeTurn(processing).pipe( + Effect.catchCause((cause) => + finishDelivery(processing, FAILED_RESPONSE, "rejected").pipe( + Effect.ignore, + Effect.andThen( + Effect.logError("GitHub PR response bridge stopped", { + deliveryId: processing.deliveryId, + threadId: processing.threadId, + cause, + }), + ), + ), + ), + ), + ); + }); + + const handle = (input: { + readonly deliveryId: string; + readonly invocation: GitHubPrInvocation; + }) => + handleUnsafe(input).pipe( + Effect.catchCause((cause) => + deliveries.get(input.deliveryId).pipe( + Effect.flatMap((delivery) => + delivery?.acknowledgmentReactionId + ? finishDelivery(delivery, FAILED_RESPONSE, "rejected").pipe(Effect.ignore) + : Effect.void, + ), + Effect.andThen( + Effect.logError("GitHub PR invocation failed", { + deliveryId: input.deliveryId, + repository: input.invocation.repository, + pullRequestNumber: input.invocation.pullRequestNumber, + cause, + }), + ), + ), + ), + ); + + const restore = deliveries.listProcessing().pipe( + Effect.flatMap((pending) => + Effect.forEach(pending, (delivery) => Effect.forkDetach(bridgeTurn(delivery)), { + concurrency: 4, + discard: true, + }), + ), + ); + if (config.enabled) yield* restore; + + return GitHubPrBridge.of({ + handle, + restore, + }); +}); + +export const layer = Layer.effect(GitHubPrBridge, make); diff --git a/apps/server/src/github/GitHubPullRequestStack.test.ts b/apps/server/src/github/GitHubPullRequestStack.test.ts new file mode 100644 index 000000000000..8dd8e089a90d --- /dev/null +++ b/apps/server/src/github/GitHubPullRequestStack.test.ts @@ -0,0 +1,61 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { inferPullRequestStack, stackBranchesForMatching } from "./GitHubPullRequestStack.ts"; + +const pullRequest = (number: number, headBranch: string, baseBranch: string) => ({ + number, + headBranch, + headSha: `sha-${number}`, + baseBranch, +}); + +describe("GitHub pull request stack inference", () => { + it("infers the ordered parent and child chain around the requested PR", () => { + const context = inferPullRequestStack({ + target: pullRequest(12, "feature-api", "feature-core"), + openPullRequests: [ + pullRequest(13, "feature-ui", "feature-api"), + pullRequest(12, "feature-api", "feature-core"), + pullRequest(11, "feature-core", "main"), + pullRequest(99, "unrelated", "main"), + ], + }); + + expect(context.source).toBe("inferred"); + expect(context.baseBranch).toBe("main"); + expect(context.pullRequests.map(({ number }) => number)).toEqual([11, 12, 13]); + expect(stackBranchesForMatching(context, 12)).toEqual([ + "feature-api", + "feature-core", + "feature-ui", + ]); + }); + + it("stops at ambiguous branches instead of joining unrelated PRs", () => { + const context = inferPullRequestStack({ + target: pullRequest(11, "feature-core", "main"), + openPullRequests: [ + pullRequest(11, "feature-core", "main"), + pullRequest(12, "feature-api", "feature-core"), + pullRequest(13, "feature-ui", "feature-core"), + ], + }); + + expect(context.source).toBe("exact"); + expect(context.pullRequests.map(({ number }) => number)).toEqual([11]); + }); + + it("falls back to exact context when no chain exists", () => { + const context = inferPullRequestStack({ + target: pullRequest(42, "feature", "main"), + openPullRequests: [pullRequest(42, "feature", "main")], + }); + + expect(context).toMatchObject({ + source: "exact", + stackNumber: null, + baseBranch: "main", + }); + expect(context.pullRequests.map(({ number }) => number)).toEqual([42]); + }); +}); diff --git a/apps/server/src/github/GitHubPullRequestStack.ts b/apps/server/src/github/GitHubPullRequestStack.ts new file mode 100644 index 000000000000..b77ae8c66d39 --- /dev/null +++ b/apps/server/src/github/GitHubPullRequestStack.ts @@ -0,0 +1,72 @@ +export interface GitHubStackPullRequest { + readonly number: number; + readonly headBranch: string; + readonly headSha: string; + readonly baseBranch?: string; +} + +export interface GitHubPullRequestStackContext { + readonly source: "github" | "inferred" | "exact"; + readonly stackNumber: number | null; + readonly baseBranch: string; + readonly pullRequests: ReadonlyArray; +} + +export function inferPullRequestStack(input: { + readonly target: GitHubStackPullRequest & { readonly baseBranch: string }; + readonly openPullRequests: ReadonlyArray< + GitHubStackPullRequest & { readonly baseBranch: string } + >; +}): GitHubPullRequestStackContext { + const byNumber = new Map( + input.openPullRequests.map((pullRequest) => [pullRequest.number, pullRequest]), + ); + byNumber.set(input.target.number, input.target); + const pullRequests = [...byNumber.values()]; + const stack = [input.target]; + const used = new Set([input.target.number]); + + let bottom = input.target; + while (true) { + const parents = pullRequests.filter( + (candidate) => !used.has(candidate.number) && candidate.headBranch === bottom.baseBranch, + ); + if (parents.length !== 1) break; + bottom = parents[0]!; + used.add(bottom.number); + stack.unshift(bottom); + } + + let top = input.target; + while (true) { + const children = pullRequests.filter( + (candidate) => !used.has(candidate.number) && candidate.baseBranch === top.headBranch, + ); + if (children.length !== 1) break; + top = children[0]!; + used.add(top.number); + stack.push(top); + } + + return { + source: stack.length > 1 ? "inferred" : "exact", + stackNumber: null, + baseBranch: stack[0]!.baseBranch, + pullRequests: stack, + }; +} + +export function stackBranchesForMatching( + context: GitHubPullRequestStackContext, + requestedPullRequestNumber: number, +): ReadonlyArray { + const requested = context.pullRequests.find( + (pullRequest) => pullRequest.number === requestedPullRequestNumber, + ); + return [ + ...(requested === undefined ? [] : [requested.headBranch]), + ...context.pullRequests + .filter((pullRequest) => pullRequest.number !== requestedPullRequestNumber) + .map((pullRequest) => pullRequest.headBranch), + ]; +} diff --git a/apps/server/src/github/GitHubWebhook.test.ts b/apps/server/src/github/GitHubWebhook.test.ts new file mode 100644 index 000000000000..065720331855 --- /dev/null +++ b/apps/server/src/github/GitHubWebhook.test.ts @@ -0,0 +1,863 @@ +import * as NodeBuffer from "node:buffer"; +import * as NodeCrypto from "node:crypto"; +import { describe, expect, it } from "@effect/vitest"; + +import { + buildGitHubTurnPrompt, + discoverGitHubTargetTurnId, + extractJiraIssueKeysFromGitHubInvocation, + githubFinalAnswerText, + githubFinalAnswerWithStats, + hasRequiredGitHubPermission, + isGitHubRepositoryAllowed, + liveWorktreeRef, + matchesGitHubRepository, + resolveGitHubBridgeTurnOutcome, +} from "./GitHubPrBridge.ts"; +import { + defaultGitHubThreadMode, + type GitHubIssueCommentWebhook, + type GitHubPullRequestReviewCommentWebhook, + parseGitHubPrInvocation, + parseGitHubReviewCommentInvocation, + parseGitHubThreadMode, +} from "./GitHubWebhookPayload.ts"; +import { createGitHubAppJwt, verifyGitHubWebhookSignature } from "./GitHubWebhookSecurity.ts"; + +function webhook(body = "@t3-code investigate the failing check"): GitHubIssueCommentWebhook { + return { + action: "created", + installation: { id: 11 }, + repository: { + id: 22, + full_name: "acme/widgets", + html_url: "https://github.com/acme/widgets", + }, + issue: { + number: 42, + title: "Fix widgets", + html_url: "https://github.com/acme/widgets/pull/42", + pull_request: {}, + }, + comment: { + id: 33, + body, + html_url: "https://github.com/acme/widgets/pull/42#issuecomment-33", + user: { id: 44, login: "octocat", type: "User" }, + }, + sender: { id: 44, login: "octocat", type: "User" }, + }; +} + +function reviewCommentWebhook( + body = "@t3-code please fix this null check", +): GitHubPullRequestReviewCommentWebhook { + return { + action: "created", + installation: { id: 11 }, + repository: { + id: 22, + full_name: "acme/widgets", + html_url: "https://github.com/acme/widgets", + }, + pull_request: { + number: 42, + title: "Fix widgets", + html_url: "https://github.com/acme/widgets/pull/42", + }, + comment: { + id: 3_628_634_093, + body, + html_url: "https://github.com/acme/widgets/pull/42#discussion_r3628634093", + path: "src/widget.ts", + line: 88, + original_line: 88, + side: "RIGHT", + diff_hunk: + "@@ -80,6 +80,10 @@ export function load() {\n+ const value = maybeNull()\n+ return value.name", + commit_id: "abc123def456", + user: { id: 44, login: "octocat", type: "User" }, + }, + sender: { id: 44, login: "octocat", type: "User" }, + }; +} + +describe("GitHub PR webhook", () => { + it("verifies the raw webhook body signature", () => { + const secret = "development-secret"; + const body = JSON.stringify(webhook()); + const signature = `sha256=${NodeCrypto.createHmac("sha256", secret).update(body).digest("hex")}`; + + expect(verifyGitHubWebhookSignature({ secret, body, signature })).toBe(true); + expect(verifyGitHubWebhookSignature({ secret, body: `${body} `, signature })).toBe(false); + expect(verifyGitHubWebhookSignature({ secret, body, signature: "sha256=bad" })).toBe(false); + }); + + it("extracts Jira keys from PR title and mention comment", () => { + expect( + extractJiraIssueKeysFromGitHubInvocation({ + pullRequestTitle: "Fix widgets for SA-401", + prompt: "also see CFG-12 please", + }), + ).toEqual(["SA-401", "CFG-12"]); + expect( + extractJiraIssueKeysFromGitHubInvocation({ + pullRequestTitle: "no keys here", + prompt: "look at SA-414", + }), + ).toEqual(["SA-414"]); + }); + + it("parses an explicit PR invocation and preserves requester provenance", () => { + const invocation = parseGitHubPrInvocation(webhook(), "t3-code"); + + expect(invocation).toEqual({ + installationId: 11, + repositoryId: 22, + repository: "acme/widgets", + pullRequestNumber: 42, + pullRequestTitle: "Fix widgets", + pullRequestUrl: "https://github.com/acme/widgets/pull/42", + commentId: 33, + commentUrl: "https://github.com/acme/widgets/pull/42#issuecomment-33", + replyToCommentId: 33, + commentSurface: "issue", + actorId: 44, + actorLogin: "octocat", + prompt: "investigate the failing check", + reviewContext: null, + }); + const prompt = buildGitHubTurnPrompt(invocation!); + expect(prompt.startsWith("", + "", + isUpdate + ? [ + "The Jira user **edited** an earlier comment that addresses the bot. Treat the updated prompt as authoritative and discard work that only applied to a previous version of this comment.", + "", + `Updated prompt from Jira [${requester}] on [${invocation.issueKey}]${invocation.commentUrl ? `(${invocation.commentUrl})` : ""}: ${invocation.prompt}`, + ].join("\n") + : `From Jira [${requester}] on [${invocation.issueKey}]${invocation.commentUrl ? `(${invocation.commentUrl})` : ""}: ${invocation.prompt}`, + ].filter((line): line is string => line !== null); + return lines.join("\n"); +} + +/** + * Stable delivery id: creates dedupe on comment id; updates include updated-at / prompt + * so redeliveries of the same edit collapse but new edits re-run. + */ +export function jiraDeliveryIdFor(input: { + readonly invocation: JiraIssueInvocation; + readonly headerDeliveryId?: string | undefined; +}): string { + if (input.headerDeliveryId && input.headerDeliveryId.trim().length > 0) { + return input.headerDeliveryId.trim(); + } + const { invocation } = input; + if (invocation.webhookEvent === "comment_updated") { + const stamp = + invocation.commentUpdatedAt?.replace(/[^0-9A-Za-z._-]/gu, "") || + // Fall back to a short hash of the prompt so body-only edits without `updated` still re-run. + simplePromptFingerprint(invocation.prompt); + return `jira-comment-updated:${invocation.issueKey}:${invocation.commentId}:${stamp}`; + } + return `jira-comment:${invocation.issueKey}:${invocation.commentId}`; +} + +function simplePromptFingerprint(prompt: string): string { + // FNV-1a 32-bit — stable, no crypto dependency, good enough for delivery keys. + let hash = 0x811c9dc5; + const normalized = prompt.replace(/\s+/gu, " ").trim(); + for (let i = 0; i < normalized.length; i += 1) { + hash ^= normalized.charCodeAt(i); + hash = Math.imul(hash, 0x01000193); + } + return (hash >>> 0).toString(16).padStart(8, "0"); +} + +export type JiraAdfMention = { + readonly accountId: string; + readonly displayName?: string | null | undefined; +}; + +type AdfInlineNode = + | { readonly type: "text"; readonly text: string } + | { + readonly type: "mention"; + readonly attrs: { + readonly id: string; + readonly text: string; + readonly accessLevel: string; + }; + }; + +type AdfParagraph = { + readonly type: "paragraph"; + readonly content: ReadonlyArray; +}; + +export type JiraAdfDocument = { + readonly type: "doc"; + readonly version: 1; + readonly content: ReadonlyArray; +}; + +/** + * Normalize a Jira Cloud account id for an ADF **mention** node `attrs.id`. + * + * Live GET `/rest/api/3/issue/{key}/comment` returns bare Atlassian account ids + * (e.g. `6331c32307a27ebeff15d19d` or `712020:uuid`) — **not** the wiki form + * `accountid:…`. Official ADF docs: attrs.id = “Atlassian Account ID”. + * Strip a leading `accountid:` if present so inbound wiki/Automation forms still work. + */ +export function jiraMentionAccountId(accountId: string): string { + const trimmed = accountId.trim(); + if (trimmed.length === 0) return trimmed; + return trimmed.replace(/^accountid:/iu, ""); +} + +/** + * Minimal ADF document from plain text paragraphs (API v3 comment body). + * Optional leading @mention of the human requester (normal Jira reply style). + * + * Mention shape (matches real comments on this site): + * `{ type: "mention", attrs: { id: "", text: "@Name", accessLevel: "" } }` + */ +export function plainTextToAdf( + text: string, + options?: { readonly mention?: JiraAdfMention | null | undefined }, +): JiraAdfDocument { + const paragraphs = text + .split(/\n{2,}/u) + .map((block) => block.trim()) + .filter((block) => block.length > 0); + const blocks = paragraphs.length > 0 ? paragraphs : [text.trim() || " "]; + const mention = options?.mention; + const accountId = jiraMentionAccountId(mention?.accountId?.trim() ?? ""); + const display = mention?.displayName?.trim().replace(/^@/u, "") || accountId; + const mentionNode: AdfInlineNode | null = + accountId.length > 0 + ? { + type: "mention", + attrs: { + id: accountId, + text: `@${display}`, + accessLevel: "", + }, + } + : null; + + return { + type: "doc", + version: 1, + content: blocks.map((block, index) => { + if (index === 0 && mentionNode !== null) { + return { + type: "paragraph" as const, + content: [mentionNode, { type: "text" as const, text: ` ${block}` }], + }; + } + return { + type: "paragraph" as const, + content: [{ type: "text" as const, text: block }], + }; + }), + }; +} diff --git a/apps/server/src/jira/JiraWebhookSecurity.ts b/apps/server/src/jira/JiraWebhookSecurity.ts new file mode 100644 index 000000000000..cf6c54d2c454 --- /dev/null +++ b/apps/server/src/jira/JiraWebhookSecurity.ts @@ -0,0 +1,66 @@ +import * as NodeCrypto from "node:crypto"; + +/** + * Verify inbound Jira webhook auth. + * + * Jira Cloud classic webhooks do not always sign the body. We accept either: + * - `Authorization: Bearer ` + * - `X-T3-Webhook-Secret: ` + * - Optional `X-Hub-Signature-256: sha256=` when the proxy signs the raw body + */ +export function verifyJiraWebhookSecret(input: { + readonly secret: string; + readonly authorizationHeader: string | undefined; + readonly t3SecretHeader: string | undefined; + readonly body: string; + readonly signatureHeader: string | undefined; +}): boolean { + const expected = input.secret.trim(); + if (expected.length === 0) return false; + + const bearer = parseBearer(input.authorizationHeader); + if (bearer !== null && timingSafeEqualString(bearer, expected)) return true; + + const headerSecret = input.t3SecretHeader?.trim(); + if (headerSecret !== undefined && headerSecret.length > 0) { + if (timingSafeEqualString(headerSecret, expected)) return true; + } + + if (input.signatureHeader) { + return verifySha256Signature({ + secret: expected, + body: input.body, + signature: input.signatureHeader, + }); + } + + return false; +} + +function parseBearer(authorization: string | undefined): string | null { + if (!authorization) return null; + const match = /^Bearer\s+(\S+)\s*$/iu.exec(authorization.trim()); + return match?.[1] ?? null; +} + +function verifySha256Signature(input: { + readonly secret: string; + readonly body: string; + readonly signature: string; +}): boolean { + if (!/^sha256=[0-9a-f]{64}$/iu.test(input.signature)) return false; + const received = Buffer.from(input.signature.slice("sha256=".length), "hex"); + const expected = NodeCrypto.createHmac("sha256", input.secret).update(input.body).digest(); + return received.length === expected.length && NodeCrypto.timingSafeEqual(received, expected); +} + +function timingSafeEqualString(left: string, right: string): boolean { + const a = Buffer.from(left); + const b = Buffer.from(right); + if (a.length !== b.length) { + // Still perform a compare to reduce trivial timing oracles on length alone for short secrets. + NodeCrypto.timingSafeEqual(Buffer.alloc(a.length), Buffer.alloc(a.length)); + return false; + } + return NodeCrypto.timingSafeEqual(a, b); +} diff --git a/apps/server/src/jira/http.ts b/apps/server/src/jira/http.ts new file mode 100644 index 000000000000..6a297758fe3e --- /dev/null +++ b/apps/server/src/jira/http.ts @@ -0,0 +1,205 @@ +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; +import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"; + +import { + classifyWebhookBodyFailure, + previewWebhookBody, + WebhookDebugLog, + type WebhookDebugAppendInput, +} from "../webhooks/WebhookDebugLog.ts"; +import { JiraAppConfig, isJiraProjectAllowed } from "./JiraAppConfig.ts"; +import { JiraIssueBridge } from "./JiraIssueBridge.ts"; +import { + isAcceptedJiraCommentEvent, + jiraDeliveryIdFor, + JiraCommentWebhook, + parseJiraCommentInvocation, + type JiraIssueInvocation, +} from "./JiraWebhookPayload.ts"; +import { verifyJiraWebhookSecret } from "./JiraWebhookSecurity.ts"; + +export const JIRA_WEBHOOK_PATH = "/api/jira/webhook"; +const MAX_WEBHOOK_BODY_BYTES = 1_024 * 1_024; +const decodeCommentWebhook = Schema.decodeUnknownSync(Schema.fromJsonString(JiraCommentWebhook)); + +type ParsedWebhook = + | { readonly _tag: "invalid"; readonly reason: string } + | { readonly _tag: "ignored"; readonly reason: string } + | { readonly _tag: "invocation"; readonly invocation: JiraIssueInvocation }; + +function parseWebhook(body: string, mention: string, botAccountId: string | null): ParsedWebhook { + const payload = (() => { + try { + return decodeCommentWebhook(body); + } catch { + return null; + } + })(); + if (payload === null) { + const failure = classifyWebhookBodyFailure(body); + return { + _tag: "invalid", + reason: failure.detail ? `${failure.reason}: ${failure.detail}` : failure.reason, + }; + } + + // Accept missing webhookEvent (Automation often omits it). Allow created + updated. + if (!isAcceptedJiraCommentEvent(payload.webhookEvent)) { + return { + _tag: "ignored", + reason: `unsupported_webhook_event=${payload.webhookEvent ?? ""}`, + }; + } + + const invocation = parseJiraCommentInvocation(payload, mention, { botAccountId }); + if (invocation === null) { + return { + _tag: "ignored", + reason: `no_invocation mention=${mention} issue=${payload.issue.key}`, + }; + } + return { _tag: "invocation", invocation }; +} + +export const jiraWebhookRouteLayer = HttpRouter.add( + "POST", + JIRA_WEBHOOK_PATH, + Effect.gen(function* () { + const config = yield* JiraAppConfig; + const debugLog = yield* WebhookDebugLog; + + const logDebug = (input: Omit) => + debugLog.append({ ...input, source: "jira" }).pipe(Effect.ignore, Effect.forkDetach); + + if (!config.enabled) { + yield* logDebug({ + outcome: "disabled_404", + status: 404, + reason: `missing=${config.missing.join(",")}`, + bodyBytes: 0, + }); + return HttpServerResponse.empty({ status: 404 }); + } + + const request = yield* HttpServerRequest.HttpServerRequest; + const body = yield* request.text.pipe(Effect.orElseSucceed(() => "")); + const { bodyBytes, bodyPreview } = previewWebhookBody(body); + + if (bodyBytes > MAX_WEBHOOK_BODY_BYTES) { + yield* logDebug({ + outcome: "too_large_413", + status: 413, + reason: `bodyBytes=${bodyBytes}`, + bodyBytes, + }); + return HttpServerResponse.text("Payload Too Large", { status: 413 }); + } + + if ( + !verifyJiraWebhookSecret({ + secret: config.webhookSecret, + authorizationHeader: request.headers["authorization"], + t3SecretHeader: request.headers["x-t3-webhook-secret"], + body, + signatureHeader: request.headers["x-hub-signature-256"], + }) + ) { + yield* logDebug({ + outcome: "unauthorized_401", + status: 401, + reason: "secret_mismatch", + bodyBytes, + bodyPreview, + mention: config.mention, + }); + return HttpServerResponse.text("Unauthorized", { status: 401 }); + } + + const parsed = parseWebhook(body, config.mention, config.botAccountId); + if (parsed._tag === "invalid") { + yield* Effect.logWarning("Jira webhook invalid payload", { + reason: parsed.reason, + bodyBytes, + }); + yield* logDebug({ + outcome: "invalid_400", + status: 400, + reason: parsed.reason, + bodyBytes, + bodyPreview, + mention: config.mention, + }); + return HttpServerResponse.text("Invalid payload", { status: 400 }); + } + if (parsed._tag === "ignored") { + yield* logDebug({ + outcome: "ignored_202", + status: 202, + reason: parsed.reason, + bodyBytes, + bodyPreview, + mention: config.mention, + }); + return HttpServerResponse.empty({ status: 202 }); + } + + const { invocation } = parsed; + if (!isJiraProjectAllowed(config.allowedProjects, invocation.projectKey)) { + yield* Effect.logWarning("Ignoring Jira webhook from unauthorized project", { + issueKey: invocation.issueKey, + projectKey: invocation.projectKey, + }); + yield* logDebug({ + outcome: "project_denied_202", + status: 202, + reason: `project_not_allowed=${invocation.projectKey}`, + bodyBytes, + issueKey: invocation.issueKey, + projectKey: invocation.projectKey, + webhookEvent: invocation.webhookEvent, + commentId: invocation.commentId, + mention: config.mention, + }); + return HttpServerResponse.empty({ status: 202 }); + } + + const headerDeliveryId = + request.headers["x-atlassian-webhook-identifier"] ?? + request.headers["x-request-id"] ?? + undefined; + const deliveryId = jiraDeliveryIdFor({ invocation, headerDeliveryId }); + + yield* logDebug({ + outcome: "accepted_202", + status: 202, + bodyBytes, + deliveryId, + issueKey: invocation.issueKey, + projectKey: invocation.projectKey, + webhookEvent: invocation.webhookEvent, + commentId: invocation.commentId, + prompt: invocation.prompt.slice(0, 500), + commentText: invocation.commentText.slice(0, 500), + actorDisplayName: invocation.actorDisplayName, + actorAccountId: invocation.actorAccountId, + mention: config.mention, + }); + + const bridge = yield* JiraIssueBridge; + yield* Effect.forkDetach( + bridge.handle({ deliveryId, invocation }).pipe( + Effect.catchCause((cause) => + Effect.logError("Jira webhook delivery failed", { + deliveryId, + issueKey: invocation.issueKey, + commentSurface: invocation.commentSurface, + cause, + }), + ), + ), + ); + + return HttpServerResponse.empty({ status: 202 }); + }), +); diff --git a/apps/server/src/jira/jiraActorTrust.test.ts b/apps/server/src/jira/jiraActorTrust.test.ts new file mode 100644 index 000000000000..e699ac405652 --- /dev/null +++ b/apps/server/src/jira/jiraActorTrust.test.ts @@ -0,0 +1,88 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { + classifyJiraActorTrust, + normalizeJiraAccountId, + resolvePersonByJiraAccountId, +} from "./jiraActorTrust.ts"; + +const people = [ + { + personId: "patroza", + username: "patroza", + name: "Patrick Roza", + jira: { accountId: "712020:abc-trusted" }, + }, + { + personId: "julius", + username: "julius", + jira: { accountId: "accountid:712020:def-other" }, + }, +] as const; + +describe("normalizeJiraAccountId", () => { + it("strips accountid: prefix and lowercases", () => { + expect(normalizeJiraAccountId("accountid:712020:ABC")).toBe("712020:abc"); + expect(normalizeJiraAccountId("712020:ABC")).toBe("712020:abc"); + }); + + it("returns null for empty", () => { + expect(normalizeJiraAccountId(null)).toBeNull(); + expect(normalizeJiraAccountId(" ")).toBeNull(); + }); +}); + +describe("resolvePersonByJiraAccountId", () => { + it("matches mapped account ids with prefix variants", () => { + expect(resolvePersonByJiraAccountId(people, "712020:abc-trusted")?.username).toBe("patroza"); + expect(resolvePersonByJiraAccountId(people, "accountid:712020:ABC-TRUSTED")?.username).toBe( + "patroza", + ); + expect(resolvePersonByJiraAccountId(people, "712020:def-other")?.username).toBe("julius"); + }); + + it("returns null when unmapped", () => { + expect(resolvePersonByJiraAccountId(people, "unknown")).toBeNull(); + }); +}); + +describe("classifyJiraActorTrust", () => { + it("denies agent access when the identity map is disabled (fail-closed)", () => { + expect( + classifyJiraActorTrust({ + identityMapEnabled: false, + actorAccountId: "stranger", + people: [], + }), + ).toEqual({ mode: "context-only", person: null, reason: "identity_map_disabled" }); + }); + + it("trusts mapped Jira account ids for full agent turns", () => { + const decision = classifyJiraActorTrust({ + identityMapEnabled: true, + actorAccountId: "712020:abc-trusted", + people, + }); + expect(decision.mode).toBe("full"); + expect(decision.reason).toBe("mapped_jira_account"); + expect(decision.person?.username).toBe("patroza"); + }); + + it("restricts unmapped and missing account ids to context-only", () => { + expect( + classifyJiraActorTrust({ + identityMapEnabled: true, + actorAccountId: "712020:stranger", + people, + }), + ).toMatchObject({ mode: "context-only", reason: "unmapped_jira_account", person: null }); + + expect( + classifyJiraActorTrust({ + identityMapEnabled: true, + actorAccountId: null, + people, + }), + ).toMatchObject({ mode: "context-only", reason: "missing_jira_account_id", person: null }); + }); +}); diff --git a/apps/server/src/jira/jiraActorTrust.ts b/apps/server/src/jira/jiraActorTrust.ts new file mode 100644 index 000000000000..9d7808cfe5ba --- /dev/null +++ b/apps/server/src/jira/jiraActorTrust.ts @@ -0,0 +1,53 @@ +/** + * Jira actor trust relative to the closed-set identity map. + * + * Fail-closed: no configured map (or empty map) is treated like an unmapped + * actor — no agent turns. Only people with a mapped Jira accountId may run the + * agent; everyone else may only append context to an already-linked thread. + */ +import { + normalizeJiraAccountId, + resolvePersonByJiraAccountId, + type IdentityMapPerson, +} from "@t3tools/shared/identityMap"; + +export type JiraActorTrustMode = "full" | "context-only"; + +export type JiraActorTrustDecision = { + readonly mode: JiraActorTrustMode; + /** Mapped person when trusted; null when untrusted. */ + readonly person: IdentityMapPerson | null; + readonly reason: + | "identity_map_disabled" + | "mapped_jira_account" + | "unmapped_jira_account" + | "missing_jira_account_id"; +}; + +export { normalizeJiraAccountId, resolvePersonByJiraAccountId }; + +/** + * Classify a Jira mention actor for agent execution. + * + * - Map off / empty → context-only (no agent; same as unmapped) + * - Map on + accountId in map → full + * - Map on + missing/unmapped accountId → context-only + */ +export function classifyJiraActorTrust(input: { + readonly identityMapEnabled: boolean; + readonly actorAccountId: string | null | undefined; + readonly people: ReadonlyArray; +}): JiraActorTrustDecision { + if (!input.identityMapEnabled) { + return { mode: "context-only", person: null, reason: "identity_map_disabled" }; + } + const normalized = normalizeJiraAccountId(input.actorAccountId); + if (normalized === null) { + return { mode: "context-only", person: null, reason: "missing_jira_account_id" }; + } + const person = resolvePersonByJiraAccountId(input.people, input.actorAccountId); + if (person === null) { + return { mode: "context-only", person: null, reason: "unmapped_jira_account" }; + } + return { mode: "full", person, reason: "mapped_jira_account" }; +} diff --git a/apps/server/src/jira/jiraDiscordContext.test.ts b/apps/server/src/jira/jiraDiscordContext.test.ts new file mode 100644 index 000000000000..dd96703a6674 --- /dev/null +++ b/apps/server/src/jira/jiraDiscordContext.test.ts @@ -0,0 +1,30 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { formatDiscordJiraContextNote } from "./jiraDiscordContext.ts"; + +describe("formatDiscordJiraContextNote", () => { + it("formats a short context note", () => { + const text = formatDiscordJiraContextNote({ + issueKey: "SA-402", + requester: "Ada", + prompt: "packing fails on stage", + commentUrl: "https://example.atlassian.net/browse/SA-402?focusedCommentId=1", + }); + expect(text).toContain("SA-402"); + expect(text).toContain("Ada"); + expect(text).toContain("no agent run"); + expect(text).toContain("packing fails on stage"); + expect(text).toContain("focusedCommentId=1"); + }); + + it("truncates long prompts to Discord limits", () => { + const prompt = "x".repeat(3000); + const text = formatDiscordJiraContextNote({ + issueKey: "SA-1", + requester: "Bob", + prompt, + }); + expect(text.length).toBeLessThanOrEqual(2000); + expect(text).toContain("…(truncated)"); + }); +}); diff --git a/apps/server/src/jira/jiraDiscordContext.ts b/apps/server/src/jira/jiraDiscordContext.ts new file mode 100644 index 000000000000..946666bc5c68 --- /dev/null +++ b/apps/server/src/jira/jiraDiscordContext.ts @@ -0,0 +1,84 @@ +// @effect-diagnostics nodeBuiltinImport:off globalFetch:off globalFetchInEffect:off +/** + * Minimal Discord post helper for untrusted Jira context notes. + * Intentionally small — does not depend on MCP tools or the full Discord bot. + */ +import * as NodeFSP from "node:fs/promises"; + +const DISCORD_API_BASE_URL = "https://discord.com/api/v10"; +const DISCORD_DEFAULT_ENV_FILE = "/run/secrets/discord-bot.env"; + +function extractEnvAssignment(raw: string, key: string): string | undefined { + for (const line of raw.split(/\r?\n/u)) { + if (!line.startsWith(`${key}=`)) continue; + const value = line.slice(key.length + 1).trim(); + if (value.length === 0) return undefined; + if ( + (value.startsWith('"') && value.endsWith('"')) || + (value.startsWith("'") && value.endsWith("'")) + ) { + return value.slice(1, -1); + } + return value; + } + return undefined; +} + +export async function resolveDiscordBotToken(): Promise { + const fromEnv = process.env.DISCORD_BOT_TOKEN?.trim(); + if (fromEnv) return fromEnv; + try { + const envFile = await NodeFSP.readFile(DISCORD_DEFAULT_ENV_FILE, "utf8"); + const fromFile = extractEnvAssignment(envFile, "DISCORD_BOT_TOKEN")?.trim(); + return fromFile && fromFile.length > 0 ? fromFile : null; + } catch { + return null; + } +} + +/** Discord message body length limit (UTF-16 code units; we treat as chars). */ +const DISCORD_CONTENT_MAX = 2000; + +export function formatDiscordJiraContextNote(input: { + readonly issueKey: string; + readonly requester: string; + readonly prompt: string; + readonly commentUrl?: string | null; +}): string { + const header = `**Jira context** (no agent run) · \`${input.issueKey}\` · ${input.requester}`; + const link = input.commentUrl ? `\n${input.commentUrl}` : ""; + const body = input.prompt.trim(); + const combined = `${header}${link}\n\n${body}`; + if (combined.length <= DISCORD_CONTENT_MAX) return combined; + const budget = DISCORD_CONTENT_MAX - header.length - link.length - 20; + const clipped = body.slice(0, Math.max(0, budget)); + return `${header}${link}\n\n${clipped}\n…(truncated)`; +} + +export async function postDiscordChannelMessage(input: { + readonly token: string; + readonly channelId: string; + readonly content: string; +}): Promise<{ readonly id: string; readonly channelId: string }> { + const url = `${DISCORD_API_BASE_URL}/channels/${input.channelId}/messages`; + const response = await fetch(url, { + method: "POST", + headers: { + Authorization: `Bot ${input.token}`, + "Content-Type": "application/json", + }, + body: JSON.stringify({ + content: input.content, + allowed_mentions: { parse: [] as string[] }, + }), + }); + if (!response.ok) { + const body = await response.text(); + throw new Error(`Discord create message failed (${response.status}): ${body}`); + } + const json = (await response.json()) as { id?: string; channel_id?: string }; + return { + id: json.id ?? "", + channelId: json.channel_id ?? input.channelId, + }; +} diff --git a/apps/server/src/keybindings.test.ts b/apps/server/src/keybindings.test.ts index ec7070809435..3e69ecbd93e9 100644 --- a/apps/server/src/keybindings.test.ts +++ b/apps/server/src/keybindings.test.ts @@ -188,6 +188,34 @@ it.layer(NodeServices.layer)("keybindings", (it) => { }).pipe(Effect.provide(makeKeybindingsLayer())), ); + it.effect("ships configurable thread navigation defaults", () => + Effect.sync(() => { + const defaultsByCommand = new Map( + Keybindings.DEFAULT_KEYBINDINGS.map((binding) => [binding.command, binding.key] as const), + ); + + assert.equal(defaultsByCommand.get("thread.previous"), "mod+shift+["); + assert.equal(defaultsByCommand.get("thread.next"), "mod+shift+]"); + assert.equal(defaultsByCommand.get("thread.copyReference"), "mod+shift+c"); + assert.equal(defaultsByCommand.get("thread.settle"), "mod+shift+s"); + assert.equal(defaultsByCommand.get("thread.pin"), "mod+shift+p"); + assert.equal(defaultsByCommand.get("thread.jump.1"), "mod+1"); + assert.equal(defaultsByCommand.get("thread.jump.9"), "mod+9"); + assert.equal(defaultsByCommand.get("modelPicker.toggle"), "mod+shift+m"); + assert.equal(defaultsByCommand.get("board.open"), "mod+t"); + assert.equal(defaultsByCommand.get("themeEditor.toggle"), "mod+alt+shift+t"); + assert.equal(defaultsByCommand.get("filePicker.toggle"), "mod+p"); + assert.equal(defaultsByCommand.get("projectSearch.toggle"), "mod+shift+f"); + assert.equal(defaultsByCommand.get("sidebar.toggle"), "mod+b"); + assert.equal(defaultsByCommand.get("rightPanel.toggle"), "mod+alt+b"); + assert.isFalse(defaultsByCommand.has("rightPanel.toggleMaximized")); + assert.equal(defaultsByCommand.get("rightPanel.close"), "mod+w"); + assert.equal(defaultsByCommand.get("terminal.splitVertical"), "mod+shift+d"); + assert.equal(defaultsByCommand.get("modelPicker.jump.1"), "mod+1"); + assert.equal(defaultsByCommand.get("modelPicker.jump.9"), "mod+9"); + }), + ); + it.effect("uses defaults in runtime when config is malformed without overriding file", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; diff --git a/apps/server/src/keybindings.ts b/apps/server/src/keybindings.ts index 1795808bc179..3e4361d6a3b6 100644 --- a/apps/server/src/keybindings.ts +++ b/apps/server/src/keybindings.ts @@ -542,24 +542,19 @@ const make = Effect.gen(function* () { }); } - // Startup backfill must never evict persisted user rules: append only - // the defaults that fit and skip the rest. - const availableSlots = Math.max(0, MAX_KEYBINDINGS_COUNT - customConfig.length); - const defaultsToAppend = missingDefaults.slice(0, availableSlots); - const skippedDefaults = missingDefaults.slice(availableSlots); - if (skippedDefaults.length > 0) { - yield* Effect.logWarning("skipping default keybinding backfill at max entries", { + const nextConfig = [...customConfig, ...missingDefaults]; + const cappedConfig = + nextConfig.length > MAX_KEYBINDINGS_COUNT + ? nextConfig.slice(-MAX_KEYBINDINGS_COUNT) + : nextConfig; + if (nextConfig.length > MAX_KEYBINDINGS_COUNT) { + yield* Effect.logWarning("truncating keybindings config to max entries", { path: keybindingsConfigPath, maxEntries: MAX_KEYBINDINGS_COUNT, - commands: skippedDefaults.map((rule) => rule.command), }); } - if (defaultsToAppend.length === 0) { - yield* Cache.invalidate(resolvedConfigCache, resolvedConfigCacheKey); - return; - } - yield* writeConfigAtomically([...customConfig, ...defaultsToAppend]); + yield* writeConfigAtomically(cappedConfig); yield* Cache.invalidate(resolvedConfigCache, resolvedConfigCacheKey); }), ); diff --git a/apps/server/src/mcp/DiscordLinkedChannelTool.test.ts b/apps/server/src/mcp/DiscordLinkedChannelTool.test.ts new file mode 100644 index 000000000000..d13c470ad43a --- /dev/null +++ b/apps/server/src/mcp/DiscordLinkedChannelTool.test.ts @@ -0,0 +1,162 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { __testing } from "./DiscordLinkedChannelTool.ts"; + +describe("extractEnvAssignment", () => { + it("reads values from dotenv-like content", () => { + expect(__testing.extractEnvAssignment("DISCORD_BOT_TOKEN=abc123\n", "DISCORD_BOT_TOKEN")).toBe( + "abc123", + ); + expect(__testing.extractEnvAssignment("OTHER=1\n", "DISCORD_BOT_TOKEN")).toBeUndefined(); + }); +}); + +describe("parseTopicShortName", () => { + it("extracts t3 short names from channel topics", () => { + expect(__testing.parseTopicShortName("ops t3-example-project channel")).toBe("example-project"); + expect(__testing.parseTopicShortName("no tag")).toBeNull(); + }); +}); + +describe("pickLinkedDiscordChannel", () => { + it("returns a unique linked channel match", () => { + const result = __testing.pickLinkedDiscordChannel({ + guilds: [{ id: "guild-1", name: "Main" }], + channelsByGuildId: new Map([ + [ + "guild-1", + [ + { id: "chan-1", name: "scanner", type: 0, topic: "team t3-example-project" }, + { id: "chan-2", name: "other", type: 0, topic: "team t3-other" }, + ], + ], + ]), + shortName: "example-project", + }); + expect(result.match).toEqual({ + guildId: "guild-1", + guildName: "Main", + channelId: "chan-1", + channelName: "scanner", + shortName: "example-project", + topic: "team t3-example-project", + }); + expect(result.conflicts).toEqual([]); + }); +}); + +describe("pickLinkedDiscordThreadId", () => { + it("prefers the newest Discord thread linked to the active T3 thread", () => { + expect( + __testing.pickLinkedDiscordThreadId( + [ + { + discordThreadId: "discord-old", + t3ThreadId: "t3-active", + createdAt: "2026-07-17T10:00:00.000Z", + }, + { + discordThreadId: "discord-other", + t3ThreadId: "t3-other", + createdAt: "2026-07-18T10:00:00.000Z", + }, + { + discordThreadId: "discord-new", + t3ThreadId: "t3-active", + createdAt: "2026-07-18T10:00:00.000Z", + }, + ], + "t3-active", + ), + ).toBe("discord-new"); + }); + + it("reads v2 links.json documents used by the Discord bot", () => { + expect( + __testing.pickLinkedDiscordThreadId( + { + version: 2, + links: [ + { + discordThreadId: "discord-v2", + t3ThreadId: "t3-active", + createdAt: "2026-09-04T07:00:00.000Z", + status: "active", + }, + ], + }, + "t3-active", + ), + ).toBe("discord-v2"); + }); + + it("skips tombstones and prefers recent activity on v2 documents", () => { + expect( + __testing.pickLinkedDiscordThreadId( + { + version: 2, + links: [ + { + discordThreadId: "discord-tombstone", + t3ThreadId: "t3-active", + createdAt: "2026-09-04T09:00:00.000Z", + lastActivityAt: "2026-09-04T09:00:00.000Z", + status: "tombstone", + }, + { + discordThreadId: "discord-older-active", + t3ThreadId: "t3-active", + createdAt: "2026-09-04T07:00:00.000Z", + lastActivityAt: "2026-09-04T07:00:00.000Z", + status: "active", + }, + { + discordThreadId: "discord-newer-active", + t3ThreadId: "t3-active", + createdAt: "2026-09-04T08:00:00.000Z", + lastActivityAt: "2026-09-04T10:00:00.000Z", + status: "active", + }, + ], + }, + "t3-active", + ), + ).toBe("discord-newer-active"); + }); + + it("falls back when the active T3 thread has no Discord link", () => { + expect(__testing.pickLinkedDiscordThreadId([], "t3-active")).toBeNull(); + expect(__testing.pickLinkedDiscordThreadId({ links: [] }, "t3-active")).toBeNull(); + }); +}); + +describe("buildDiscordMultipartForm", () => { + it("uploads files as File parts so Discord keeps the filename", () => { + const form = __testing.buildDiscordMultipartForm({ + body: { content: "hi", allowed_mentions: { parse: [] } }, + files: [ + { + filename: "note.md", + spoiler: false, + bytes: new TextEncoder().encode("# hi\n"), + }, + ], + }); + const part = form.get("files[0]"); + expect(part).toBeInstanceOf(File); + expect((part as File).name).toBe("note.md"); + expect(form.get("payload_json")).toBe( + JSON.stringify({ content: "hi", allowed_mentions: { parse: [] } }), + ); + }); +}); + +describe("resolveDiscordPostDestination", () => { + it("prefers a linked Discord thread over its parent channel", () => { + expect(__testing.resolveDiscordPostDestination("channel-1", "thread-1")).toBe("thread-1"); + }); + + it("uses the repository channel when no Discord thread is linked", () => { + expect(__testing.resolveDiscordPostDestination("channel-1", null)).toBe("channel-1"); + }); +}); diff --git a/apps/server/src/mcp/DiscordLinkedChannelTool.ts b/apps/server/src/mcp/DiscordLinkedChannelTool.ts new file mode 100644 index 000000000000..47ac2e5dd879 --- /dev/null +++ b/apps/server/src/mcp/DiscordLinkedChannelTool.ts @@ -0,0 +1,869 @@ +// @effect-diagnostics nodeBuiltinImport:off globalFetch:off globalFetchInEffect:off outdatedApi:off +import * as NodeFS from "node:fs"; +import * as NodeFSP from "node:fs/promises"; +import * as NodePath from "node:path"; +import * as Cause from "effect/Cause"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import { McpSchema, McpServer } from "effect/unstable/ai"; + +import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import * as McpInvocationContext from "./McpInvocationContext.ts"; + +const DISCORD_API_BASE_URL = "https://discord.com/api/v10"; +const DISCORD_DEFAULT_ALIASES_PATH = "/run/secrets/project-aliases.yaml"; +const DISCORD_DEFAULT_ENV_FILE = "/run/secrets/discord-bot.env"; +const DISCORD_DEFAULT_DATA_DIR = "/var/lib/t3/discord-bot"; +const DISCORD_MESSAGE_FLAG_SUPPRESS_EMBEDS = 1 << 2; +const DISCORD_MESSAGE_FLAG_SUPPRESS_NOTIFICATIONS = 1 << 12; +const SHORT_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/; + +interface DiscordGuildSummary { + readonly id: string; + readonly name: string; +} + +interface DiscordGuildChannel { + readonly id: string; + readonly guild_id?: string; + readonly name?: string; + readonly type?: number; + readonly topic?: string | null; +} + +interface DiscordMessageResponse { + readonly id: string; + readonly channel_id: string; + readonly attachments?: ReadonlyArray<{ + readonly id: string; + readonly filename: string; + readonly size?: number; + readonly url?: string; + }>; +} + +interface LinkedDiscordChannel { + readonly guildId: string; + readonly guildName: string; + readonly channelId: string; + readonly channelName: string; + readonly shortName: string; + readonly topic: string; +} + +interface DiscordAttachmentInput { + readonly path: string; + readonly filename?: string; + readonly description?: string; + readonly spoiler?: boolean; +} + +interface DiscordEmbedInput { + readonly title?: string; + readonly description?: string; + readonly url?: string; + readonly color?: number; + readonly fields?: ReadonlyArray<{ + readonly name: string; + readonly value: string; + readonly inline?: boolean; + }>; + readonly footer?: { + readonly text: string; + readonly icon_url?: string; + }; + readonly author?: { + readonly name: string; + readonly url?: string; + readonly icon_url?: string; + }; + readonly image?: { readonly url: string }; + readonly thumbnail?: { readonly url: string }; +} + +interface DiscordPollInput { + readonly question: string; + readonly answers: ReadonlyArray; + readonly durationHours?: number; + readonly allowMultiselect?: boolean; +} + +interface DiscordPostToolInput { + readonly content?: string; + readonly attachments?: ReadonlyArray; + readonly embeds?: ReadonlyArray; + readonly poll?: DiscordPollInput; + readonly replyToMessageId?: string; + readonly tts?: boolean; + readonly suppressEmbeds?: boolean; + readonly suppressNotifications?: boolean; +} + +interface MutableDiscordPostToolInput { + content?: string; + attachments?: ReadonlyArray; + embeds?: ReadonlyArray; + poll?: DiscordPollInput; + replyToMessageId?: string; + tts?: boolean; + suppressEmbeds?: boolean; + suppressNotifications?: boolean; +} + +interface DiscordUploadFile { + readonly filename: string; + readonly description?: string; + readonly spoiler: boolean; + readonly bytes: Uint8Array; +} + +interface DiscordProjectAlias { + readonly shortName: string; + readonly workspaceRoot: string; +} + +interface DiscordThreadLinkRecord { + readonly discordThreadId: string; + readonly t3ThreadId: string; + readonly createdAt?: string; + readonly updatedAt?: string; + readonly lastActivityAt?: string; + readonly status?: string; +} + +function expandHomePath(value: string): string { + if (!value) return value; + if (value === "~") return process.env.HOME ?? value; + if (value.startsWith("~/") || value.startsWith("~\\")) { + return NodePath.join(process.env.HOME ?? "", value.slice(2)); + } + return value; +} + +function normalizeDiscordProjectAliasShortName(raw: string): string | null { + const shortName = raw.trim().toLowerCase(); + if (shortName.length === 0) return null; + if (!SHORT_NAME_PATTERN.test(shortName)) return null; + return shortName; +} + +function normalizeDiscordProjectAliasWorkspaceRoot(raw: string): string { + const expanded = expandHomePath(raw.trim()); + return expanded.replaceAll("\\", "/").replace(/\/+$/u, "") || expanded; +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function stripYamlScalar(value: string): string { + const trimmed = value.trim(); + if ( + (trimmed.startsWith('"') && trimmed.endsWith('"')) || + (trimmed.startsWith("'") && trimmed.endsWith("'")) + ) { + return trimmed.slice(1, -1); + } + return trimmed; +} + +function parseDiscordProjectAliasesYaml(raw: string): unknown { + const lines = raw.split(/\r?\n/); + const flat: Record = {}; + const nested: Record = {}; + let inAliasesBlock = false; + let currentKey: string | null = null; + + for (const line of lines) { + const trimmed = line.trim(); + if (trimmed.length === 0 || trimmed.startsWith("#")) continue; + + if (/^aliases:\s*$/.test(trimmed)) { + inAliasesBlock = true; + continue; + } + + const workspaceRootMatch = /^\s+workspaceRoot:\s*(.+)\s*$/.exec(line); + if (workspaceRootMatch && currentKey !== null) { + const value = stripYamlScalar(workspaceRootMatch[1]!); + nested[currentKey] = { workspaceRoot: value }; + currentKey = null; + continue; + } + + const nestedKeyMatch = /^\s{2,}([A-Za-z0-9][A-Za-z0-9_-]*):\s*$/.exec(line); + if (nestedKeyMatch && inAliasesBlock) { + currentKey = nestedKeyMatch[1]!; + continue; + } + + const flatMatch = /^([A-Za-z0-9][A-Za-z0-9_-]*):\s*(.+)\s*$/.exec(trimmed); + if (flatMatch) { + const key = flatMatch[1]!; + const value = stripYamlScalar(flatMatch[2]!); + if (key === "aliases") continue; + flat[key] = value; + currentKey = null; + } + } + + if (Object.keys(nested).length > 0) { + return { aliases: nested }; + } + return flat; +} + +function parseDiscordProjectAliasesDocument( + document: unknown, + options?: { readonly resolveRelativeTo?: string }, +): ReadonlyArray { + const resolveRoot = (raw: string): string => { + const expanded = expandHomePath(raw.trim()); + const absolute = + options?.resolveRelativeTo !== undefined && !NodePath.isAbsolute(expanded) + ? NodePath.resolve(options.resolveRelativeTo, expanded) + : expanded; + return normalizeDiscordProjectAliasWorkspaceRoot(absolute); + }; + + const entries = new Map(); + + const add = (shortNameRaw: string, workspaceRootRaw: string) => { + const shortName = normalizeDiscordProjectAliasShortName(shortNameRaw); + if (shortName === null) { + throw new Error(`Invalid project alias shortName '${shortNameRaw}'.`); + } + const workspaceRoot = resolveRoot(workspaceRootRaw); + if (workspaceRoot.trim().length === 0) { + throw new Error(`Project alias '${shortName}' has an empty workspaceRoot.`); + } + if (entries.has(shortName)) { + throw new Error(`Duplicate project alias shortName '${shortName}'.`); + } + entries.set(shortName, workspaceRoot); + }; + + if (Array.isArray(document)) { + for (const item of document) { + if (!isRecord(item)) { + throw new Error("Project aliases array entries must be objects."); + } + const shortName = item.shortName; + const workspaceRoot = item.workspaceRoot; + if (typeof shortName !== "string" || typeof workspaceRoot !== "string") { + throw new Error("Each project alias must include string shortName and workspaceRoot."); + } + add(shortName, workspaceRoot); + } + } else if (isRecord(document)) { + const aliasesNode = document.aliases; + const source = isRecord(aliasesNode) ? aliasesNode : document; + for (const [key, value] of Object.entries(source)) { + if (key === "aliases" && source === document) continue; + if (typeof value === "string") { + add(key, value); + continue; + } + if (isRecord(value) && typeof value.workspaceRoot === "string") { + add(key, value.workspaceRoot); + continue; + } + throw new Error( + `Project alias '${key}' must be a path string or an object with workspaceRoot.`, + ); + } + } else { + throw new Error("Project aliases file must be a mapping, aliases object, or array."); + } + + return [...entries.entries()] + .map(([shortName, workspaceRoot]) => ({ shortName, workspaceRoot })) + .toSorted((left, right) => left.shortName.localeCompare(right.shortName)); +} + +function loadDiscordProjectAliasesFromFileSync( + filePath: string, +): ReadonlyArray { + const resolvedPath = NodePath.resolve(expandHomePath(filePath.trim())); + const raw = NodeFS.readFileSync(resolvedPath, "utf8"); + const trimmed = raw.trim(); + if (trimmed.length === 0) return []; + + const document = resolvedPath.endsWith(".json") + ? (JSON.parse(trimmed) as unknown) + : parseDiscordProjectAliasesYaml(trimmed); + return parseDiscordProjectAliasesDocument(document, { + resolveRelativeTo: NodePath.dirname(resolvedPath), + }); +} + +function findDiscordProjectAliasByWorkspaceRoot( + aliases: ReadonlyArray, + workspaceRoot: string, +): DiscordProjectAlias | null { + const normalized = normalizeDiscordProjectAliasWorkspaceRoot(workspaceRoot); + return aliases.find((entry) => entry.workspaceRoot === normalized) ?? null; +} + +function extractEnvAssignment(raw: string, key: string): string | undefined { + for (const line of raw.split(/\r?\n/u)) { + if (!line.startsWith(`${key}=`)) continue; + const value = line.slice(key.length + 1).trim(); + if (value.length === 0) return undefined; + if ( + (value.startsWith('"') && value.endsWith('"')) || + (value.startsWith("'") && value.endsWith("'")) + ) { + return value.slice(1, -1); + } + return value; + } + return undefined; +} + +async function readOptionalTextFile(filePath: string): Promise { + try { + return await NodeFSP.readFile(filePath, "utf8"); + } catch { + return null; + } +} + +async function resolveDiscordBotToken(): Promise { + const fromEnv = process.env.DISCORD_BOT_TOKEN?.trim(); + if (fromEnv) return fromEnv; + const envFile = await readOptionalTextFile(DISCORD_DEFAULT_ENV_FILE); + const fromFile = envFile ? extractEnvAssignment(envFile, "DISCORD_BOT_TOKEN")?.trim() : undefined; + return fromFile && fromFile.length > 0 ? fromFile : null; +} + +async function resolveDiscordAliasesPath(): Promise { + const fromEnv = process.env.T3_PROJECT_ALIASES_PATH?.trim(); + if (fromEnv) return fromEnv; + const aliasesFile = await readOptionalTextFile(DISCORD_DEFAULT_ALIASES_PATH); + return aliasesFile !== null ? DISCORD_DEFAULT_ALIASES_PATH : null; +} + +function linksFromDocument(document: unknown): ReadonlyArray { + if (Array.isArray(document)) return document; + if (isRecord(document) && Array.isArray(document.links)) return document.links; + return []; +} + +function isDiscordThreadLinkRecord(entry: unknown): entry is DiscordThreadLinkRecord { + return ( + isRecord(entry) && + typeof entry.t3ThreadId === "string" && + typeof entry.discordThreadId === "string" && + entry.discordThreadId.trim().length > 0 + ); +} + +function linkRecency(entry: DiscordThreadLinkRecord): string { + return entry.lastActivityAt ?? entry.updatedAt ?? entry.createdAt ?? ""; +} + +function pickLinkedDiscordThreadId(document: unknown, t3ThreadId: string): string | null { + const matches = linksFromDocument(document).filter( + (entry): entry is DiscordThreadLinkRecord => + isDiscordThreadLinkRecord(entry) && entry.t3ThreadId === t3ThreadId, + ); + const active = matches.filter((entry) => entry.status !== "tombstone"); + const pool = active.length > 0 ? active : matches; + return ( + pool.toSorted((left, right) => linkRecency(right).localeCompare(linkRecency(left)))[0] + ?.discordThreadId ?? null + ); +} + +async function resolveLinkedDiscordThreadId(t3ThreadId: string): Promise { + const dataDir = expandHomePath( + process.env.T3_DISCORD_BOT_DATA_DIR?.trim() || DISCORD_DEFAULT_DATA_DIR, + ); + const raw = await readOptionalTextFile(NodePath.join(dataDir, "links.json")); + if (raw === null) return null; + try { + return pickLinkedDiscordThreadId(JSON.parse(raw) as unknown, t3ThreadId); + } catch { + return null; + } +} + +function resolveDiscordPostDestination( + linkedChannelId: string, + linkedThreadId: string | null, +): string { + return linkedThreadId ?? linkedChannelId; +} + +function parseTopicShortName(topic: string | null | undefined): string | null { + if (!topic) return null; + const match = /(?:^|\s)t3-([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/iu.exec(topic); + return match?.[1]?.toLowerCase() ?? null; +} + +function isSupportedLinkedChannel(channel: DiscordGuildChannel): boolean { + return channel.type === 0 || channel.type === 5; +} + +function pickLinkedDiscordChannel(input: { + readonly guilds: ReadonlyArray; + readonly channelsByGuildId: ReadonlyMap>; + readonly shortName: string; +}): { + readonly match: LinkedDiscordChannel | null; + readonly conflicts: ReadonlyArray; +} { + const matches: LinkedDiscordChannel[] = []; + for (const guild of input.guilds) { + for (const channel of input.channelsByGuildId.get(guild.id) ?? []) { + if (!isSupportedLinkedChannel(channel) || typeof channel.topic !== "string") continue; + const topicShortName = parseTopicShortName(channel.topic); + if (topicShortName !== input.shortName) continue; + matches.push({ + guildId: guild.id, + guildName: guild.name, + channelId: channel.id, + channelName: channel.name ?? channel.id, + shortName: input.shortName, + topic: channel.topic, + }); + } + } + + if (matches.length !== 1) { + return { match: null, conflicts: matches }; + } + return { match: matches[0]!, conflicts: [] }; +} + +async function discordGetJson(token: string, path: string): Promise { + const response = await fetch(`${DISCORD_API_BASE_URL}${path}`, { + headers: { + Authorization: `Bot ${token}`, + }, + }); + if (!response.ok) { + const body = await response.text(); + throw new Error(`Discord GET ${path} failed (${response.status}): ${body}`); + } + return (await response.json()) as T; +} + +async function resolveLinkedChannel(input: { + readonly token: string; + readonly workspaceRoot: string; +}): Promise { + const aliasesPath = await resolveDiscordAliasesPath(); + if (!aliasesPath) return null; + const aliases = loadDiscordProjectAliasesFromFileSync(aliasesPath); + const alias = findDiscordProjectAliasByWorkspaceRoot(aliases, input.workspaceRoot); + if (alias === null) return null; + + const guilds = await discordGetJson>( + input.token, + "/users/@me/guilds", + ); + const channelsByGuildId = new Map>(); + await Promise.all( + guilds.map(async (guild) => { + const channels = await discordGetJson>( + input.token, + `/guilds/${guild.id}/channels`, + ); + channelsByGuildId.set(guild.id, channels); + }), + ); + + const picked = pickLinkedDiscordChannel({ + guilds, + channelsByGuildId, + shortName: alias.shortName, + }); + if (picked.conflicts.length > 1) { + throw new Error( + `Multiple linked Discord channels found for '${alias.shortName}': ${picked.conflicts + .map((entry) => `${entry.guildName}/#${entry.channelName}`) + .join(", ")}`, + ); + } + return picked.match; +} + +function normalizeDiscordPostToolInput(payload: unknown): DiscordPostToolInput { + if (typeof payload !== "object" || payload === null) return {}; + const record = payload as Record; + const normalized: MutableDiscordPostToolInput = {}; + if (typeof record.content === "string") normalized.content = record.content; + if (Array.isArray(record.attachments)) { + normalized.attachments = record.attachments.filter( + (entry): entry is DiscordAttachmentInput => + typeof entry === "object" && + entry !== null && + typeof (entry as { path?: unknown }).path === "string", + ); + } + if (Array.isArray(record.embeds)) { + normalized.embeds = record.embeds.filter( + (entry): entry is DiscordEmbedInput => typeof entry === "object" && entry !== null, + ) as ReadonlyArray; + } + if (typeof record.poll === "object" && record.poll !== null) { + normalized.poll = record.poll as DiscordPollInput; + } + if (typeof record.replyToMessageId === "string") { + normalized.replyToMessageId = record.replyToMessageId; + } + if (record.tts === true) normalized.tts = true; + if (record.suppressEmbeds === true) normalized.suppressEmbeds = true; + if (record.suppressNotifications === true) normalized.suppressNotifications = true; + return normalized; +} + +function validateDiscordPostToolInput(input: DiscordPostToolInput): string | null { + const hasContent = (input.content?.trim().length ?? 0) > 0; + const hasAttachments = (input.attachments?.length ?? 0) > 0; + const hasEmbeds = (input.embeds?.length ?? 0) > 0; + const hasPoll = input.poll !== undefined; + if (!hasContent && !hasAttachments && !hasEmbeds && !hasPoll) { + return "Provide at least one of content, attachments, embeds, or poll."; + } + if (input.poll) { + if (input.poll.question.trim().length === 0) { + return "Poll question cannot be empty."; + } + if (!Array.isArray(input.poll.answers) || input.poll.answers.length < 2) { + return "Polls require at least two answers."; + } + } + return null; +} + +async function readDiscordUploadFiles( + attachments: ReadonlyArray, + cwd: string, +): Promise> { + return Promise.all( + attachments.map(async (attachment) => { + const resolvedPath = NodePath.isAbsolute(attachment.path) + ? attachment.path + : NodePath.resolve(cwd, attachment.path); + const bytes = await NodeFSP.readFile(resolvedPath); + const requestedName = attachment.filename?.trim(); + const baseFilename = + requestedName && requestedName.length > 0 ? requestedName : NodePath.basename(resolvedPath); + return { + filename: + attachment.spoiler === true && !baseFilename.startsWith("SPOILER_") + ? `SPOILER_${baseFilename}` + : baseFilename, + spoiler: attachment.spoiler === true, + bytes, + ...(attachment.description?.trim() ? { description: attachment.description.trim() } : {}), + }; + }), + ); +} + +function buildDiscordCreateMessageBody( + input: DiscordPostToolInput, + files: ReadonlyArray, +) { + const flags = + (input.suppressEmbeds ? DISCORD_MESSAGE_FLAG_SUPPRESS_EMBEDS : 0) | + (input.suppressNotifications ? DISCORD_MESSAGE_FLAG_SUPPRESS_NOTIFICATIONS : 0); + return { + ...(input.content !== undefined ? { content: input.content } : {}), + ...(input.tts ? { tts: true } : {}), + ...(input.embeds && input.embeds.length > 0 ? { embeds: input.embeds } : {}), + ...(flags !== 0 ? { flags } : {}), + allowed_mentions: { parse: [] as string[] }, + ...(input.replyToMessageId + ? { + message_reference: { + message_id: input.replyToMessageId, + fail_if_not_exists: false, + }, + allowed_mentions: { parse: [] as string[], replied_user: false }, + } + : {}), + ...(input.poll + ? { + poll: { + question: { text: input.poll.question }, + answers: input.poll.answers.map((answer) => ({ poll_media: { text: answer } })), + duration: input.poll.durationHours ?? 24, + allow_multiselect: input.poll.allowMultiselect === true, + }, + } + : {}), + ...(files.length > 0 + ? { + attachments: files.map((file, index) => ({ + id: index, + filename: file.filename, + ...(file.description ? { description: file.description } : {}), + ...(file.spoiler ? { is_spoiler: true } : {}), + })), + } + : {}), + }; +} + +function copyBytes(bytes: Uint8Array): Uint8Array { + const copy = new Uint8Array(bytes.byteLength); + copy.set(bytes); + return copy; +} + +function appendDiscordUploadFiles(form: FormData, files: ReadonlyArray): void { + files.forEach((file, index) => { + const filename = file.filename.trim() !== "" ? file.filename.trim() : "attachment.bin"; + form.append( + `files[${index}]`, + new File([copyBytes(file.bytes)], filename, { + type: "application/octet-stream", + }), + ); + }); +} + +function buildDiscordMultipartForm(input: { + readonly body: ReturnType; + readonly files: ReadonlyArray; +}): FormData { + const formData = new FormData(); + formData.append("payload_json", JSON.stringify(input.body)); + appendDiscordUploadFiles(formData, input.files); + return formData; +} + +function messageFromUnknown(cause: unknown): string { + return cause instanceof Error ? cause.message : String(cause); +} + +async function createDiscordMessage(input: { + readonly token: string; + readonly channelId: string; + readonly body: ReturnType; + readonly files: ReadonlyArray; +}): Promise { + const url = `${DISCORD_API_BASE_URL}/channels/${input.channelId}/messages`; + const response = + input.files.length === 0 + ? await fetch(url, { + method: "POST", + headers: { + Authorization: `Bot ${input.token}`, + "Content-Type": "application/json", + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + body: JSON.stringify(input.body), + }) + : await fetch(url, { + method: "POST", + headers: { + Authorization: `Bot ${input.token}`, + "User-Agent": "DiscordBot (t3-discord-bot, 0.0.0)", + }, + body: buildDiscordMultipartForm({ body: input.body, files: input.files }), + }); + + if (!response.ok) { + const body = await response.text(); + throw new Error(`Discord create message failed (${response.status}): ${body}`); + } + return (await response.json()) as DiscordMessageResponse; +} + +function errorResult(message: string, tag = "DiscordLinkedChannelPostError") { + return new McpSchema.CallToolResult({ + isError: true, + structuredContent: { + error: { + _tag: tag, + message, + }, + }, + content: [{ type: "text", text: message }], + }); +} + +export const registerDiscordLinkedChannelPostTool = Effect.fn("DiscordLinkedChannelTool.register")( + function* () { + const server = yield* McpServer.McpServer; + const snapshotQuery = yield* ProjectionSnapshotQuery; + + yield* server.addTool({ + tool: new McpSchema.Tool({ + name: "discord_post_to_linked_channel", + description: + "Post to the Discord thread linked to the active T3 thread, falling back to the repository channel linked via a `t3-` topic tag. Supports file attachments, rich embeds, and polls.", + inputSchema: { + type: "object", + properties: { + content: { type: "string", description: "Plain message content." }, + attachments: { + type: "array", + description: + "Local files to upload. Relative paths resolve from the current thread workspace.", + items: { + type: "object", + properties: { + path: { type: "string" }, + filename: { type: "string" }, + description: { type: "string" }, + spoiler: { type: "boolean" }, + }, + required: ["path"], + additionalProperties: false, + }, + }, + embeds: { + type: "array", + description: + "Discord rich embeds. Uploaded files can be referenced with attachment://filename URLs.", + items: { type: "object" }, + }, + poll: { + type: "object", + properties: { + question: { type: "string" }, + answers: { type: "array", items: { type: "string" } }, + durationHours: { type: "integer", minimum: 1, maximum: 768 }, + allowMultiselect: { type: "boolean" }, + }, + required: ["question", "answers"], + additionalProperties: false, + }, + replyToMessageId: { type: "string" }, + tts: { type: "boolean" }, + suppressEmbeds: { type: "boolean" }, + suppressNotifications: { type: "boolean" }, + }, + additionalProperties: false, + }, + annotations: { + title: "Post to linked Discord channel", + destructiveHint: false, + idempotentHint: false, + openWorldHint: true, + }, + }), + annotations: Context.empty(), + handle: (payload) => + Effect.withFiber((fiber) => { + const invocation = Context.getUnsafe( + fiber.context, + McpInvocationContext.McpInvocationContext, + ); + const input = normalizeDiscordPostToolInput(payload); + const validationError = validateDiscordPostToolInput(input); + if (validationError) { + return Effect.succeed(errorResult(validationError, "InvalidDiscordPostInput")); + } + + return Effect.gen(function* () { + const threadShell = yield* snapshotQuery.getThreadShellById(invocation.threadId); + if (Option.isNone(threadShell)) { + return errorResult(`Thread ${invocation.threadId} was not found.`, "ThreadNotFound"); + } + const projectShell = yield* snapshotQuery.getProjectShellById( + threadShell.value.projectId, + ); + if (Option.isNone(projectShell)) { + return errorResult( + `Project ${threadShell.value.projectId} was not found for this thread.`, + "ProjectNotFound", + ); + } + + const token = yield* Effect.promise(() => resolveDiscordBotToken()); + if (!token) { + return errorResult( + "Discord posting is unavailable because no Discord bot token is configured.", + "DiscordUnavailable", + ); + } + + const linkedChannel = yield* Effect.promise(() => + resolveLinkedChannel({ + token, + workspaceRoot: projectShell.value.workspaceRoot, + }), + ); + if (linkedChannel === null) { + return errorResult( + `No linked Discord channel was found for repository workspace '${projectShell.value.workspaceRoot}'.`, + "LinkedChannelNotFound", + ); + } + + const cwd = threadShell.value.worktreePath ?? projectShell.value.workspaceRoot; + const discordThreadId = yield* Effect.promise(() => + resolveLinkedDiscordThreadId(invocation.threadId), + ); + const destinationId = resolveDiscordPostDestination( + linkedChannel.channelId, + discordThreadId, + ); + const files = yield* Effect.promise(() => + readDiscordUploadFiles(input.attachments ?? [], cwd), + ); + const body = buildDiscordCreateMessageBody(input, files); + const message = yield* Effect.promise(() => + createDiscordMessage({ + token, + channelId: destinationId, + body, + files, + }), + ); + + return new McpSchema.CallToolResult({ + isError: false, + structuredContent: { + shortName: linkedChannel.shortName, + guildId: linkedChannel.guildId, + guildName: linkedChannel.guildName, + channelId: linkedChannel.channelId, + channelName: linkedChannel.channelName, + destinationId, + discordThreadId, + messageId: message.id, + attachmentCount: message.attachments?.length ?? 0, + }, + content: [ + { + type: "text", + text: + discordThreadId === null + ? `Posted to Discord ${linkedChannel.guildName}/#${linkedChannel.channelName}.` + : `Posted to the linked Discord thread in ${linkedChannel.guildName}/#${linkedChannel.channelName}.`, + }, + ], + }); + }).pipe( + Effect.matchCause({ + onFailure: (cause) => + errorResult( + messageFromUnknown(Cause.squash(cause)), + "DiscordLinkedChannelPostError", + ), + onSuccess: (result) => result, + }), + ); + }), + }); + }, +); + +export const __testing = { + extractEnvAssignment, + parseTopicShortName, + pickLinkedDiscordChannel, + pickLinkedDiscordThreadId, + resolveDiscordPostDestination, + buildDiscordMultipartForm, +}; diff --git a/apps/server/src/mcp/McpHttpServer.test.ts b/apps/server/src/mcp/McpHttpServer.test.ts index 9cbc3fde2977..f459b6bcb42c 100644 --- a/apps/server/src/mcp/McpHttpServer.test.ts +++ b/apps/server/src/mcp/McpHttpServer.test.ts @@ -12,6 +12,7 @@ import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; import { McpProtocol, McpSchema, McpServer } from "effect/unstable/ai"; import { HttpBody, HttpClient, HttpRouter, HttpServerResponse } from "effect/unstable/http"; +import { vi } from "vite-plus/test"; import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; @@ -51,6 +52,9 @@ const TestLayer = McpHttpServer.PreviewToolkitRegistrationLive.pipe( Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "t3-mcp-http-server-test-" })), Layer.provideMerge(NodeServices.layer), ); +const DiscordThreadToolTestLayer = McpHttpServer.DiscordThreadToolkitRegistrationLive.pipe( + Layer.provideMerge(McpServer.McpServer.layer), +); const PullRequestsTestLayer = McpHttpServer.PullRequestsToolkitRegistrationLive.pipe( Layer.provideMerge(McpServer.McpServer.layer), Layer.provide( @@ -766,3 +770,95 @@ it.effect("registers annotated tools and preserves authenticated request context }), ).pipe(Effect.provide(TestLayer)), ); + +it.effect("renames the current thread through the Discord mirror tool", () => { + const dispatchCalls: Array = []; + const dispatch = vi.fn((command: unknown) => { + dispatchCalls.push(command); + return Promise.resolve({ sequence: 1 }); + }); + + return Effect.gen(function* () { + const server = yield* McpServer.McpServer; + + const renamed = yield* server + .callTool({ name: "discord_rename_thread", arguments: { title: "Review PR #428" } }) + .pipe( + Effect.provideService(McpInvocationContext.McpInvocationContext, invocation), + Effect.provideService(McpSchema.McpServerClient, client), + ); + + expect(renamed.isError).toBe(false); + expect(renamed.structuredContent).toMatchObject({ + threadId, + title: "Review PR #428", + discordMirrorRequested: true, + }); + expect(dispatchCalls).toHaveLength(1); + expect(dispatchCalls[0]).toMatchObject({ + type: "thread.meta.update", + threadId, + title: "Review PR #428", + }); + }).pipe( + Effect.provide( + DiscordThreadToolTestLayer.pipe( + Layer.provideMerge( + Layer.succeed(OrchestrationEngineService, { + readEvents: () => Stream.empty, + readThreadEvents: () => Stream.empty, + getThreadReplayStats: () => + Effect.succeed({ + eventCount: 0, + payloadBytes: 0, + hasCreateEvent: false, + }), + dispatch: (command) => Effect.promise(() => dispatch(command)), + streamDomainEvents: Stream.empty, + subscribeDomainEvents: Effect.succeed(Stream.empty), + latestSequence: Effect.succeed(0), + }), + ), + ), + ), + ); +}); + +it.effect("rejects empty Discord mirror thread titles", () => + Effect.gen(function* () { + const server = yield* McpServer.McpServer; + + const result = yield* server + .callTool({ name: "discord_rename_thread", arguments: { title: " " } }) + .pipe( + Effect.provideService(McpInvocationContext.McpInvocationContext, invocation), + Effect.provideService(McpSchema.McpServerClient, client), + ); + + expect(result.isError).toBe(true); + expect(result.structuredContent).toEqual({ + error: { _tag: "InvalidTitle", message: "Title cannot be empty." }, + }); + }).pipe( + Effect.provide( + DiscordThreadToolTestLayer.pipe( + Layer.provideMerge( + Layer.succeed(OrchestrationEngineService, { + readEvents: () => Stream.empty, + readThreadEvents: () => Stream.empty, + getThreadReplayStats: () => + Effect.succeed({ + eventCount: 0, + payloadBytes: 0, + hasCreateEvent: false, + }), + dispatch: () => Effect.die("unused"), + streamDomainEvents: Stream.empty, + subscribeDomainEvents: Effect.succeed(Stream.empty), + latestSequence: Effect.succeed(0), + }), + ), + ), + ), + ), +); diff --git a/apps/server/src/mcp/McpHttpServer.ts b/apps/server/src/mcp/McpHttpServer.ts index 5a8cb573ad88..f4bc18a4f5ea 100644 --- a/apps/server/src/mcp/McpHttpServer.ts +++ b/apps/server/src/mcp/McpHttpServer.ts @@ -1,4 +1,5 @@ import * as NodeCrypto from "node:crypto"; +import { CommandId } from "@t3tools/contracts"; import * as Cause from "effect/Cause"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; @@ -7,6 +8,7 @@ import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; +import * as Random from "effect/Random"; import * as Schema from "effect/Schema"; import * as Sink from "effect/Sink"; import * as Stream from "effect/Stream"; @@ -20,6 +22,8 @@ import * as DeviceService from "../device/DeviceService.ts"; import * as McpInvocationContext from "./McpInvocationContext.ts"; import * as McpSessionRegistry from "./McpSessionRegistry.ts"; import * as PreviewAutomationBroker from "./PreviewAutomationBroker.ts"; +import * as DiscordLinkedChannelTool from "./DiscordLinkedChannelTool.ts"; +import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; import { PreviewSnapshotToolkitHandlersLive, PreviewStandardToolkitHandlersLive, @@ -390,6 +394,7 @@ const registerPreviewSnapshot = Effect.fn("McpHttpServer.registerPreviewSnapshot readonly data: string; readonly width: number; readonly height: number; + readonly path?: string; }; }; const { screenshot, ...page } = snapshot; @@ -402,6 +407,7 @@ const registerPreviewSnapshot = Effect.fn("McpHttpServer.registerPreviewSnapshot mimeType: screenshot.mimeType, width: screenshot.width, height: screenshot.height, + ...(screenshot.path === undefined ? {} : { path: screenshot.path }), }, ...(screenshotPath === undefined ? {} : { screenshotPath }), }; @@ -599,11 +605,124 @@ const PreviewSnapshotRegistrationLive = Layer.effectDiscard(registerPreviewSnaps Layer.provide(PreviewSnapshotToolkitHandlersLive), ); +const registerDiscordRenameThread = Effect.fn("McpHttpServer.registerDiscordRenameThread")( + function* () { + const server = yield* McpServer.McpServer; + const engine = yield* OrchestrationEngineService; + + yield* server.addTool({ + tool: new McpSchema.Tool({ + name: "discord_rename_thread", + description: + "Rename the current T3 thread. When this thread is linked to a Discord thread through the Discord bot, the bot mirrors the new title onto that Discord thread automatically.", + inputSchema: { + type: "object", + properties: { + title: { + type: "string", + description: "New concise title for the current linked thread.", + }, + }, + required: ["title"], + additionalProperties: false, + }, + annotations: { + title: "Rename linked Discord thread", + destructiveHint: false, + idempotentHint: true, + openWorldHint: false, + }, + }), + annotations: Context.empty(), + handle: (payload) => + Effect.withFiber((fiber) => { + const invocation = Context.getUnsafe( + fiber.context, + McpInvocationContext.McpInvocationContext, + ); + const rawTitle = + typeof payload === "object" && payload !== null && "title" in payload + ? payload.title + : undefined; + const title = typeof rawTitle === "string" ? rawTitle.trim().replace(/\s+/g, " ") : ""; + if (title.length === 0) { + return Effect.succeed( + new McpSchema.CallToolResult({ + isError: true, + structuredContent: { + error: { _tag: "InvalidTitle", message: "Title cannot be empty." }, + }, + content: [{ type: "text", text: "Title cannot be empty." }], + }), + ); + } + + return Effect.gen(function* () { + const millis = yield* Clock.currentTimeMillis; + const random = yield* Random.nextInt; + const commandId = CommandId.make( + `server:mcp-discord-rename-thread:${millis}:${String(Math.abs(random))}`, + ); + yield* engine.dispatch({ + type: "thread.meta.update", + commandId, + threadId: invocation.threadId, + title, + }); + return new McpSchema.CallToolResult({ + isError: false, + structuredContent: { + threadId: invocation.threadId, + title, + discordMirrorRequested: true, + }, + content: [ + { + type: "text", + text: `Renamed the T3 thread to "${title}". A linked Discord bot will mirror the title.`, + }, + ], + }); + }).pipe( + Effect.matchCause({ + onFailure: (cause) => + new McpSchema.CallToolResult({ + isError: true, + structuredContent: { + error: { + _tag: "ThreadRenameFailed", + message: Cause.pretty(cause), + }, + }, + content: [{ type: "text", text: "Failed to rename the linked thread." }], + }), + onSuccess: (result) => result, + }), + ); + }), + }); + }, +); + +export const DiscordThreadToolkitRegistrationLive = Layer.effectDiscard( + registerDiscordRenameThread(), +); + +export const DiscordLinkedChannelToolkitRegistrationLive = Layer.effectDiscard( + DiscordLinkedChannelTool.registerDiscordLinkedChannelPostTool(), +); + export const PreviewToolkitRegistrationLive = Layer.mergeAll( PreviewStandardToolkitRegistrationLive, PreviewSnapshotRegistrationLive, ); +export const AgentThreadToolkitRegistrationLive = Layer.mergeAll( + PreviewToolkitRegistrationLive, + DiscordThreadToolkitRegistrationLive, + DiscordLinkedChannelToolkitRegistrationLive, +); + export const PullRequestsToolkitRegistrationLive = McpServer.toolkit(PullRequestsToolkit).pipe( Layer.provide(PullRequestsToolkitHandlersLive), ); @@ -629,7 +748,7 @@ const McpTransportLive = McpServer.layerHttp({ }).pipe(Layer.provide(McpAuthMiddlewareLive)); export const layer = Layer.mergeAll( - PreviewToolkitRegistrationLive, + AgentThreadToolkitRegistrationLive, PullRequestsToolkitRegistrationLive, DeviceToolkitRegistrationLive, ).pipe(Layer.provideMerge(McpTransportLive)); diff --git a/apps/server/src/mcp/PreviewAutomationBroker.test.ts b/apps/server/src/mcp/PreviewAutomationBroker.test.ts index 27557d43b701..30fd7f64479d 100644 --- a/apps/server/src/mcp/PreviewAutomationBroker.test.ts +++ b/apps/server/src/mcp/PreviewAutomationBroker.test.ts @@ -7,6 +7,7 @@ import { PreviewAutomationMalformedResponseError, PreviewAutomationNoAvailableHostError, PreviewAutomationTargetNotEditableError, + PreviewAutomationTimeoutError, PreviewTabId, ProviderInstanceId, ThreadId, @@ -19,6 +20,7 @@ import * as Deferred from "effect/Deferred"; import * as Fiber from "effect/Fiber"; import * as Result from "effect/Result"; import * as Stream from "effect/Stream"; +import * as TestClock from "effect/testing/TestClock"; import * as PreviewAutomationBroker from "./PreviewAutomationBroker.ts"; @@ -558,6 +560,46 @@ it.effect("removes host availability when the authoritative request stream disco ), ); +it.effect("evicts an unresponsive host so its automation stream can reconnect", () => + Effect.scoped( + Effect.gen(function* () { + const broker = yield* makeBroker; + const staleRequests = requestsFrom(yield* broker.connect(makeHost())); + yield* Stream.runDrain(staleRequests).pipe(Effect.forkScoped); + yield* Effect.yieldNow; + + const pendingTimeout = yield* broker + .invoke({ scope, operation: "status", input: {}, timeoutMs: 10 }) + .pipe(Effect.flip, Effect.forkScoped); + yield* Effect.yieldNow; + yield* TestClock.adjust("10 millis"); + const timeout = yield* Fiber.join(pendingTimeout); + expect(timeout).toBeInstanceOf(PreviewAutomationTimeoutError); + + const unavailable = yield* broker + .invoke({ scope, operation: "status", input: {} }) + .pipe(Effect.flip); + expect(unavailable).toBeInstanceOf(PreviewAutomationNoAvailableHostError); + + const replacementRequests = requestsFrom(yield* broker.connect(makeHost())); + yield* Stream.runForEach(replacementRequests, (request) => + broker.respond({ + clientId: "client-1", + connectionId: request.connectionId, + requestId: request.requestId, + ok: true, + result: "reconnected", + }), + ).pipe(Effect.forkScoped); + yield* Effect.yieldNow; + + expect(yield* broker.invoke({ scope, operation: "status", input: {} })).toBe( + "reconnected", + ); + }), + ), +); + it.effect("routes requests for background threads through an environment-level host", () => Effect.scoped( Effect.gen(function* () { @@ -718,6 +760,76 @@ it.effect("pins a provider session to its initial host despite later focus chang ), ); +it.effect("routes a claimed thread to its host without affecting other threads", () => + Effect.scoped( + Effect.gen(function* () { + const broker = yield* makeBroker; + let claimedConnectionId = ""; + const claimedRequests = requestsFrom( + yield* broker.connect( + makeHost({ clientId: "client-discord", supportedOperations: ["status", "snapshot"] }), + ), + (connectionId) => { + claimedConnectionId = connectionId; + }, + ); + const richerRequests = requestsFrom( + yield* broker.connect( + makeHost({ + clientId: "client-desktop", + supportedOperations: ["status", "snapshot", "evaluate"], + }), + ), + ); + yield* Stream.runForEach(claimedRequests, (request) => + broker.respond({ + clientId: "client-discord", + connectionId: request.connectionId, + requestId: request.requestId, + ok: true, + result: "discord", + }), + ).pipe(Effect.forkScoped); + yield* Stream.runForEach(richerRequests, (request) => + broker.respond({ + clientId: "client-desktop", + connectionId: request.connectionId, + requestId: request.requestId, + ok: true, + result: "desktop", + }), + ).pipe(Effect.forkScoped); + yield* Effect.yieldNow; + + expect(yield* broker.invoke({ scope, operation: "snapshot", input: {} })).toBe( + "desktop", + ); + yield* broker.focusHost({ + clientId: "client-discord", + environmentId: scope.environmentId, + connectionId: claimedConnectionId, + focused: true, + threadId: scope.threadId, + }); + + expect(yield* broker.invoke({ scope, operation: "snapshot", input: {} })).toBe( + "discord", + ); + expect( + yield* broker.invoke({ + scope: { + ...scope, + threadId: ThreadId.make("thread-desktop"), + providerSessionId: "provider-session-desktop", + }, + operation: "snapshot", + input: {}, + }), + ).toBe("desktop"); + }), + ), +); + it.effect("does not route new operations to legacy hosts that did not advertise support", () => Effect.scoped( Effect.gen(function* () { diff --git a/apps/server/src/mcp/PreviewAutomationBroker.ts b/apps/server/src/mcp/PreviewAutomationBroker.ts index 8d92059bde8a..318e740dea8c 100644 --- a/apps/server/src/mcp/PreviewAutomationBroker.ts +++ b/apps/server/src/mcp/PreviewAutomationBroker.ts @@ -116,6 +116,7 @@ interface PreviewAutomationRequestErrorContext { interface BrokerState { readonly clients: ReadonlyMap; readonly assignments: ReadonlyMap; + readonly threadClaims: ReadonlyMap; readonly pending: ReadonlyMap; readonly requestSequence: number; readonly focusSequence: number; @@ -128,19 +129,23 @@ const removeConnectionFromState = ( ): { readonly state: BrokerState; readonly disconnected: ReadonlyArray } => { const clients = new Map(current.clients); const assignments = new Map(current.assignments); + const threadClaims = new Map(current.threadClaims); const pending = new Map(current.pending); const disconnected: PendingRequest[] = []; if (current.clients.get(clientId)?.queue === queue) clients.delete(clientId); for (const [assignmentKey, assignment] of assignments) { if (assignment.queue === queue) assignments.delete(assignmentKey); } + for (const [claimKey, claim] of threadClaims) { + if (claim.queue === queue) threadClaims.delete(claimKey); + } for (const [requestId, entry] of pending) { if (entry.queue !== queue) continue; pending.delete(requestId); disconnected.push(entry); } return { - state: { ...current, clients, assignments, pending }, + state: { ...current, clients, assignments, threadClaims, pending }, disconnected, }; }; @@ -161,6 +166,11 @@ const selectorDiagnosticsFromInput = ( const hostAssignmentKey = (scope: McpInvocationContext.McpInvocationScope): string => `${scope.environmentId}\u0000${scope.providerSessionId}`; +const threadClaimKey = ( + environmentId: McpInvocationContext.McpInvocationScope["environmentId"], + threadId: McpInvocationContext.McpInvocationScope["threadId"], +): string => `${environmentId}\u0000${threadId}`; + const isPreviewTabId = Schema.is(PreviewTabId); const readResultTabId = (result: unknown): PreviewTabId | null | undefined => { @@ -318,6 +328,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() { const state = yield* SynchronizedRef.make({ clients: new Map(), assignments: new Map(), + threadClaims: new Map(), pending: new Map(), requestSequence: 0, focusSequence: 0, @@ -412,6 +423,13 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() { return current; } const clients = new Map(current.clients); + if (host.threadId !== undefined) { + const threadClaims = new Map(current.threadClaims); + const claimKey = threadClaimKey(host.environmentId, host.threadId); + if (host.focused) threadClaims.set(claimKey, currentHost); + else threadClaims.delete(claimKey); + return { ...current, threadClaims }; + } const focusSequence = host.focused ? current.focusSequence + 1 : current.focusSequence; clients.set(host.clientId, { ...currentHost, @@ -470,29 +488,38 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() { const assigned = assignments.get(assignmentKey); const assignedConnection = assigned ? current.clients.get(assigned.clientId) : undefined; const hasLiveAssignment = assignedConnection?.environmentId === input.scope.environmentId; - // Keep one provider session on one physical desktop runtime so a - // multi-step browser interaction cannot jump between independent - // Electron cookie/DOM state. A live assignment that predates an - // operation is not silently moved to a newer client: the caller gets a - // capability failure and can deliberately start a fresh provider - // session. A dead lease is pruned above and may fail over. + const claimedConnection = current.threadClaims.get( + threadClaimKey(input.scope.environmentId, input.scope.threadId), + ); + const hasLiveClaim = + claimedConnection?.environmentId === input.scope.environmentId && + current.clients.get(claimedConnection.clientId)?.connectionId === + claimedConnection.connectionId; + // Keep a provider session on one physical runtime so a multi-step + // interaction cannot jump between independent cookie/DOM state. An + // explicit thread claim intentionally overrides that pin; this lets a + // headless bridge select its own host before dispatching a turn. const connection = - hasLiveAssignment && supportsOperation(assignedConnection, input.operation) - ? assignedConnection - : hasLiveAssignment + hasLiveClaim && supportsOperation(claimedConnection, input.operation) + ? claimedConnection + : hasLiveClaim ? undefined - : Array.from(current.clients.values()) - .filter( - (host) => - host.environmentId === input.scope.environmentId && - supportsOperation(host, input.operation), - ) - .sort( - (left, right) => - right.supportedOperations.size - left.supportedOperations.size || - Number(right.focused) - Number(left.focused) || - right.focusOrder - left.focusOrder, - )[0]; + : hasLiveAssignment && supportsOperation(assignedConnection, input.operation) + ? assignedConnection + : hasLiveAssignment + ? undefined + : Array.from(current.clients.values()) + .filter( + (host) => + host.environmentId === input.scope.environmentId && + supportsOperation(host, input.operation), + ) + .sort( + (left, right) => + right.supportedOperations.size - left.supportedOperations.size || + Number(right.focused) - Number(left.focused) || + right.focusOrder - left.focusOrder, + )[0]; if (!connection) { if (!hasLiveAssignment) assignments.delete(assignmentKey); return [undefined, { ...current, assignments }] as const; @@ -574,10 +601,15 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() { return yield* new PreviewAutomationRequestQueueClosedError(requestContext); } const result = yield* Deferred.await(deferred).pipe(Effect.timeoutOption(timeoutMs)); - return yield* Option.match(result, { - onNone: () => Effect.fail(new PreviewAutomationTimeoutError(requestContext)), - onSome: (value) => Effect.succeed(value as A), - }); + if (Option.isSome(result)) return result.value as A; + + // A connected host that stops consuming requests otherwise remains the + // authoritative route forever: every later tool call is queued to the + // same dead stream and pays another full timeout. Closing the stream + // makes the client subscription reconnect and lets the replacement host + // register with a fresh connection id. + yield* disconnect(connection.clientId, connection.queue); + return yield* new PreviewAutomationTimeoutError(requestContext); }); const result = yield* awaitResponse().pipe(Effect.ensuring(removePending)); if (input.updateCurrentTab === false) return result; diff --git a/apps/server/src/mcp/toolkits/preview/tools.ts b/apps/server/src/mcp/toolkits/preview/tools.ts index 3f80e84e9a59..5e75df8aaa73 100644 --- a/apps/server/src/mcp/toolkits/preview/tools.ts +++ b/apps/server/src/mcp/toolkits/preview/tools.ts @@ -119,7 +119,7 @@ const PreviewSetAppearanceTool = safeBrowserTool( export const PreviewSnapshotTool = readonlyBrowserTool( Tool.make("preview_snapshot", { description: - "Inspect a page before interacting. Pass tabId to inspect a specific tab; omit it to use this agent session's current tab. Returns page state, semantic elements, diagnostics, action history, and a PNG screenshot. Set includeImage=false for text-only output with the same page metadata. Set save=true to also write the PNG to disk and get screenshotPath back; embed that path in your reply as ![alt](screenshotPath) so the user sees it. This is the only way to show the user a screenshot; the image in the tool result is not saved anywhere.", + "Inspect a page before interacting. Pass tabId to inspect a specific tab; omit it to use this agent session's current tab. Returns page state, semantic elements, diagnostics, action history, a PNG screenshot, and a local artifact path when the host supports export. Set includeImage=false for text-only output with the same page metadata. Set save=true to also write the PNG to disk and get screenshotPath back. To show the user a screenshot, embed the exported path or screenshotPath as ![alt](path); the image in the tool result is not saved anywhere unless save=true or the host already exported a path.", parameters: Schema.Struct({ ...PreviewAutomationTabTargetInput.fields, includeImage: Schema.optional( diff --git a/apps/server/src/ntbs/ExchangeRepository.test.ts b/apps/server/src/ntbs/ExchangeRepository.test.ts new file mode 100644 index 000000000000..518395b0e1e0 --- /dev/null +++ b/apps/server/src/ntbs/ExchangeRepository.test.ts @@ -0,0 +1,304 @@ +import { describe, expect, it } from "@effect/vitest"; +import { Effect, Exit } from "effect"; +import { MessageId, ProjectId, ThreadId, TurnId } from "@t3tools/contracts"; +import { + ExchangeRepositoryError, + ExchangeRepository, + inMemoryExchangeRepository, +} from "./ExchangeRepository.ts"; +import { + makeRequestAccepted, + toReplyPending, + toReplyPosted, + toThreadCreated, + toUndeliverable, + toWorkPlanned, + type Reply, +} from "./exchange.ts"; + +const now = 1_700_000_000_000; + +const makeAccepted = (sourceUri: string) => + makeRequestAccepted( + { sourceUri, snapshot: "request", attachments: [] }, + { projectId: ProjectId.make("project"), startBranchName: "main" }, + now, + ); + +const makeExchange = (sourceUri: string, threadId: string) => + toWorkPlanned( + makeAccepted(sourceUri), + { + projectId: ProjectId.make("project"), + startBranchName: "main", + startCommitSha: "start-commit-sha", + threadId: ThreadId.make(threadId), + userMessageId: MessageId.make(`message-${threadId}`), + worktreeBranchName: `branch-${threadId}`, + }, + now, + ); + +const answerFrom = (threadId: string, text: string): Reply => ({ + type: "answer", + text, + threadId: ThreadId.make(threadId), + userMessageId: MessageId.make(`message-${threadId}`), + turnId: TurnId.make(`turn-${threadId}`), +}); + +describe("inMemoryExchangeRepository", () => { + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("allows the same sourceUri to advance its state", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const planned = makeExchange("test://request/1", "thread-1"); + const threadCreated = toThreadCreated(planned, now); + + yield* repository.upsert(planned); + yield* repository.upsert(threadCreated); + + expect(yield* repository.findBySourceUri(planned.sourceUri)).toEqual(threadCreated); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("allows the same state to be rewritten", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const planned = makeExchange("test://request/1", "thread-1"); + + yield* repository.upsert(planned); + yield* repository.upsert(planned); + + expect(yield* repository.findBySourceUri(planned.sourceUri)).toEqual(planned); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("refuses a replacement that is not an update of the stored exchange", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const planned = makeExchange("test://request/1", "thread-1"); + const threadCreated = toThreadCreated(planned, now); + const replyPending = toReplyPending(threadCreated, answerFrom("thread-1", "reply"), now); + const posted = toReplyPosted(replyPending, "test://reply/1", now); + + yield* repository.upsert(threadCreated); + const backwards = yield* Effect.flip(repository.upsert(planned)); + expect(backwards).toBeInstanceOf(ExchangeRepositoryError); + + const skippingAhead = yield* Effect.flip(repository.upsert(posted)); + expect(skippingAhead).toBeInstanceOf(ExchangeRepositoryError); + + yield* repository.upsert(replyPending); + yield* repository.upsert(posted); + const afterTerminal = yield* Effect.flip(repository.upsert(threadCreated)); + expect(afterTerminal).toBeInstanceOf(ExchangeRepositoryError); + + expect(yield* repository.findBySourceUri(planned.sourceUri)).toEqual(posted); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("rejects a threadId already owned by another sourceUri", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const existing = makeExchange("test://request/1", "shared-thread"); + const conflicting = makeExchange("test://request/2", "shared-thread"); + + yield* repository.upsert(existing); + const error = yield* Effect.flip(repository.upsert(conflicting)); + + expect(error).toBeInstanceOf(ExchangeRepositoryError); + expect(error.reason).toContain(existing.t3.threadId); + expect(yield* repository.findBySourceUri(existing.sourceUri)).toEqual(existing); + expect(yield* repository.findBySourceUri(conflicting.sourceUri)).toBeNull(); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("keeps a replied exchange's thread out of reach of other sourceUris", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const replied = toReplyPending( + toThreadCreated(makeExchange("test://request/1", "shared-thread"), now), + answerFrom("shared-thread", "done"), + now, + ); + const conflicting = makeExchange("test://request/2", "shared-thread"); + + yield* repository.upsert(replied); + const error = yield* Effect.flip(repository.upsert(conflicting)); + + expect(error).toBeInstanceOf(ExchangeRepositoryError); + expect(yield* repository.findBySourceUri(conflicting.sourceUri)).toBeNull(); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("finds an exchange by threadId", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const planned = makeExchange("test://request/1", "thread-1"); + const threadCreated = toThreadCreated(planned, now); + const replyPending = toReplyPending( + threadCreated, + answerFrom("thread-1", "posted reply"), + now, + ); + const posted = toReplyPosted(replyPending, "test://reply/1", now); + + yield* repository.upsert(planned); + + expect(yield* repository.findByThreadId(planned.t3.threadId)).toEqual(planned); + expect(yield* repository.findByThreadId(ThreadId.make("unknown-thread"))).toBeNull(); + + yield* repository.upsert(threadCreated); + yield* repository.upsert(replyPending); + yield* repository.upsert(posted); + + expect(yield* repository.findByThreadId(planned.t3.threadId)).toEqual(posted); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("finds a thread only once its exchange has been planned", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const planned = makeExchange("test://request/1", "thread-1"); + + yield* repository.upsert(makeAccepted(planned.sourceUri)); + expect(yield* repository.findByThreadId(planned.t3.threadId)).toBeNull(); + + yield* repository.upsert(planned); + expect(yield* repository.findByThreadId(planned.t3.threadId)).toEqual(planned); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("finds only non-terminal exchanges", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const accepted = makeAccepted("test://request/accepted"); + const planned = makeExchange("test://request/planned", "thread-planned"); + const threadCreated = toThreadCreated( + makeExchange("test://request/thread-created", "thread-created"), + now, + ); + const replyPending = toReplyPending( + toThreadCreated( + makeExchange("test://request/reply-pending", "thread-reply-pending"), + now, + ), + answerFrom("thread-reply-pending", "pending reply"), + now, + ); + const replyPosted = toReplyPosted( + toReplyPending( + toThreadCreated( + makeExchange("test://request/reply-posted", "thread-reply-posted"), + now, + ), + answerFrom("thread-reply-posted", "posted reply"), + now, + ), + "test://reply/posted", + now, + ); + const undeliverable = toUndeliverable( + toReplyPending( + toThreadCreated( + makeExchange("test://request/undeliverable", "thread-undeliverable"), + now, + ), + answerFrom("thread-undeliverable", "undeliverable reply"), + now, + ), + { message: "platform rejected the reply" }, + now, + ); + + yield* Effect.forEach( + [accepted, planned, threadCreated, replyPending, replyPosted, undeliverable], + repository.upsert, + ); + + const results = yield* repository.findNonTerminalExchanges; + + expect(results).toHaveLength(4); + expect(results).toEqual( + expect.arrayContaining([accepted, planned, threadCreated, replyPending]), + ); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("preserves existing records when a replacement has a conflicting threadId", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const first = makeExchange("test://request/1", "thread-1"); + const second = makeExchange("test://request/2", "thread-2"); + const conflictingReplacement = makeExchange("test://request/2", "thread-1"); + + yield* repository.upsert(first); + yield* repository.upsert(second); + yield* Effect.flip(repository.upsert(conflictingReplacement)); + + expect(yield* repository.findBySourceUri(first.sourceUri)).toEqual(first); + expect(yield* repository.findBySourceUri(second.sourceUri)).toEqual(second); + expect(yield* repository.findByThreadId(first.t3.threadId)).toEqual(first); + expect(yield* repository.findByThreadId(second.t3.threadId)).toEqual(second); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("moves its thread index when a replacement names a different thread", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const original = makeExchange("test://request/1", "thread-1"); + const replacement = makeExchange("test://request/1", "thread-2"); + + yield* repository.upsert(original); + yield* repository.upsert(replacement); + + expect(yield* repository.findByThreadId(original.t3.threadId)).toBeNull(); + expect(yield* repository.findByThreadId(replacement.t3.threadId)).toEqual(replacement); + }), + ); + }); + + it.layer(inMemoryExchangeRepository)((it) => { + it.effect("atomically rejects concurrent upserts with the same threadId", () => + Effect.gen(function* () { + const repository = yield* ExchangeRepository; + const first = makeExchange("test://request/1", "shared-thread"); + const second = makeExchange("test://request/2", "shared-thread"); + + const outcomes = yield* Effect.all( + [Effect.exit(repository.upsert(first)), Effect.exit(repository.upsert(second))], + { concurrency: "unbounded" }, + ); + + expect(outcomes.filter(Exit.isSuccess)).toHaveLength(1); + expect(outcomes.filter(Exit.isFailure)).toHaveLength(1); + + const stored = yield* Effect.all([ + repository.findBySourceUri(first.sourceUri), + repository.findBySourceUri(second.sourceUri), + ]); + + expect(stored.filter((state) => state !== null)).toHaveLength(1); + }), + ); + }); +}); diff --git a/apps/server/src/ntbs/ExchangeRepository.ts b/apps/server/src/ntbs/ExchangeRepository.ts new file mode 100644 index 000000000000..fb861abf8e5e --- /dev/null +++ b/apps/server/src/ntbs/ExchangeRepository.ts @@ -0,0 +1,167 @@ +/* + * Defines the repository for durable NTBS exchanges. + * + * An exchange links an admitted external-platform request to its planned T3 + * work and tracks its progress through delivery of the eventual reply. + * + * The repository owns persistence, lookup, and recovery. Each stored exchange + * is identified by its `sourceUri`, while the processor decides how to handle + * duplicate requests. It does not communicate with T3 or the originating + * platform. + */ +import { Array, Effect, Context, Data, HashMap, Ref, Layer, Result } from "effect"; +import { + getThreadId, + isNonTerminal, + isUpdateOf, + type Exchange, + type NonTerminalExchange, +} from "./exchange.ts"; +import type { ThreadId } from "@t3tools/contracts"; +import { isSome } from "effect/Option"; + +export class ExchangeRepositoryError extends Data.TaggedError("ExchangeRepositoryError")<{ + readonly reason: string; + readonly cause: unknown; +}> {} + +export interface ExchangeRepository { + readonly findBySourceUri: ( + sourceUri: string, + ) => Effect.Effect; + + readonly findByThreadId: ( + threadId: ThreadId, + ) => Effect.Effect; + + readonly findNonTerminalExchanges: Effect.Effect< + ReadonlyArray, + ExchangeRepositoryError + >; + + /** + * Inserts or replaces the exchange identified by its `sourceUri`, as long as it is a legal update of the stored one and the thread it refers to does not already belong to another exchange. + * + * The checks and the write are atomic, so of two conflicting concurrent upserts at most one succeeds. + */ + readonly upsert: (exchange: Exchange) => Effect.Effect; +} + +export const ExchangeRepository = Context.Service( + "t3code/ntbs/ExchangeRepository", +); + +/** The in-memory store: every exchange by its `sourceUri`, plus the thread index. */ +type StoredExchanges = { + readonly bySourceUri: HashMap.HashMap; + readonly byThreadId: HashMap.HashMap; +}; + +const inMemoryER: Effect.Effect = Effect.gen(function* () { + const state = yield* Ref.make({ + bySourceUri: HashMap.empty(), + // An index over the same exchanges: rule 2 of `validate` keeps at most one per thread. + byThreadId: HashMap.empty(), + }); + + /** Whether `exchange` may be written into `state`, with the reason when it may not. */ + const validate = ( + state: StoredExchanges, + exchange: Exchange, + ): Result.Result => { + // Rule 1: a stored exchange may only be replaced by an update of itself. + const previous = HashMap.get(state.bySourceUri, exchange.sourceUri); + + if (isSome(previous) && !isUpdateOf(exchange, previous.value)) { + return Result.fail( + new ExchangeRepositoryError({ + reason: `Exchange ${exchange.sourceUri} cannot move from ${previous.value.tag} to ${exchange.tag}`, + cause: { sourceUri: exchange.sourceUri, from: previous.value.tag, to: exchange.tag }, + }), + ); + } + + // Rule 2: the thread an exchange refers to may not belong to another exchange. + const threadId = getThreadId(exchange); + + if (threadId === null) { + return Result.void; + } + + const owner = HashMap.get(state.byThreadId, threadId); + + if (isSome(owner) && owner.value.sourceUri !== exchange.sourceUri) { + return Result.fail( + new ExchangeRepositoryError({ + reason: `Thread ${threadId} already belongs to exchange ${owner.value.sourceUri}`, + cause: { + threadId, + existingSourceUri: owner.value.sourceUri, + incomingSourceUri: exchange.sourceUri, + }, + }), + ); + } + + return Result.void; + }; + + // Validating and writing share one modify, so concurrent upserts cannot both pass. + const upsert = Effect.fn("ExchangeRepository.upsert")((exchange: Exchange) => + state.pipe( + Ref.modify( + (current): readonly [Result.Result, StoredExchanges] => { + const result = validate(current, exchange); + + if (Result.isFailure(result)) { + return [result, current]; + } + + const previous = HashMap.get(current.bySourceUri, exchange.sourceUri); + const previousThreadId = isSome(previous) ? getThreadId(previous.value) : null; + const threadId = getThreadId(exchange); + + let byThreadId = current.byThreadId; + + if (previousThreadId !== null && previousThreadId !== threadId) { + byThreadId = HashMap.remove(byThreadId, previousThreadId); + } + + if (threadId !== null) { + byThreadId = HashMap.set(byThreadId, threadId, exchange); + } + + return [ + result, + { + bySourceUri: HashMap.set(current.bySourceUri, exchange.sourceUri, exchange), + byThreadId, + }, + ]; + }, + ), + Effect.flatMap(Effect.fromResult), + ), + ); + + const findBySourceUri = (uri: string) => + Ref.get(state).pipe( + Effect.map(({ bySourceUri }) => HashMap.get(bySourceUri, uri)), + Effect.map((o) => (isSome(o) ? o.value : null)), + ); + + const findByThreadId = (threadId: ThreadId) => + Ref.get(state).pipe( + Effect.map(({ byThreadId }) => HashMap.get(byThreadId, threadId)), + Effect.map((o) => (isSome(o) ? o.value : null)), + ); + + const findNonTerminalExchanges = Ref.get(state).pipe( + Effect.map(({ bySourceUri }) => Array.fromIterable(HashMap.values(bySourceUri))), + Effect.map(Array.filter(isNonTerminal)), + ); + + return { upsert, findBySourceUri, findByThreadId, findNonTerminalExchanges }; +}); + +export const inMemoryExchangeRepository = Layer.effect(ExchangeRepository, inMemoryER); diff --git a/apps/server/src/ntbs/adapter.ts b/apps/server/src/ntbs/adapter.ts new file mode 100644 index 000000000000..bff0db7bfe5b --- /dev/null +++ b/apps/server/src/ntbs/adapter.ts @@ -0,0 +1,61 @@ +/* + This file describes the adapter: the interface through external platforms like Jira/Linear/etc interact with T3. + + The adapter is platform-agnostic. Each platform needs to expose its own. +*/ +import type { ReplyPending, ThreadCreated, UndeliverableCause } from "./exchange.ts"; +import { Context, Data, Effect } from "effect"; + +/** + * A platform operation failed without establishing that reply delivery is + * permanently impossible. The processor may retry the operation later. + */ +export class AdapterError extends Data.TaggedError("AdapterError")<{ + readonly reason: string; + readonly cause: unknown; +}> {} + +/** The platform definitively rejected delivery of a pending reply. */ +export class ReplyRejected extends Data.TaggedError("ReplyRejected")<{ + readonly cause: UndeliverableCause; +}> {} + +/** + * Defines the platform-specific operations used by the shared NTBS processor. + * + * An adapter communicates with one originating platform. It posts + * acknowledgements and replies, and can discover whether a particular pending + * reply was already posted. It does not persist exchange state, create T3 + * threads, or interpret T3 events. + */ +export interface NTBSAdapter { + /** + * Posts a best-effort working acknowledgement for an exchange whose T3 + * thread now exists. The acknowledgement is not part of the durable exchange + * lifecycle and its platform identifier is not retained. + */ + readonly acknowledge: (state: ThreadCreated) => Effect.Effect; + + /** + * Posts the exact reply stored in `state` to the destination identified by + * its `sourceUri`. + * + * Returns an adapter-encoded URI locating the posted reply. `ReplyRejected` + * means the platform definitively refused delivery; other failures remain + * retryable. + */ + readonly postReply: (state: ReplyPending) => Effect.Effect; + + /** + * Searches for the exact pending reply in case it was posted before the + * corresponding `ReplyPosted` state could be persisted. + * + * Returns its adapter-encoded source URI when found, or `null` otherwise. + */ + readonly findPostedReply: (state: ReplyPending) => Effect.Effect; +} + +/** + * One tag for every platform. A processor resolves its adapter from the context it is built in, so each one is given the implementation for its own platform. + */ +export const NTBSAdapter = Context.Service("t3code/ntbs/adapter"); diff --git a/apps/server/src/ntbs/exchange.test.ts b/apps/server/src/ntbs/exchange.test.ts new file mode 100644 index 000000000000..af3b8f7c58f3 --- /dev/null +++ b/apps/server/src/ntbs/exchange.test.ts @@ -0,0 +1,334 @@ +import { describe, expect, it } from "@effect/vitest"; +import { Duration } from "effect"; +import { + fromReplyPending, + fromRequestAccepted, + fromThreadCreated, + fromWorkPlanned, + getThreadId, + isExpired, + isUpdateOf, + makeRequestAccepted, + toExpired, + toRejected, + toReplyPending, + toReplyPosted, + toThreadCreated, + toUndeliverable, + toWorkPlanned, + type Exchange, + type ExchangeBase, + type NonTerminalExchange, + type ReplyPosted, + type Request, + type RequestAccepted, + type T3Target, + type ThreadCreated, + type TurnCoordinates, + type WorkCoordinates, +} from "./exchange.ts"; +import { MessageId, ProjectId, ThreadId, TurnId } from "@t3tools/contracts"; + +const request = { + sourceUri: "test://exchange/test", + snapshot: "You need to imagine some text here", + attachments: [], +} satisfies Request; + +const target = { + projectId: ProjectId.make("projectId"), + startBranchName: "startBranchName", +} satisfies T3Target; + +const coordinates = { + projectId: target.projectId, + startBranchName: target.startBranchName, + startCommitSha: "startCommitSha", + threadId: ThreadId.make("threadId"), + userMessageId: MessageId.make("messageId"), + worktreeBranchName: "worktreeBranchName", +} satisfies WorkCoordinates; + +const turn = { + threadId: coordinates.threadId, + userMessageId: coordinates.userMessageId, + turnId: TurnId.make("turnId"), +} satisfies TurnCoordinates; + +const now = 1_700_000_000_000; +// Past every state's deadline. +const later = now + Duration.toMillis(Duration.hours(2)); + +const exchangeBase = { ...request, target, createdAt: now, updatedAt: now } satisfies ExchangeBase; + +const rejection = { reason: "T3 said no", method: "someT3Call" }; + +const accepted = makeRequestAccepted(request, target, now); +const planned = toWorkPlanned(accepted, coordinates, now); +const threadCreated = toThreadCreated(planned, now); +const answer = { type: "answer", text: "The turn's final answer", ...turn } as const; + +describe("RequestAccepted", () => { + it("makeRequestAccepted tags the request and target, nothing from T3", () => { + expect(accepted).toEqual({ ...exchangeBase, tag: "request-accepted" }); + }); + + it("toWorkPlanned adds the coordinates", () => { + expect(planned).toEqual({ ...exchangeBase, tag: "work-planned", t3: coordinates }); + }); + + it("a transition stamps updatedAt and keeps createdAt", () => { + expect(toWorkPlanned(accepted, coordinates, later)).toEqual({ + ...exchangeBase, + updatedAt: later, + tag: "work-planned", + t3: coordinates, + }); + }); + + it.each([ + [now, { type: "plan" }], + [later, { type: "expire" }], + ] as const)("decides at %d -> %j", (at, expected) => { + expect(fromRequestAccepted(accepted, at)).toEqual(expected); + }); + + it("a planning rejection becomes a failure reply with no T3 context", () => { + expect(toRejected(accepted, rejection, now)).toEqual({ + ...exchangeBase, + tag: "reply-pending", + reply: { + type: "failure", + text: rejection.reason, + cause: { type: "rejected", method: rejection.method, state: { tag: "request-accepted" } }, + }, + }); + }); + + it("expiry becomes a failure reply with no T3 context", () => { + expect(toExpired(accepted, later)).toEqual({ + ...exchangeBase, + updatedAt: later, + tag: "reply-pending", + reply: { + type: "failure", + text: "T3 did not answer in time.", + cause: { type: "expired", state: { tag: "request-accepted" } }, + }, + }); + }); +}); + +describe("WorkPlanned", () => { + // missing thread -> provision it, unless expired; present thread -> record it, even when expired; unknown thread -> wait, unless expired + it.each([ + [{ thread: "missing" }, now, { type: "provision-thread" }], + [{ thread: "present" }, now, { type: "record-thread-created" }], + [{ thread: "unknown" }, now, { type: "wait" }], + [{ thread: "missing" }, later, { type: "expire" }], + [{ thread: "present" }, later, { type: "record-thread-created" }], + [{ thread: "unknown" }, later, { type: "expire" }], + ] as const)("decides %j at %d -> %j", (context, at, expected) => { + expect(fromWorkPlanned(planned, context, at)).toEqual(expected); + }); + + it("toThreadCreated retags and carries the coordinates forward", () => { + expect(threadCreated).toEqual({ ...exchangeBase, tag: "thread-created", t3: coordinates }); + }); + + it("a provisioning rejection keeps the planned coordinates inside the reply only", () => { + expect(toRejected(planned, rejection, now)).toEqual({ + ...exchangeBase, + tag: "reply-pending", + reply: { + type: "failure", + text: rejection.reason, + cause: { + type: "rejected", + method: rejection.method, + state: { tag: "work-planned", t3: coordinates }, + }, + }, + }); + }); + + it("expiry keeps the planned coordinates inside the reply only", () => { + expect(toExpired(planned, later).reply).toEqual({ + type: "failure", + text: "T3 did not answer in time.", + cause: { type: "expired", state: { tag: "work-planned", t3: coordinates } }, + }); + }); +}); + +describe("ThreadCreated", () => { + // missing turn -> start it; active or unknown turn -> wait; all three expire; completed turn -> record its reply, even when expired + it.each([ + [{ turn: "missing" }, now, { type: "start-turn" }], + [{ turn: "active" }, now, { type: "wait" }], + [{ turn: "unknown" }, now, { type: "wait" }], + [{ turn: "completed", reply: answer }, now, { type: "record-reply-pending", reply: answer }], + [{ turn: "missing" }, later, { type: "expire" }], + [{ turn: "active" }, later, { type: "expire" }], + [{ turn: "unknown" }, later, { type: "expire" }], + [{ turn: "completed", reply: answer }, later, { type: "record-reply-pending", reply: answer }], + ] as const)("decides %j at %d -> %j", (context, at, expected) => { + expect(fromThreadCreated(threadCreated, context, at)).toEqual(expected); + }); + + it("completed turn's reply lands in ReplyPending verbatim and drops the coordinates", () => { + expect(toReplyPending(threadCreated, answer, now)).toEqual({ + ...exchangeBase, + tag: "reply-pending", + reply: answer, + }); + }); + + it("a turn-start rejection keeps the coordinates inside the reply only", () => { + expect(toRejected(threadCreated, rejection, now).reply).toEqual({ + type: "failure", + text: rejection.reason, + cause: { + type: "rejected", + method: rejection.method, + state: { tag: "thread-created", t3: coordinates }, + }, + }); + }); + + it("expiry keeps the coordinates inside the reply only", () => { + expect(toExpired(threadCreated, later).reply).toEqual({ + type: "failure", + text: "T3 did not answer in time.", + cause: { type: "expired", state: { tag: "thread-created", t3: coordinates } }, + }); + }); +}); + +describe("ReplyPending", () => { + const replyPending = toReplyPending(threadCreated, answer, now); + + // missing platform reply -> post it, unless expired; posted -> record its message id, even when expired; unknown -> wait, unless expired + it.each([ + [{ platformReply: "missing" }, now, { type: "post-reply" }], + [{ platformReply: "unknown" }, now, { type: "wait" }], + [ + { platformReply: "posted", replySourceUri: "test://exchange/reply" }, + now, + { type: "record-reply-posted", replySourceUri: "test://exchange/reply" }, + ], + [{ platformReply: "missing" }, later, { type: "expire" }], + [{ platformReply: "unknown" }, later, { type: "expire" }], + [ + { platformReply: "posted", replySourceUri: "test://exchange/reply" }, + later, + { type: "record-reply-posted", replySourceUri: "test://exchange/reply" }, + ], + ] as const)("decides %j at %d -> %j", (context, at, expected) => { + expect(fromReplyPending(replyPending, context, at)).toEqual(expected); + }); + + it("accepted delivery lands in ReplyPosted with the platform message id", () => { + expect(toReplyPosted(replyPending, "test://exchange/reply", now)).toEqual({ + ...exchangeBase, + tag: "reply-posted", + reply: answer, + replySourceUri: "test://exchange/reply", + }); + }); + + it("definitive rejection lands in Undeliverable with the reply and cause", () => { + const cause = { message: "original message was deleted" } as const; + expect(toUndeliverable(replyPending, cause, now)).toEqual({ + ...exchangeBase, + tag: "undeliverable", + reply: answer, + cause, + }); + }); +}); + +describe("isExpired", () => { + const replyPending = toReplyPending(threadCreated, answer, now); + + it.each<[string, NonTerminalExchange]>([ + ["request-accepted", accepted], + ["work-planned", planned], + ["thread-created", threadCreated], + ["reply-pending", replyPending], + ])("%s is fresh at its own updatedAt and expired two hours later", (_, state) => { + expect(isExpired(state, now)).toBe(false); + expect(isExpired(state, later)).toBe(true); + }); +}); + +describe("isUpdateOf", () => { + const replyPending = toReplyPending(threadCreated, answer, now); + const posted = toReplyPosted(replyPending, "test://exchange/reply", now); + const undeliverable = toUndeliverable(replyPending, { message: "gone" }, now); + + it.each<[string, Exchange, Exchange]>([ + ["the same state rewritten", accepted, accepted], + ["accepted -> planned", planned, accepted], + ["accepted -> reply-pending", toRejected(accepted, rejection, now), accepted], + ["planned -> thread-created", threadCreated, planned], + ["planned -> reply-pending", toRejected(planned, rejection, now), planned], + ["thread-created -> reply-pending", replyPending, threadCreated], + ["reply-pending -> reply-posted", posted, replyPending], + ["reply-pending -> undeliverable", undeliverable, replyPending], + ])("accepts %s", (_, next, previous) => { + expect(isUpdateOf(next, previous)).toBe(true); + }); + + it.each<[string, Exchange, Exchange]>([ + ["going back", planned, threadCreated], + ["skipping ahead", threadCreated, accepted], + ["moving a posted reply", replyPending, posted], + ["moving an undeliverable reply", posted, undeliverable], + ["another exchange", { ...planned, sourceUri: "test://exchange/other" }, accepted], + ])("refuses %s", (_, next, previous) => { + expect(isUpdateOf(next, previous)).toBe(false); + }); +}); + +describe("getThreadId", () => { + const settled = { + type: "failure", + text: "T3 failed", + cause: { type: "settled", ...turn }, + } as const; + + it.each<[string, Exchange, ThreadId | null]>([ + ["nothing before planning", accepted, null], + ["the coordinates while planned", planned, coordinates.threadId], + ["the coordinates while the thread exists", threadCreated, coordinates.threadId], + ["the answer's thread", toReplyPending(threadCreated, answer, now), turn.threadId], + ["a settled failure's thread", toReplyPending(threadCreated, settled, now), turn.threadId], + ["nothing for a planning rejection", toRejected(accepted, rejection, now), null], + [ + "the planned thread for a later rejection", + toRejected(planned, rejection, now), + coordinates.threadId, + ], + ["nothing for a planning expiry", toExpired(accepted, later), null], + ["the planned thread for a later expiry", toExpired(planned, later), coordinates.threadId], + ])("finds %s", (_, exchange, expected) => { + expect(getThreadId(exchange)).toBe(expected); + }); +}); + +/* +Type-level: forward-only is structural. Never executed — typecheck enforces +these. If an `@ts-expect-error` stops erroring, a constructor's input type +widened and the forward-only guarantee broke. +*/ +const _forwardOnly = (posted: ReplyPosted, accepted: RequestAccepted, created: ThreadCreated) => { + // @ts-expect-error terminal states cannot re-enter thread creation + toThreadCreated(posted, now); + // @ts-expect-error a bare acceptance cannot record a posted reply + toReplyPosted(accepted, "reply://msg", now); + // @ts-expect-error Undeliverable is entered only from ReplyPending + toUndeliverable(accepted, { message: "cause" }, now); + // @ts-expect-error planning happens once, before the thread exists + toWorkPlanned(created, coordinates, now); +}; diff --git a/apps/server/src/ntbs/exchange.ts b/apps/server/src/ntbs/exchange.ts new file mode 100644 index 000000000000..19c789adae98 --- /dev/null +++ b/apps/server/src/ntbs/exchange.ts @@ -0,0 +1,599 @@ +/* + This file defines the basics of the exchange model and its business rules: + one admitted external request, its T3 work, and delivery of the eventual reply back to the originating platform. + + Everything in this file is data structures or pure business logic. +*/ +import type { ChatAttachment, MessageId, ProjectId, ThreadId, TurnId } from "@t3tools/contracts"; +import { Duration } from "effect"; + +export type Request = { + /** + * Adapter-encoded URI locating the originating platform message, + * e.g. `discord:////` or + * `jira:///issue//comment/`. + * + * Two contracts: + * + * Identity — the same platform request must carry the same string + * across redeliveries and restarts; distinct requests must carry + * distinct strings. This is the durable dedup key `findBySourceUri` + * looks up, the key the processor serializes concurrent deliveries + * on, and the natural unique key for the repository's stored records. + * + * Addressability — it must contain everything needed to reach the + * message through the platform API from a cold start, because + * recovery reposts with only the stored record. A Discord message + * ID alone fails this: replying requires the channel ID too. + * + * Only the adapter that wrote it may parse it; the processor treats + * it as an opaque string. + */ + readonly sourceUri: string; + /** + * The captured source text sent as the first T3 user message. + * Platform independent. + * Must not exceed T3's 120,000-character input limit. + */ + readonly snapshot: string; + /** + * References to attachments stored by T3 and sent with the first user message. + * The processor creates them from attachment data provided by the adapter. + */ + readonly attachments: ReadonlyArray; +}; + +/** + * Describes _where_ the T3 work goes. Set by the platform-specific inbound code. + */ +export type T3Target = { + readonly projectId: ProjectId; + /** + * The starting point for the thread's worktree: the new branch is created from this one. + * + * Must be a branch that exists on `origin`; it is resolved there, so the worktree starts from the + * latest remote commit even when the local copy is behind. Tags, commit SHAs and local-only + * branches are rejected. + */ + readonly startBranchName: string; +}; + +/** + * Stable identities and pinned Git state needed to resume an exchange. + * + * Filesystem locations are intentionally excluded: live project state identifies + * the repository, and `worktreeBranchName` identifies any checkout created for + * the exchange. The thread records the actual checkout path after creation. + */ +export type WorkCoordinates = { + // TODO: Isn't this doubled from T3Target? + readonly projectId: ProjectId; + /** + * The branch this work starts from, and the commit it pointed at on `origin` when the work was planned. + * We keep the same SHA across retries so the request always runs against the code selected when it was planned, even if the branch moves later. The name is recorded as the worktree's merge base for later diff and PR flows. + */ + readonly startBranchName: string; + readonly startCommitSha: string; + // Planned while WorkPlanned; confirmed by ThreadCreated. + readonly threadId: ThreadId; + /** + * The first T3 user message created for this external request. + * This identifies the correct turn and reply even if the thread later receives other messages. + */ + readonly userMessageId: MessageId; + /** The branch minted for this request's worktree. */ + readonly worktreeBranchName: string; +}; + +/** Identifiers locating the T3 turn a reply came out of. */ +export type TurnCoordinates = { + readonly threadId: ThreadId; + readonly userMessageId: MessageId; + readonly turnId: TurnId; +}; + +/** + * Why an exchange ended in a failure reply, with the T3 identifiers that existed when it happened. + * Every variant is plain data so the stored reply survives JSON encoding; diagnostics that are not (the underlying error) are logged where the failure is caught, not stored. + */ +export type FailureCause = + /** + * T3 rejected the one action of the state the exchange was in; `method` names the T3 call that answered. + * `state` is that state reduced to its T3 data: nothing for a rejected target, the planned coordinates otherwise. + */ + | { + readonly type: "rejected"; + readonly method: string; + readonly state: + | Pick + | Pick + | Pick; + } + /** T3 settled the thread without an answer to our message; observed, not a rejection. `turnId` is null when no turn ever adopted the message. */ + | { + readonly type: "settled"; + readonly threadId: ThreadId; + readonly userMessageId: MessageId; + readonly turnId: TurnId | null; + } + /** The state outlived its deadline and its action was given up. `state` is reduced like in `rejected`. */ + | { + readonly type: "expired"; + readonly state: + | Pick + | Pick + | Pick; + }; + +export type ReplyAnswer = TurnCoordinates & { + readonly type: "answer"; + readonly text: string; +}; + +export type ReplyFailure = { + readonly type: "failure"; + readonly text: string; + readonly cause: FailureCause; +}; + +export type ReplyCancellation = TurnCoordinates & { + readonly type: "cancellation"; + readonly text: string; +}; + +/** + * What gets posted back to the platform. Each variant carries the T3 context that produced it, so delivery and audit need nothing else from the exchange. + */ +export type Reply = ReplyAnswer | ReplyFailure | ReplyCancellation; + +export type UndeliverableCause = { + readonly message: string; +}; + +/** + * The data every exchange carries, whatever state it has reached: the request and where its work was meant to go. + */ +export type ExchangeBase = Request & { + readonly target: T3Target; + /** Epoch millis of when the request was recorded, which is when it was accepted. */ + readonly createdAt: number; + /** + * Epoch millis of the last transition. + * The processor never rewrites a state in place, so this is when the current state began. + */ + readonly updatedAt: number; +}; + +/** + * The platform inbound code (Jira Webhook e.g.) admitted the request, + * trigger and actor checks passed, and the processor recorded it. + * + * Nothing in T3 exists yet. From here, the processor alone drives the exchange to a terminal state, and everything that fails from here on becomes a failure reply like any other. + */ +export type RequestAccepted = ExchangeBase & { + readonly tag: "request-accepted"; +}; + +/** + * T3 accepted the target and the identifiers for its work are minted and stored. + * Still nothing created in T3: the thread, worktree and turn come next. + */ +export type WorkPlanned = ExchangeBase & { + readonly tag: "work-planned"; + readonly t3: WorkCoordinates; +}; + +/** + * The planned T3 thread exists. The first turn may not have started yet. Turn existence and progress are T3-owned. + */ +export type ThreadCreated = ExchangeBase & { + readonly tag: "thread-created"; + readonly t3: WorkCoordinates; +}; + +/** + * A reply exists; the exact payload is stored verbatim so every posting attempt sends the same content. + * Reached from any earlier state: a rejection during planning, provisioning or turn start lands here as much as a finished turn does, so this and later states do not imply the thread existed. + * Delivery needs only `sourceUri` and the reply; what T3 produced it lives inside the reply. + */ +export type ReplyPending = ExchangeBase & { + readonly tag: "reply-pending"; + readonly reply: Reply; +}; + +/** + * Terminal state. + * The platform accepted the reply; its message ID is stored. + */ +export type ReplyPosted = ExchangeBase & { + readonly tag: "reply-posted"; + readonly reply: Reply; + readonly replySourceUri: string; +}; + +/** + * Terminal state. + * A finished reply exists, but the platform definitively rejected delivery. + * Stores the undelivered payload and the cause. + * Common causes could be: the original discussion or message has been deleted + * or locked (Jira/Github issue, Discord thread), the bot has been kicked, etc. + * The tombstone keeps dedup intact and stops the processor from retrying forever. + */ +export type Undeliverable = ExchangeBase & { + readonly tag: "undeliverable"; + readonly reply: Reply; + readonly cause: UndeliverableCause; +}; + +/** Exchanges that still have work left to do. */ +export type NonTerminalExchange = RequestAccepted | WorkPlanned | ThreadCreated | ReplyPending; + +/** Exchanges that have finished, with the reply either posted or undeliverable. */ +export type TerminalExchange = ReplyPosted | Undeliverable; + +/** + * One exchange between an external platform and T3, from request acceptance through final-reply delivery. The tag says how far it got; the repository stores the latest value per `sourceUri` so non-terminal exchanges resume after a restart. + */ +export type Exchange = NonTerminalExchange | TerminalExchange; + +export const isTerminal = (state: Exchange): state is TerminalExchange => { + // An exhaustive switch makes new lifecycle states require an explicit classification. + // This way it is impossible to break the program semantics by adding a new state + // and forgetting to deal with it, because it would not typecheck. + switch (state.tag) { + case "reply-posted": + case "undeliverable": + return true; + + case "request-accepted": + case "work-planned": + case "thread-created": + case "reply-pending": + return false; + } +}; + +export const isNonTerminal = (state: Exchange): state is NonTerminalExchange => !isTerminal(state); + +/** The states an exchange may move to from each state; the same table the constructors below enforce in types. */ +const successors: { readonly [Tag in Exchange["tag"]]: ReadonlyArray } = { + "request-accepted": ["work-planned", "reply-pending"], + "work-planned": ["thread-created", "reply-pending"], + "thread-created": ["reply-pending"], + "reply-pending": ["reply-posted", "undeliverable"], + "reply-posted": [], + undeliverable: [], +}; + +/** + * Whether `next` is a later version of the same exchange as `previous`: the same state rewritten, or a state the exchange may legally move to. Going back, skipping ahead, and moving a terminal exchange are all refused. + */ +export const isUpdateOf = (next: Exchange, previous: Exchange): boolean => + next.sourceUri === previous.sourceUri && + (next.tag === previous.tag || successors[previous.tag].includes(next.tag)); + +/** + * How long an exchange may stay in each non-terminal state, in millis, before its action is given up. + * First guesses: planning and provisioning fail on git and the filesystem, a turn on the agent, delivery on the platform. + */ +const deadlines: { readonly [Tag in NonTerminalExchange["tag"]]: number } = { + "request-accepted": Duration.toMillis(Duration.minutes(5)), + "work-planned": Duration.toMillis(Duration.minutes(15)), + "thread-created": Duration.toMillis(Duration.hours(1)), + "reply-pending": Duration.toMillis(Duration.hours(1)), +}; + +export const expiresAt = (state: NonTerminalExchange): number => + state.updatedAt + deadlines[state.tag]; + +/** Whether the current state has reached its deadline. */ +export const isExpired = (state: NonTerminalExchange, now: number): boolean => + now >= expiresAt(state); + +const getThreadIdFromFailure = (cause: FailureCause): ThreadId | null => { + switch (cause.type) { + case "settled": + return cause.threadId; + + case "rejected": + case "expired": + return "t3" in cause.state ? cause.state.t3.threadId : null; + } +}; + +const getThreadIdFromReply = (reply: Reply): ThreadId | null => { + switch (reply.type) { + case "answer": + case "cancellation": + return reply.threadId; + + case "failure": + return getThreadIdFromFailure(reply.cause); + } +}; + +/** + * The T3 thread this exchange refers to, wherever the state keeps it: in `t3` while work is in progress, inside the reply afterwards. Null before planning and when planning was rejected. + */ +export const getThreadId = (exchange: Exchange): ThreadId | null => { + switch (exchange.tag) { + case "request-accepted": + return null; + + case "work-planned": + case "thread-created": + return exchange.t3.threadId; + + case "reply-pending": + case "reply-posted": + case "undeliverable": + return getThreadIdFromReply(exchange.reply); + } +}; + +export const makeRequestAccepted = ( + request: Request, + target: T3Target, + now: number, +): RequestAccepted => ({ + ...request, + target, + createdAt: now, + updatedAt: now, + tag: "request-accepted", +}); + +/* +Decider/Policy pattern. + +The decider answers: given the stored state and the relevant live context, what should happen next? + +decider: (state, context) -> action + +The decider/policy pattern is important in the NTBS module because we have to frequently ask: "given this information I have about the exchange and this context (e.g. checking external platforms or t3 thread states) what should we do next?" + +A decision does not transition the exchange. The processor first executes the chosen effect; only after it succeeds does the processor construct the legal transition, passing along any result data the effect produced. +The reconciliation flow is: + +1. load state effect +2. retrieve observations effect +3. make decision pure +4. execute decision effect +5. construct the transition from its result pure, then persist as an effect + +Each exchange state has a time limit for completing its work. The decider uses the current time to decide whether to keep trying or give up. If the observation confirms the work already succeeded, it records that success even after the time limit. If the observation is unknown, it waits for another attempt while time remains and gives up afterward. +RequestAccepted only needs the current time to decide whether to plan or give up: planning creates no thread or turn, so there is no earlier result in T3 to check. + +A note on "unknown"s. + +`unknown` represents a failed observation where the failure is generally retryable and not fatal. +*/ + +export type WorkPlannedContext = + | { readonly thread: "missing" } + | { readonly thread: "present" } + | { readonly thread: "unknown" }; + +export type ThreadCreatedContext = + | { + readonly turn: "missing"; + } + | { readonly turn: "unknown" } + | { readonly turn: "active" } + | { readonly turn: "completed"; readonly reply: Reply }; + +export type ReplyPendingContext = + | { + readonly platformReply: "missing"; + } + | { readonly platformReply: "unknown" } + | { + readonly platformReply: "posted"; + readonly replySourceUri: string; + }; + +// Picks the base fields so states that must not carry `t3` do not inherit it at runtime. +const baseOf = ({ + sourceUri, + snapshot, + attachments, + target, + createdAt, + updatedAt, +}: ExchangeBase): ExchangeBase => ({ + sourceUri, + snapshot, + attachments, + target, + createdAt, + updatedAt, +}); + +export const toWorkPlanned = ( + state: RequestAccepted, + coordinates: WorkCoordinates, + now: number, +): WorkPlanned => ({ + ...state, + updatedAt: now, + tag: "work-planned", + t3: coordinates, +}); + +export const toThreadCreated = (state: WorkPlanned, now: number): ThreadCreated => ({ + ...state, + updatedAt: now, + tag: "thread-created", +}); + +export const toReplyPending = ( + state: RequestAccepted | WorkPlanned | ThreadCreated, + reply: Reply, + now: number, +): ReplyPending => ({ + ...baseOf(state), + updatedAt: now, + tag: "reply-pending", + reply, +}); + +/** What T3 said when it rejected a step for good; `method` names the T3 call that answered. */ +export type Rejection = { + readonly reason: string; + readonly method: string; +}; + +/** + * T3 rejected the work for good while the exchange was in `state`. Each state has exactly one action, so the state itself records which step was rejected and what T3 data existed. + */ +export const toRejected = ( + state: RequestAccepted | WorkPlanned | ThreadCreated, + rejection: Rejection, + now: number, +): ReplyPending => + toReplyPending( + state, + { + type: "failure", + text: rejection.reason, + cause: { + type: "rejected", + method: rejection.method, + state: + state.tag === "request-accepted" ? { tag: state.tag } : { tag: state.tag, t3: state.t3 }, + }, + }, + now, + ); + +/** The state outlived its deadline; the reply tells the user we gave up and the cause records where. */ +export const toExpired = ( + state: RequestAccepted | WorkPlanned | ThreadCreated, + now: number, +): ReplyPending => + toReplyPending( + state, + { + type: "failure", + text: "T3 did not answer in time.", + cause: { + type: "expired", + state: + state.tag === "request-accepted" ? { tag: state.tag } : { tag: state.tag, t3: state.t3 }, + }, + }, + now, + ); + +export const toReplyPosted = ( + state: ReplyPending, + replySourceUri: string, + now: number, +): ReplyPosted => ({ + ...state, + updatedAt: now, + tag: "reply-posted", + replySourceUri, +}); + +export const toUndeliverable = ( + state: ReplyPending, + cause: UndeliverableCause, + now: number, +): Undeliverable => ({ + ...state, + updatedAt: now, + tag: "undeliverable", + cause, +}); + +export type RequestAcceptedDecision = { readonly type: "plan" } | { readonly type: "expire" }; + +export type WorkPlannedDecision = + | { readonly type: "provision-thread" } + | { readonly type: "record-thread-created" } + | { readonly type: "wait" } + | { readonly type: "expire" }; + +export type ThreadCreatedDecision = + | { readonly type: "start-turn" } + | { readonly type: "wait" } + | { + readonly type: "record-reply-pending"; + readonly reply: Reply; + } + | { readonly type: "expire" }; + +export type ReplyPendingDecision = + | { readonly type: "post-reply" } + | { readonly type: "wait" } + | { + readonly type: "record-reply-posted"; + readonly replySourceUri: string; + } + | { readonly type: "expire" }; + +export const fromRequestAccepted = ( + state: RequestAccepted, + now: number, +): RequestAcceptedDecision => (isExpired(state, now) ? { type: "expire" } : { type: "plan" }); + +export const fromWorkPlanned = ( + state: WorkPlanned, + context: WorkPlannedContext, + now: number, +): WorkPlannedDecision => { + switch (context.thread) { + case "missing": + return isExpired(state, now) ? { type: "expire" } : { type: "provision-thread" }; + + case "present": + return { type: "record-thread-created" }; + + case "unknown": + return isExpired(state, now) ? { type: "expire" } : { type: "wait" }; + } +}; + +export const fromThreadCreated = ( + state: ThreadCreated, + context: ThreadCreatedContext, + now: number, +): ThreadCreatedDecision => { + switch (context.turn) { + case "missing": + return isExpired(state, now) ? { type: "expire" } : { type: "start-turn" }; + + case "unknown": + return isExpired(state, now) ? { type: "expire" } : { type: "wait" }; + + case "active": + return isExpired(state, now) ? { type: "expire" } : { type: "wait" }; + + case "completed": + return { + type: "record-reply-pending", + reply: context.reply, + }; + } +}; + +export const fromReplyPending = ( + state: ReplyPending, + context: ReplyPendingContext, + now: number, +): ReplyPendingDecision => { + switch (context.platformReply) { + case "missing": + return isExpired(state, now) ? { type: "expire" } : { type: "post-reply" }; + + case "unknown": + return isExpired(state, now) ? { type: "expire" } : { type: "wait" }; + + case "posted": + return { + type: "record-reply-posted", + replySourceUri: context.replySourceUri, + }; + } +}; diff --git a/apps/server/src/ntbs/processor.test.ts b/apps/server/src/ntbs/processor.test.ts new file mode 100644 index 000000000000..7175e159bfbc --- /dev/null +++ b/apps/server/src/ntbs/processor.test.ts @@ -0,0 +1,3593 @@ +import { describe, expect, it } from "@effect/vitest"; +import { Clock, Deferred, Effect, Fiber, Layer, Queue, Stream } from "effect"; +import { TestClock } from "effect/testing"; +import { + ExchangeRepository, + ExchangeRepositoryError, + inMemoryExchangeRepository, +} from "./ExchangeRepository.ts"; +import { makeNTBSProcessor, type NTBSProcessor } from "./processor.ts"; +import { MessageId, ProjectId, ThreadId, TurnId } from "@t3tools/contracts"; +import { FatalError, RetryableError, T3Gateway } from "./t3gateway.ts"; +import { AdapterError, NTBSAdapter, ReplyRejected } from "./adapter.ts"; +import { + makeRequestAccepted, + toExpired, + toRejected, + toReplyPending, + toReplyPosted, + toThreadCreated, + toUndeliverable, + toWorkPlanned, + type Exchange, + type Request, + type T3Target, + type WorkCoordinates, +} from "./exchange.ts"; + +/** + * The test configuration of the services. + * While T3Gateway tests took flags as input (failX?: boolean, etc), this does not scale for processor test, because instead of a single call we're often testing an entire choreography of events and how the processor behaves in that situation. + * + * Flags, on the other hand, work when behaviors are small, enumerable and reused. Scripts pay off for testing choreography. + */ +type ServiceInput = { + readonly t3Gateway?: Partial; + readonly adapter?: Partial; + /** + * Overrides for the repository: the properties to replace, or a builder that receives the real in-memory repository so an override can gate a call and then delegate it. Everything not overridden stays the real in-memory repository. + */ + readonly repository?: + | Partial + | ((base: ExchangeRepository) => Partial); +}; + +type Call = { + service: string; + method: string; + args: ReadonlyArray; +}; + +/** + * Everything the test harness hands back to the file. + * + * The assembled service as well as probes to look into its state. + */ +type ProcessorTestContext = { + /** The subject under test, built from mocked services.*/ + readonly processor: NTBSProcessor; + /** Assesses the persisted state in most of the tests. What has been recorded about the events and changes? */ + readonly repository: ExchangeRepository; + /** The shared ordered call log. We know what has been dispatched and with which arguments. This is not testing internals but actual business-logic. */ + readonly calls: ReadonlyArray; + /** How many times the processor asked the repository to resolve a thread id, the lookup a busy retry loop would repeat. */ + readonly findByThreadIdCalls: () => number; + /** + * Waits until the shared call log holds at least `count` entries. The mocks are synchronous, so the log is how the background pass's progress can be observed from the test. + */ + readonly awaitCalls: (count: number) => Effect.Effect; + /** + * Yields until neither the service-call log nor the repository's thread lookups have changed for `SETTLE_TICKS` consecutive turns. Use it before asserting that something did *not* happen: a single `yieldNow` can be outrun by a wrongly scheduled call, which would let the assertion pass vacuously. + */ + readonly settle: () => Effect.Effect; + /** Waits until the processor resolved threads at least `count` times. A recovered pass that keeps re-resolving a thread shows up here. */ + readonly awaitThreadLookups: (count: number) => Effect.Effect; + /** Pushes a threadId to the `threadActivity` stream, waking up the processor. */ + readonly pingActivity: (threadId: ThreadId) => Effect.Effect; + /** + * Polls the repository until the exchange at `sourceUri` carries `tag`. + * A Deferred signalled from inside a mock fires before the processor persists the transition, so anything that asserts on stored state after a mock call must wait on the store itself. + */ + readonly awaitStoredTag: ( + sourceUri: string, + tag: Exchange["tag"], + ) => Effect.Effect; +}; + +const request: Request = { + sourceUri: "test://request/1", + snapshot: "Please fix the bug", + attachments: [], +}; + +const defaultProjectId = ProjectId.make("defaultProjectId"); +const defaultThreadId = ThreadId.make("defaultThreadId"); +const defaultUserMessageId = MessageId.make("defaultUserMessageId"); + +const target: T3Target = { + projectId: defaultProjectId, + startBranchName: "fork/dev", +}; + +const defaultWorkCoordinates: WorkCoordinates = { + projectId: defaultProjectId, + startBranchName: "fork/dev", + startCommitSha: "start-commit-sha", + threadId: defaultThreadId, + userMessageId: defaultUserMessageId, + worktreeBranchName: "ntbs/defaultThreadId", +}; + +const secondRequest: Request = { + ...request, + sourceUri: "test://request/2", +}; + +const secondThreadId = ThreadId.make("secondThreadId"); + +const secondWorkCoordinates: WorkCoordinates = { + ...defaultWorkCoordinates, + startCommitSha: "second-start-commit-sha", + threadId: secondThreadId, + userMessageId: MessageId.make("secondUserMessageId"), + worktreeBranchName: "ntbs/secondThreadId", +}; + +const postedReplyUri = "test://reply/1"; + +/** The TestClock starts at epoch, so every transition the processor makes without adjusting it is stamped 0. */ +const now = 0; + +/** The states the default request walks through, for asserting on stored records. */ +const accepted = makeRequestAccepted(request, target, now); +const planned = toWorkPlanned(accepted, defaultWorkCoordinates, now); +const threadCreated = toThreadCreated(planned, now); + +const secondThreadCreated = toThreadCreated( + toWorkPlanned(makeRequestAccepted(secondRequest, target, now), secondWorkCoordinates, now), + now, +); + +/** An answer out of the turn our message started on the given coordinates. */ +const answer = (text: string, coordinates: WorkCoordinates = defaultWorkCoordinates) => + ({ + type: "answer", + text, + threadId: coordinates.threadId, + userMessageId: coordinates.userMessageId, + turnId: TurnId.make(`turn-${coordinates.threadId}`), + }) as const; + +/** + * Happy-path defaults: + * - fresh request flowing to a started turn + * - nothing settled yet + * - replies deliverable + * + * Each test overrides only the methods its scenario changes. + */ +const defaultT3Gateway: Omit = { + planCoordinates: () => Effect.succeed(defaultWorkCoordinates), + getThreadStatus: () => Effect.succeed({ thread: "missing" }), + provisionThread: () => Effect.void, + getTurnStatus: () => Effect.succeed({ turn: "missing" }), + startTurn: () => Effect.void, +}; + +const defaultAdapter: NTBSAdapter = { + acknowledge: () => Effect.void, + postReply: () => Effect.succeed(postedReplyUri), + findPostedReply: () => Effect.succeed(null), +}; + +/** + * How many scheduler turns the harness waits below tolerate before failing with a diagnostic. A healthy wait resolves in a handful of turns; a stuck one names itself here instead of ending as the bare vitest timeout. + */ +const AWAIT_SPINS = 10_000; + +/** + * How many consecutive quiet scheduler turns `settle` requires before it trusts that nothing else is going on. + * + * Every mock here is synchronous, so anything a regression adds lands within a turn or two; a window this wide cannot be crossed by a call that is merely late, while a single yield can be. + * + * What it does *not* prove: that a pass finished. Work parked on a Deferred or a timer looks exactly as quiet, so an assertion made under `settle` still misses anything that would resume after that park. When the claim is that something completed, wait for an observable consequence of the next step instead (the exchange lock only lets a later pass run once the previous one released it). + */ +const SETTLE_TICKS = 50; + +/** + * The harness. + * + * The term "harness" comes from electrical engineering for describing hardware test benches: the wiring harness is the fixed rig that holds the device under test and connects it to instruments, so each experiment only varies the stimulus. + * + * In software it means the same thing: the _fixed_ part of the test setup such as system assembly, instrumentation, probes, as opposed to fixtures (the data) and tests (the scenarios). + * + * `withProcessor` is our harness. + * + * generics allow for our test callback to pass through its types. + * We never specify A and E manually, and we rarely care, but if we ever have to chain the result of withProcessor or do anything with its returned value they are useful to avoid spreading `any`s. + */ +const withProcessor = ( + servicesInput: ServiceInput, + test: (context: ProcessorTestContext) => Effect.Effect, +) => + Effect.gen(function* () { + const calls: Call[] = []; + const activity = yield* Queue.unbounded(); + + /** + * Records the call, then runs the wrapped behavior. + * Recording lives here so no implementation or override can forget it. + * The push happens when the effect runs, not when it's created, which keeps the log ordering honest in the concurrency tests. + */ + const wrap = + (service: string) => + , B, E2>( + method: string, + fn: (...args: Args) => Effect.Effect, + ) => + (...args: Args) => + Effect.suspend(() => { + calls.push({ service, method, args }); + return fn(...args); + }); + + const wrapT3 = wrap("T3Gateway"); + const wrapAdapter = wrap("NTBSAdapter"); + + const t3 = { ...defaultT3Gateway, ...servicesInput.t3Gateway }; + const adapter = { ...defaultAdapter, ...servicesInput.adapter }; + + let findByThreadIdCalls = 0; + + /* + The repository is the real in-memory one, with overrides applied on top and `findByThreadId` counted after them: a worker re-resolving a thread over and over shows up here, even while it is not reaching `getTurnStatus` and even when the lookup itself is what fails. + */ + const repositoryLayer = Layer.effect( + ExchangeRepository, + Effect.map(ExchangeRepository, (base) => { + const overrides = + typeof servicesInput.repository === "function" + ? servicesInput.repository(base) + : servicesInput.repository; + const repository = { ...base, ...overrides }; + + return { + ...repository, + findByThreadId: (threadId: ThreadId) => + Effect.suspend(() => { + findByThreadIdCalls += 1; + return repository.findByThreadId(threadId); + }), + }; + }), + ).pipe(Layer.provide(inMemoryExchangeRepository)); + + const layer = Layer.mergeAll( + Layer.mock(T3Gateway, { + planCoordinates: wrapT3("planCoordinates", t3.planCoordinates), + getThreadStatus: wrapT3("getThreadStatus", t3.getThreadStatus), + getTurnStatus: wrapT3("getTurnStatus", t3.getTurnStatus), + provisionThread: wrapT3("provisionThread", t3.provisionThread), + startTurn: wrapT3("startTurn", t3.startTurn), + threadActivity: Stream.fromQueue(activity), + }), + Layer.mock(NTBSAdapter, { + acknowledge: wrapAdapter("acknowledge", adapter.acknowledge), + findPostedReply: wrapAdapter("findPostedReply", adapter.findPostedReply), + postReply: wrapAdapter("postReply", adapter.postReply), + }), + repositoryLayer, + ); + + return yield* Effect.gen(function* () { + const processor = yield* makeNTBSProcessor; + const repository = yield* ExchangeRepository; + + return yield* test({ + processor, + repository, + calls, + findByThreadIdCalls: () => findByThreadIdCalls, + awaitCalls: (count) => { + const arrived = () => calls.length >= count; + + return Effect.gen(function* () { + let spins = 0; + + while (!arrived()) { + if (spins === AWAIT_SPINS) { + return yield* Effect.die( + new Error( + `awaitCalls(${count}) spun ${spins} times with ${calls.length} recorded calls`, + ), + ); + } + spins += 1; + yield* Effect.yieldNow; + } + }); + }, + awaitThreadLookups: (count) => { + const arrived = () => findByThreadIdCalls >= count; + + return Effect.gen(function* () { + let spins = 0; + + while (!arrived()) { + if (spins === AWAIT_SPINS) { + return yield* Effect.die( + new Error( + `awaitThreadLookups(${count}) spun ${spins} times with ${findByThreadIdCalls} lookups`, + ), + ); + } + spins += 1; + yield* Effect.yieldNow; + } + }); + }, + settle: () => + Effect.gen(function* () { + let lastCalls = calls.length; + let lastLookups = findByThreadIdCalls; + let quiet = 0; + let spins = 0; + + while (quiet < SETTLE_TICKS) { + if (spins === AWAIT_SPINS) { + return yield* Effect.die( + new Error( + `settle() spun ${spins} times while the log kept changing (${calls.length} calls, ${findByThreadIdCalls} lookups)`, + ), + ); + } + spins += 1; + yield* Effect.yieldNow; + + if (calls.length === lastCalls && findByThreadIdCalls === lastLookups) { + quiet += 1; + } else { + quiet = 0; + lastCalls = calls.length; + lastLookups = findByThreadIdCalls; + } + } + }), + pingActivity: (threadId) => Queue.offer(activity, threadId).pipe(Effect.asVoid), + awaitStoredTag: (sourceUri, tag) => + Effect.gen(function* () { + let spins = 0; + + while (true) { + const state = yield* repository.findBySourceUri(sourceUri); + + if (state !== null && state.tag === tag) { + return state; + } + if (spins === AWAIT_SPINS) { + return yield* Effect.die( + new Error( + `awaitStoredTag(${sourceUri}, ${tag}) spun ${spins} times, last seen ${state?.tag ?? "no record"}`, + ), + ); + } + spins += 1; + yield* Effect.yieldNow; + } + }), + }); + }).pipe(Effect.provide(layer)); + }); + +describe("NTBSProcessor", () => { + /* + Recording is all `process` does: the record is where NTBS accepts responsibility, and the background processor takes the exchange from there. + A wake waits in the queue until a run drains it; this test covers that delayed start, not a wake that never arrives. + */ + it.effect( + "returns once the request is recorded, leaving the work to the background processor", + () => + withProcessor({}, ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + yield* processor.process(request, target); + + expect(calls).toEqual([]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + + // No run is draining the wake yet; the queue holds it until one starts. + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitCalls(6); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + Harness smoke test: the happy-path defaults drive a fresh request to ThreadCreated with a started turn, and the shared log shows the full cross-service pipeline in order. + The pipeline runs in the background, so the test waits on the shared log before asserting it. + */ + it.effect("records a fresh request and starts its turn on the default behaviors", () => + withProcessor({}, ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(6); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + + // Still ThreadCreated: a successful startTurn transitions nothing, the exchange only moves when getTurnStatus observes a settled turn. + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + `process` is idempotent per sourceUri: a redelivery finds the recorded exchange and returns without touching T3 or the adapter. + The smoke test above pins the exact pipeline, so here we check the log length twice: once after the background pass ran the request to prove it actually did the work, once after the second delivery to prove it added nothing — the log is append-only, so an unchanged length means zero service calls. + */ + it.effect("starts a new request and ignores its sequential redelivery", () => + withProcessor({}, ({ processor, repository, calls, awaitCalls, settle }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(6); + + // The five T3 pipeline steps plus the acknowledgement. + expect(calls.length).toBe(6); + + yield* processor.process(request, target); + yield* settle(); + + expect(calls.length).toBe(6); + + // And the stored exchange is still the one the first delivery produced. + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + The acknowledgement is best-effort: a failing `acknowledge` must not stop the pipeline. + The log proves the failure was swallowed in place, the T3 steps after it still ran, and the exchange still reached ThreadCreated. + */ + it.effect("continues after a best-effort acknowledgement fails", () => + withProcessor( + { + adapter: { + acknowledge: () => + new AdapterError({ + reason: "The acknowledgement could not be posted", + cause: "test failure", + }), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(6); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + A stored ThreadCreated whose turn is still running is a no-op, whether startup recovery or thread activity looks at it. + The processor asks T3 for the turn status and stops there: no planning, no acknowledgement, no second startTurn, no reply lookup. + */ + it.effect("leaves an exchange unchanged while its turn is active", () => { + const recoveryStatusRead = Deferred.makeUnsafe(); + const activityStatusRead = Deferred.makeUnsafe(); + let statusReads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.gen(function* () { + statusReads += 1; + yield* Deferred.succeed( + statusReads === 1 ? recoveryStatusRead : activityStatusRead, + undefined, + ); + return { turn: "active" as const }; + }), + }, + }, + ({ processor, repository, calls, pingActivity, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(recoveryStatusRead); + yield* settle(); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + ]); + + yield* pingActivity(defaultThreadId); + yield* Deferred.await(activityStatusRead); + yield* settle(); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.getTurnStatus", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Activity pings are handled per exchange: one exchange waiting on a slow T3 read must not hold up another exchange's ping. + + Both stored exchanges are ThreadCreated, so handling a ping is one `getTurnStatus` read. A's read signals and then waits until the clock advances; B's read records and returns at once. If the processor handled one ping at a time, A's completion would be recorded before B was read, so the order of the recorded events is the assertion. + */ + it.effect("reads another exchange while one exchange's observation is still pending", () => { + const events: string[] = []; + const aRead = Deferred.makeUnsafe(); + const bRead = Deferred.makeUnsafe(); + const recovered = Deferred.makeUnsafe(); + let recoveryReads = 0; + let slow = false; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: (state) => + Effect.gen(function* () { + if (!slow) { + recoveryReads += 1; + if (recoveryReads === 2) { + yield* Deferred.succeed(recovered, undefined); + } + } else if (state.t3.threadId === defaultThreadId) { + events.push("a:start"); + yield* Deferred.succeed(aRead, undefined); + yield* Effect.sleep("1 second"); + events.push("a:end"); + } else { + events.push("b:read"); + yield* Deferred.succeed(bRead, undefined); + } + return { turn: "active" as const }; + }), + }, + }, + ({ processor, repository, pingActivity }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + yield* repository.upsert(secondThreadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(recovered); + yield* Effect.yieldNow; + + slow = true; + yield* pingActivity(defaultThreadId); + yield* Deferred.await(aRead); + yield* pingActivity(secondThreadId); + + // Advancing the clock lets A finish in both cases; the recorded order shows whether B was read before that. + const bReadWait = yield* Deferred.await(bRead).pipe( + Effect.forkChild({ startImmediately: true }), + ); + yield* TestClock.adjust("1 second"); + yield* Fiber.join(bReadWait); + + expect(events).toEqual(["a:start", "b:read", "a:end"]); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A burst of pings for one exchange is a demand to look again once, not one read per ping. + + A's first read waits until the clock advances. While it waits, the burst arrives and B's ping is read too — B is not waiting for A. The test then advances the clock and waits for A's repeated check itself before counting, because B finishing proves nothing about what A still has queued. Reading once per ping would record 51 reads; here it records A's waiting read plus that one check. + */ + it.effect("collapses a burst of pings for one exchange into a single extra observation", () => { + const aRead = Deferred.makeUnsafe(); + const bRead = Deferred.makeUnsafe(); + const checkedAgain = Deferred.makeUnsafe(); + const recovered = Deferred.makeUnsafe(); + const burst = 50; + let recoveryReads = 0; + let reads = 0; + let slow = false; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: (state) => + Effect.gen(function* () { + if (!slow) { + recoveryReads += 1; + if (recoveryReads === 2) { + yield* Deferred.succeed(recovered, undefined); + } + } else if (state.t3.threadId === defaultThreadId) { + reads += 1; + if (reads === 1) { + yield* Deferred.succeed(aRead, undefined); + yield* Effect.sleep("1 second"); + } else if (reads === 2) { + yield* Deferred.succeed(checkedAgain, undefined); + } + } else { + yield* Deferred.succeed(bRead, undefined); + } + return { turn: "active" as const }; + }), + }, + }, + ({ processor, repository, pingActivity, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + yield* repository.upsert(secondThreadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(recovered); + yield* Effect.yieldNow; + + slow = true; + reads = 0; + yield* pingActivity(defaultThreadId); + yield* Deferred.await(aRead); + yield* Effect.forEach( + Array.from({ length: burst }), + () => pingActivity(defaultThreadId), + { + discard: true, + }, + ); + + yield* pingActivity(secondThreadId); + // B's read completes while the clock has not advanced, so it happens while A is still waiting on its first read. + yield* Deferred.await(bRead); + + yield* TestClock.adjust("1 second"); + yield* Deferred.await(checkedAgain); + yield* settle(); + + expect(reads).toBe(2); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A burst of pings while the reply is being posted asks for one more look, not a second delivery: the follow-up pass reloads the posted record and stops, so `postReply` runs exactly once. + */ + it.effect("does not post the reply again for pings arriving while it posts", () => { + const reply = answer("Reply under a burst of pings"); + const postStarted = Deferred.makeUnsafe(); + const releasePost = Deferred.makeUnsafe(); + const burst = 50; + let posts = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => Effect.succeed({ turn: "completed" as const, reply }), + }, + adapter: { + postReply: () => + Effect.gen(function* () { + posts += 1; + yield* Deferred.succeed(postStarted, undefined); + yield* Deferred.await(releasePost); + return postedReplyUri; + }), + }, + }, + ({ + processor, + repository, + calls, + pingActivity, + awaitStoredTag, + awaitThreadLookups, + settle, + }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(postStarted); + + // One ping starts a worker, which has to wait for the posting pass; the burst behind it collapses into one queued re-check. + yield* pingActivity(defaultThreadId); + yield* awaitThreadLookups(1); + + yield* Effect.forEach( + Array.from({ length: burst }), + () => pingActivity(defaultThreadId), + { discard: true }, + ); + yield* settle(); + + yield* Deferred.succeed(releasePost, undefined); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + // The queued re-check runs its own pass and resolves the thread again: it reloads the posted exchange and stops, without another post. + yield* awaitThreadLookups(2); + yield* settle(); + + expect(posts).toBe(1); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + T3 refusing the target for good (a project repository with no origin remote, say) is found out at planning, before anything from T3 exists. + The request was already recorded, so the rejection becomes a failure reply like any other and is posted; the stored record never carries T3 coordinates. + */ + it.effect("posts a failure reply when T3 rejects the request at planning", () => { + const rejection = new FatalError({ + reason: "Remote 'origin' does not exist", + cause: null, + method: "gitWorkflowService.remoteExists", + }); + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => rejection, + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(3); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + const replyPending = toRejected(accepted, rejection, now); + expect(replyPending.reply).toEqual({ + type: "failure", + text: rejection.reason, + cause: { + type: "rejected", + method: rejection.method, + state: { tag: "request-accepted" }, + }, + }); + expect(calls.at(-1)?.args).toEqual([replyPending]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(replyPending, postedReplyUri, now), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A transient planning failure happens after the request was recorded, so the record survives it: the pass fails, the exchange stays RequestAccepted. + A redelivery finds the record and plans nothing. The sweeper then re-plans from the record and drives the exchange on to its turn. + */ + it.effect( + "keeps an accepted request whose planning failed and re-plans it on the next sweep", + () => { + const turnStarted = Deferred.makeUnsafe(); + let planCalls = 0; + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => + Effect.gen(function* () { + planCalls += 1; + if (planCalls === 1) { + return yield* new RetryableError({ + reason: "Could not fetch origin", + cause: "test failure", + method: "planCoordinates", + }); + } + return defaultWorkCoordinates; + }), + startTurn: () => Deferred.succeed(turnStarted, undefined), + }, + }, + ({ processor, repository, calls, awaitCalls, settle }) => + Effect.gen(function* () { + // Started first so that the sweep, not startup recovery, is what re-plans. + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(1); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + + // Redelivery after acceptance does no planning. + yield* processor.process(request, target); + yield* settle(); + expect(calls.length).toBe(1); + + yield* TestClock.adjust("1 minute"); + yield* Deferred.await(turnStarted); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + // The sweep resumes from the record. + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + // The sweep re-planned a minute in, so its transitions carry that time. + const sweptAt = yield* Clock.currentTimeMillis; + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toThreadCreated(toWorkPlanned(accepted, defaultWorkCoordinates, sweptAt), sweptAt), + ); + + yield* Fiber.interrupt(run); + }), + ); + }, + ); + + /* + A transient provisioning failure leaves the exchange at WorkPlanned; the pass fails, the record survives. + Startup recovery then picks the exchange up where it stopped: it re-checks the thread, provisions it, and carries on to the turn. + Planning is not repeated, the coordinates were already persisted. + */ + it.effect("retries a transient provisioning failure during later recovery", () => { + const turnStarted = Deferred.makeUnsafe(); + let provisionCalls = 0; + + return withProcessor( + { + t3Gateway: { + provisionThread: () => + Effect.gen(function* () { + provisionCalls += 1; + if (provisionCalls === 1) { + return yield* new RetryableError({ + reason: "Thread provisioning temporarily failed", + cause: "test failure", + method: "provisionThread", + }); + } + }), + startTurn: () => Deferred.succeed(turnStarted, undefined), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(3); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(planned); + + yield* Fiber.interrupt(firstRun); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(turnStarted); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + // Recovery resumes from the persisted plan. + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A transient turn-start failure happens after ThreadCreated was persisted, so the exchange stays there and the pass fails. + Recovery resumes from ThreadCreated: the thread is neither re-checked nor re-provisioned, and the acknowledgement is not repeated. Only the turn is retried. + */ + it.effect("retries a transient turn-start failure during later recovery", () => { + const turnStarted = Deferred.makeUnsafe(); + let startTurnCalls = 0; + + return withProcessor( + { + t3Gateway: { + startTurn: () => + Effect.gen(function* () { + startTurnCalls += 1; + if (startTurnCalls === 1) { + return yield* new RetryableError({ + reason: "Turn start temporarily failed", + cause: "test failure", + method: "startTurn", + }); + } + yield* Deferred.succeed(turnStarted, undefined); + }), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(6); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(firstRun); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(turnStarted); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + // Recovery resumes from ThreadCreated. + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A fatal turn-start rejection is the dead end of the planning rejection one step later: the thread exists, so the rejection becomes a failure reply on the recorded exchange and the pass carries it to delivery. + */ + it.effect("turns a fatal turn start into a failure reply", () => { + const rejection = new FatalError({ + reason: "T3 rejected the turn start", + cause: null, + method: "orchestrationEngine.dispatch", + }); + const postStarted = Deferred.makeUnsafe(); + const releasePost = Deferred.makeUnsafe(); + + return withProcessor( + { + t3Gateway: { + startTurn: () => rejection, + }, + adapter: { + postReply: () => + Effect.gen(function* () { + yield* Deferred.succeed(postStarted, undefined); + yield* Deferred.await(releasePost); + return postedReplyUri; + }), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + // The post is held open so the record the fatal start produced can be read before the reply goes out. + yield* Deferred.await(postStarted); + + const replyPending = toRejected(threadCreated, rejection, now); + expect(replyPending.reply).toEqual({ + type: "failure", + text: rejection.reason, + cause: { + type: "rejected", + method: rejection.method, + state: { tag: "thread-created", t3: threadCreated.t3 }, + }, + }); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(replyPending); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + yield* Deferred.succeed(releasePost, undefined); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(replyPending, postedReplyUri, now), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Failing to load the exchanges is not fatal to `run`: startup recovery logs it, and the sweeper — which reads the same list — retries a minute later and drives the stored exchange on. + */ + it.effect("recovers from a failed recovery load on the next sweep", () => { + const recoveryFailed = Deferred.makeUnsafe(); + const reply = answer("Reply after a failed recovery load"); + let loads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => Effect.succeed({ turn: "completed" as const, reply }), + }, + repository: { + findNonTerminalExchanges: Effect.gen(function* () { + loads += 1; + if (loads === 1) { + yield* Deferred.succeed(recoveryFailed, undefined); + return yield* new ExchangeRepositoryError({ + reason: "The repository is unavailable", + cause: "test failure", + }); + } + return [threadCreated]; + }), + }, + }, + ({ processor, repository, calls, awaitStoredTag, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(recoveryFailed); + yield* settle(); + + // The failed load ended recovery before it could read or write anything about the exchange. + expect(calls).toEqual([]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* TestClock.adjust("1 minute"); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(loads).toBe(2); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A failing thread lookup fails only that pass, logged and dropped like any other: the exchange keeps the record it had, and the next ping resolves the thread and runs it on — even the ping that arrives while the failing pass is still in flight. + */ + it.effect("survives a failed lookup for thread activity", () => { + const recoveryTurnStarted = Deferred.makeUnsafe(); + const lookupParked = Deferred.makeUnsafe(); + const releaseLookup = Deferred.makeUnsafe(); + const reply = answer("Reply after a failed lookup"); + let lookups = 0; + let turnStatusReads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.sync(() => { + turnStatusReads += 1; + return turnStatusReads === 1 + ? { turn: "missing" as const } + : { turn: "completed" as const, reply }; + }), + startTurn: () => Deferred.succeed(recoveryTurnStarted, undefined), + }, + repository: { + findByThreadId: (threadId: ThreadId) => + Effect.gen(function* () { + lookups += 1; + if (lookups === 1) { + // Held open long enough that the next ping arrives while the pass is failing. + yield* Deferred.succeed(lookupParked, undefined); + yield* Deferred.await(releaseLookup); + return yield* new ExchangeRepositoryError({ + reason: "The repository is unavailable", + cause: "test failure", + }); + } + return threadId === defaultThreadId ? threadCreated : null; + }), + }, + }, + ({ + processor, + repository, + calls, + pingActivity, + awaitStoredTag, + findByThreadIdCalls, + settle, + }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + // Recovery has read the turn and started it; the exchange settles at ThreadCreated for the pings that follow. + yield* Deferred.await(recoveryTurnStarted); + yield* settle(); + + yield* pingActivity(defaultThreadId); + yield* Deferred.await(lookupParked); + + // The failing lookup never reached the exchange; the ping that arrives while it fails must not be lost with it. + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + yield* pingActivity(defaultThreadId); + // Let the activity subscription pick up the ping while the lookup is still parked, so its re-check is queued against a failing pass. + yield* settle(); + + yield* Deferred.succeed(releaseLookup, undefined); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(findByThreadIdCalls()).toBe(2); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + `upsert` guards the thread index as well, and a plan already carries its thread: a second request planned onto a thread the first exchange owns cannot record that plan. + The pass fails at the record, the second exchange stays at its accepted request, and the first keeps the thread it reached. + */ + it.effect( + "fails the pass when a second request plans onto a thread that already belongs to one", + () => { + const secondAccepted = makeRequestAccepted(secondRequest, target, now); + + return withProcessor({}, ({ processor, repository, calls, awaitCalls, settle }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + yield* processor.process(request, target); + yield* awaitCalls(6); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + // The second request plans onto the same thread the first one already owns. + yield* processor.process(secondRequest, target); + yield* awaitCalls(7); + yield* settle(); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(secondRequest.sourceUri)).toEqual( + secondAccepted, + ); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }, + ); + + /* + Only the first delivery of a sourceUri records it; a redelivery reads the record without taking the exchange lock. + The background pass is held inside planCoordinates, so the lock is busy while the exchange is mid-pipeline; the redelivery still returns immediately, and once released the log shows a single pipeline. + */ + it.effect("returns a redelivery without waiting for the exchange lock", () => { + const firstPlanStarted = Deferred.makeUnsafe(); + const releaseFirstPlan = Deferred.makeUnsafe(); + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => + Effect.gen(function* () { + yield* Deferred.succeed(firstPlanStarted, undefined); + yield* Deferred.await(releaseFirstPlan); + return defaultWorkCoordinates; + }), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + const first = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(firstPlanStarted); + + // The record exists, so the redelivery completes while the lock is still held by the parked pass. + const second = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Fiber.join(second); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + + yield* Deferred.succeed(releaseFirstPlan, undefined); + yield* Fiber.join(first); + yield* awaitCalls(6); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A delivery can read an empty repository and still find a record when it re-checks under the lock, because another delivery recorded it in between. + The first read is held open so the recording lands while it is in flight, which is the race itself; the redelivery then returns without recording anything. + */ + it.effect("returns a delivery whose first read raced the recording", () => { + const firstReadParked = Deferred.makeUnsafe(); + const releaseFirstRead = Deferred.makeUnsafe(); + let reads = 0; + + return withProcessor( + { + repository: (base) => ({ + findBySourceUri: (sourceUri) => + Effect.gen(function* () { + reads += 1; + + if (reads === 1) { + // The first check read the empty repository; the gate holds it open until another delivery records the exchange. + yield* Deferred.succeed(firstReadParked, undefined); + yield* Deferred.await(releaseFirstRead); + return null; + } + + return yield* base.findBySourceUri(sourceUri); + }), + }), + }, + ({ processor, repository }) => + Effect.gen(function* () { + const delivery = yield* processor.process(request, target).pipe(Effect.forkChild); + yield* Deferred.await(firstReadParked); + + yield* repository.upsert(threadCreated); + yield* Deferred.succeed(releaseFirstRead, undefined); + yield* Fiber.join(delivery); + + // The re-check found the recorded exchange: one record, and the redelivery persisted nothing. + expect(reads).toBe(2); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + }), + ); + }); + + /* + A redelivery does not couple to the pass it meets. + The pass fails inside planCoordinates after the request was recorded, so the redelivery finds the record and returns without planning again; recovery, not the redelivery, finishes the pipeline. + */ + it.effect("ignores a redelivery of an accepted request whose planning failed", () => { + const firstPlanStarted = Deferred.makeUnsafe(); + const releaseFirstPlan = Deferred.makeUnsafe(); + const turnStarted = Deferred.makeUnsafe(); + let planCalls = 0; + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => + Effect.gen(function* () { + planCalls += 1; + if (planCalls === 1) { + yield* Deferred.succeed(firstPlanStarted, undefined); + yield* Deferred.await(releaseFirstPlan); + return yield* new RetryableError({ + reason: "The first planning attempt failed", + cause: "test failure", + method: "planCoordinates", + }); + } + return defaultWorkCoordinates; + }), + startTurn: () => Deferred.succeed(turnStarted, undefined), + }, + }, + ({ processor, repository, calls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + const first = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(firstPlanStarted); + + // The redelivery completes while the lock is still held by the parked pass. + const second = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Fiber.join(second); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + + yield* Deferred.succeed(releaseFirstPlan, undefined); + yield* Fiber.join(first); + + // The redelivery found the record and added nothing to the log, and the failed pass is the background processor's problem, not the deliveries'. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + + yield* Fiber.interrupt(run); + + const recovery = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(turnStarted); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + // Recovery plans again from the record. + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(recovery); + }), + ); + }); + + /* + The same, one step later: the pass fails inside getThreadStatus, after the plan was persisted. + The queued redelivery finds the plan and returns without touching any service, and it is recovery, not the redelivery, that eventually finishes the pipeline. + */ + it.effect("retains a persisted plan for later recovery and ignores its queued redelivery", () => { + const threadStatusStarted = Deferred.makeUnsafe(); + const releaseThreadStatus = Deferred.makeUnsafe(); + const turnStarted = Deferred.makeUnsafe(); + let threadStatusCalls = 0; + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => + Effect.gen(function* () { + threadStatusCalls += 1; + if (threadStatusCalls === 1) { + yield* Deferred.succeed(threadStatusStarted, undefined); + yield* Deferred.await(releaseThreadStatus); + return yield* new RetryableError({ + reason: "Failed after persisting the plan", + cause: "test failure", + method: "getThreadStatus", + }); + } + return { thread: "missing" as const }; + }), + startTurn: () => Deferred.succeed(turnStarted, undefined), + }, + }, + ({ processor, repository, calls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + const first = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(threadStatusStarted); + + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(planned); + + const second = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Fiber.join(second); + + // The redelivery did not wait on the locked pass. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + ]); + + yield* Deferred.succeed(releaseThreadStatus, undefined); + // A failed observation becomes an unknown context: leave the persisted + // plan in place and let recovery decide whether to retry or expire it. + yield* Fiber.join(first); + + // The redelivery found the plan and added nothing to the log. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(planned); + + yield* Fiber.interrupt(run); + + const recovery = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(turnStarted); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + // Recovery resumes from the persisted plan. + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(recovery); + }), + ); + }); + + /* + The lock is per sourceUri, not global. + While the first request is blocked in planCoordinates, a different request runs its whole pipeline to completion. + `planCoordinates` does not receive the request, so the mock hands out coordinates by call order. + */ + it.effect("allows different requests to proceed concurrently", () => { + const firstPlanStarted = Deferred.makeUnsafe(); + const releaseFirstPlan = Deferred.makeUnsafe(); + let planCalls = 0; + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => + Effect.gen(function* () { + planCalls += 1; + if (planCalls === 1) { + yield* Deferred.succeed(firstPlanStarted, undefined); + yield* Deferred.await(releaseFirstPlan); + return defaultWorkCoordinates; + } + return secondWorkCoordinates; + }), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + yield* processor.process(request, target); + yield* Deferred.await(firstPlanStarted); + + yield* processor.process(secondRequest, target); + yield* awaitCalls(7); + + // The second request completed while the first is still held in planCoordinates. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + expect(yield* repository.findBySourceUri(secondRequest.sourceUri)).toEqual( + secondThreadCreated, + ); + + yield* Deferred.succeed(releaseFirstPlan, undefined); + yield* awaitCalls(12); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + // The first request finishes its own pipeline once released. + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Startup recovery walks every non-terminal exchange. + A stored ThreadCreated whose turn has meanwhile completed is carried to ReplyPosted: the reply is looked up on the platform first, not found, then posted. + */ + it.effect("resumes non-terminal exchanges when run starts", () => { + const reply = answer("Recovered reply"); + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => Effect.succeed({ turn: "completed", reply }), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + const replyPending = toReplyPending(threadCreated, reply, now); + expect(calls.at(-1)?.args).toEqual([replyPending]); + expect(posted).toEqual(toReplyPosted(replyPending, postedReplyUri, now)); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Thread activity is routed by threadId. An unknown thread is dropped without any service call; a stored one gets its turn status re-read. + Recovery sees the turn still active, so the reply only arrives through the ping. + */ + it.effect("routes thread activity only for stored exchanges", () => { + const reply = answer("Reply after thread activity"); + let statusReads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.sync(() => { + statusReads += 1; + return statusReads === 1 + ? { turn: "active" as const } + : { turn: "completed" as const, reply }; + }), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + yield* pingActivity(ThreadId.make("unknown-thread")); + yield* pingActivity(defaultThreadId); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + // Startup recovery. + "T3Gateway.getTurnStatus", + // The unknown thread contributed nothing; this is the stored thread's ping. + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + // Both status reads were for the stored exchange. + expect(calls[0]?.args).toEqual([threadCreated]); + expect(calls[1]?.args).toEqual([threadCreated]); + expect(posted).toEqual( + toReplyPosted(toReplyPending(threadCreated, reply, now), postedReplyUri, now), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A redelivery does not disturb an in-flight activity pass. + While the ping's status read is held open, the redelivery reads the stored exchange and returns without calls; the pass then completes and posts the reply. + */ + it.effect("returns a redelivery while thread activity is mid-pass", () => { + const activityStatusStarted = Deferred.makeUnsafe(); + const releaseActivityStatus = Deferred.makeUnsafe(); + const reply = answer("Reply from thread activity"); + let statusReads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.gen(function* () { + statusReads += 1; + if (statusReads === 1) { + return { turn: "active" as const }; + } + yield* Deferred.succeed(activityStatusStarted, undefined); + yield* Deferred.await(releaseActivityStatus); + return { turn: "completed" as const, reply }; + }), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + yield* pingActivity(defaultThreadId); + yield* Deferred.await(activityStatusStarted); + + const redelivery = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + // The redelivery returns while the activity pass still holds the exchange lock. + yield* Fiber.join(redelivery); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.getTurnStatus", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Deferred.succeed(releaseActivityStatus, undefined); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(posted).toEqual( + toReplyPosted(toReplyPending(threadCreated, reply, now), postedReplyUri, now), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + The happy path end to end: a fresh request whose thread already exists and whose turn completes immediately reaches ReplyPosted in one background pass. + The log shows provisioning skipped for the present thread, and the reply posted with the ReplyPending state the completed turn produced. + */ + it.effect("posts a completed T3 reply", () => { + const reply = answer("The bug is fixed."); + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => Effect.succeed({ thread: "present" }), + getTurnStatus: () => Effect.succeed({ turn: "completed", reply }), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(6); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + const replyPending = toReplyPending(threadCreated, reply, now); + expect(calls.at(-1)?.args).toEqual([replyPending]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(replyPending, postedReplyUri, now), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Reply discovery guards against double posting. + When the platform already shows the reply (a previous run posted it but crashed before persisting), the exchange is recorded as posted at the discovered URI and `postReply` is never called. + */ + it.effect("records a reply already found on the platform without posting it again", () => { + const reply = answer("Already delivered"); + const discoveredReplyUri = "test://reply/already-posted"; + + return withProcessor( + { + adapter: { + findPostedReply: () => Effect.succeed(discoveredReplyUri), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const replyPending = toReplyPending(threadCreated, reply, now); + yield* repository.upsert(replyPending); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + ]); + expect(calls[0]?.args).toEqual([replyPending]); + expect(posted).toEqual(toReplyPosted(replyPending, discoveredReplyUri, now)); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + `ReplyRejected` is the platform saying the reply can never land (the originating discussion is gone, say). + Unlike an AdapterError, which leaves the exchange pending for a retry, a rejection is terminal: the exchange becomes Undeliverable with the platform's cause. + */ + it.effect("records a definitively rejected reply as undeliverable", () => { + const reply = answer("Reply that cannot be delivered"); + const rejectionCause = { message: "The originating discussion was deleted" }; + + return withProcessor( + { + adapter: { + postReply: () => new ReplyRejected({ cause: rejectionCause }), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const replyPending = toReplyPending(threadCreated, reply, now); + yield* repository.upsert(replyPending); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const undeliverable = yield* awaitStoredTag(request.sourceUri, "undeliverable"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(undeliverable).toEqual(toUndeliverable(replyPending, rejectionCause, now)); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A `FatalError` from a T3 action means T3 will never accept the work, so retrying is pointless. + The processor skips straight from the plan to a failure reply: no thread is created, so no acknowledgement and no turn; the user gets told why instead. + The reply keeps the planned coordinates as its context, the stored exchange does not. + */ + it.effect("delivers a failure reply when T3 rejects thread provisioning", () => { + const rejection = new FatalError({ + reason: "T3 cannot provision this request", + cause: { message: "The selected project no longer exists" }, + method: "provisionThread", + }); + + return withProcessor( + { + t3Gateway: { + provisionThread: () => rejection, + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(5); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + const replyPending = toRejected(planned, rejection, now); + expect(replyPending.reply).toEqual({ + type: "failure", + text: rejection.reason, + cause: { + type: "rejected", + method: rejection.method, + state: { tag: "work-planned", t3: defaultWorkCoordinates }, + }, + }); + expect(calls.at(-1)?.args).toEqual([replyPending]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(replyPending, postedReplyUri, now), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Recovery from ReplyPending, the one non-terminal state the other recovery tests never start from. + A transient posting failure leaves the exchange pending; the next run repeats discovery and posting, and the second attempt lands. + */ + it.effect("retries a transient reply-posting failure during later recovery", () => { + const firstPostAttempted = Deferred.makeUnsafe(); + const retryReachedPost = Deferred.makeUnsafe(); + const releaseRetry = Deferred.makeUnsafe(); + const reply = answer("Reply after a transient posting failure"); + let postAttempts = 0; + + return withProcessor( + { + adapter: { + postReply: () => + Effect.gen(function* () { + postAttempts += 1; + if (postAttempts === 1) { + yield* Deferred.succeed(firstPostAttempted, undefined); + return yield* new AdapterError({ + reason: "Reply posting temporarily failed", + cause: "test failure", + }); + } + if (postAttempts === 2) { + yield* Deferred.succeed(retryReachedPost, undefined); + yield* Deferred.await(releaseRetry); + } + return postedReplyUri; + }), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag }) => + Effect.gen(function* () { + const replyPending = toReplyPending(threadCreated, reply, now); + yield* repository.upsert(replyPending); + + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(firstPostAttempted); + + /* + The failed pass leaves no trace of its own, so quiet is not evidence that it ended: the retry below is the evidence. + A ping's pass cannot reach `postReply` while the failed one still owns the exchange — `resumeExchange` waits for it — so `retryReachedPost` proves the failure was fully handled, not merely silent. + */ + yield* pingActivity(defaultThreadId); + yield* Deferred.await(retryReachedPost); + + // The retry is the only extra attempt, and the record is untouched: the failure was kept, nothing terminal was written. + expect(postAttempts).toBe(2); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(replyPending); + + // A crash while the retry is in flight leaves the record retryable still: startup recovery picks it up and posts. + yield* Fiber.interrupt(firstRun); + + const secondRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(postAttempts).toBe(3); + expect(posted).toEqual(toReplyPosted(replyPending, postedReplyUri, now)); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + yield* Fiber.interrupt(secondRun); + }), + ); + }); + + /* + Reply discovery can fail transiently too: an unobserved platform posts nothing, and the retry after the failed pass discovers again before delivering. + */ + it.effect("repeats reply discovery after a transient failure", () => { + const reply = answer("Reply after a failed discovery"); + const replyPending = toReplyPending(threadCreated, reply, now); + const discoveryFailed = Deferred.makeUnsafe(); + let discoveries = 0; + + return withProcessor( + { + adapter: { + findPostedReply: () => + Effect.gen(function* () { + discoveries += 1; + if (discoveries === 1) { + yield* Deferred.succeed(discoveryFailed, undefined); + return yield* new AdapterError({ + reason: "The platform is unavailable", + cause: "test failure", + }); + } + return null; + }), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag, settle }) => + Effect.gen(function* () { + yield* repository.upsert(replyPending); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(discoveryFailed); + yield* settle(); + + // The failed discovery posts nothing; the record still waits for its reply. + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(replyPending); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + ]); + + yield* pingActivity(defaultThreadId); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(discoveries).toBe(2); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + + yield* Fiber.interrupt(run); + }), + ); + }); + /* + `run` subscribes to thread activity before startup recovery, so a slow recovery does not delay live events. + Recovery is held open on the first exchange's status read while a ping for a second exchange is delivered; the second reaches ReplyPosted with recovery still blocked. + */ + it.effect("subscribes to thread activity before startup recovery finishes", () => { + const recoveryStarted = Deferred.makeUnsafe(); + const releaseRecovery = Deferred.makeUnsafe(); + const reply = answer("Reply posted while startup recovery is blocked", secondWorkCoordinates); + + return withProcessor( + { + t3Gateway: { + getTurnStatus: (state) => + state.sourceUri === request.sourceUri + ? Effect.gen(function* () { + yield* Deferred.succeed(recoveryStarted, undefined); + yield* Deferred.await(releaseRecovery); + return { turn: "active" as const }; + }) + : Effect.succeed({ turn: "completed" as const, reply }), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(recoveryStarted); + + // Stored only now, so recovery could not have picked it up: the ping is its only way forward. + yield* repository.upsert(secondThreadCreated); + yield* pingActivity(secondThreadId); + const posted = yield* awaitStoredTag(secondRequest.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(calls[0]?.args).toEqual([threadCreated]); + expect(calls[1]?.args).toEqual([secondThreadCreated]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + expect(posted).toEqual( + toReplyPosted(toReplyPending(secondThreadCreated, reply, now), postedReplyUri, now), + ); + + yield* Deferred.succeed(releaseRecovery, undefined); + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + An accepted request whose planning never succeeds is not retried forever. + Once the record is older than its deadline the next run expires it instead of planning again: the user gets a failure reply, and a later sweep finds nothing left to do. + */ + it.effect("expires an accepted request whose planning never succeeded", () => + withProcessor( + { + t3Gateway: { + planCoordinates: () => + new RetryableError({ + reason: "Could not fetch origin", + cause: "test failure", + method: "planCoordinates", + }), + }, + }, + ({ processor, repository, calls, awaitCalls, awaitStoredTag }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* awaitCalls(1); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(accepted); + yield* Fiber.interrupt(firstRun); + + yield* TestClock.adjust("6 minutes"); + const expiredAt = yield* Clock.currentTimeMillis; + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + // Recovery expires the record instead of planning again. + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + const replyPending = toExpired(accepted, expiredAt); + expect(calls.at(-1)?.args).toEqual([replyPending]); + expect(posted).toEqual(toReplyPosted(replyPending, postedReplyUri, expiredAt)); + + yield* TestClock.adjust("1 minute"); + expect(calls.length).toBe(3); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + A turn T3 keeps reporting active is given up once ThreadCreated is older than its deadline. + The failure reply keeps the coordinates, so later activity on that thread still finds the exchange, which is terminal and does nothing. + */ + it.effect("expires a turn that never settles and ignores its later activity", () => + withProcessor( + { + t3Gateway: { + getTurnStatus: () => Effect.succeed({ turn: "active" }), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + yield* TestClock.adjust("61 minutes"); + const expiredAt = yield* Clock.currentTimeMillis; + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const posted = yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + const replyPending = toExpired(threadCreated, expiredAt); + expect(replyPending.reply).toEqual({ + type: "failure", + text: "T3 did not answer in time.", + cause: { + type: "expired", + state: { tag: "thread-created", t3: defaultWorkCoordinates }, + }, + }); + expect(posted).toEqual(toReplyPosted(replyPending, postedReplyUri, expiredAt)); + + yield* pingActivity(defaultThreadId); + yield* TestClock.adjust("1 minute"); + expect(calls.length).toBe(3); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + A reply the platform never accepts is given up once ReplyPending is older than its deadline: the exchange becomes Undeliverable without another posting attempt. + */ + it.effect("gives up on a reply the platform never accepted", () => + withProcessor( + { + adapter: { + postReply: () => + new AdapterError({ reason: "Reply posting failed", cause: "test failure" }), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const replyPending = toReplyPending(threadCreated, answer("Never delivered"), now); + yield* repository.upsert(replyPending); + + yield* TestClock.adjust("61 minutes"); + const expiredAt = yield* Clock.currentTimeMillis; + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + const undeliverable = yield* awaitStoredTag(request.sourceUri, "undeliverable"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + ]); + expect(undeliverable).toEqual( + toUndeliverable( + replyPending, + { message: "The platform did not accept the reply in time." }, + expiredAt, + ), + ); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + A hung status read must not hold the exchange lock forever or start the action it was checking for. + After the observe timeout the failed check becomes unknown, the decider waits, and the next pass + can take the lock. Provisioning, a turn, and a second reply post stay unstarted. + The timeout must not crash `run` either: the run fiber is the only thing that consumes thread + activity, so after it we ping and require the exchange to be driven on to its reply. A run that + died with the timeout would release the lock all the same and pass the earlier assertions, but + it would never see the ping. + */ + const settledReply = answer("Reply after the timeout"); + const hungReplyPending = toReplyPending(threadCreated, answer("Hung reply lookup"), now); + + it.effect.each([ + { + observation: "T3Gateway.getThreadStatus", + action: "T3Gateway.provisionThread", + seed: planned, + hang: (started: Deferred.Deferred, cutOff: Deferred.Deferred): ServiceInput => { + let reads = 0; + return { + t3Gateway: { + getThreadStatus: () => { + reads += 1; + return reads === 1 + ? Deferred.succeed(started, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(cutOff, undefined)), + ) + : Effect.succeed({ thread: "present" as const }); + }, + getTurnStatus: () => + Effect.succeed({ turn: "completed" as const, reply: settledReply }), + }, + }; + }, + expectedCalls: [ + "T3Gateway.getThreadStatus", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (at: number) => + toReplyPosted( + toReplyPending(toThreadCreated(planned, at), settledReply, at), + postedReplyUri, + at, + ), + }, + { + observation: "T3Gateway.getTurnStatus", + action: "T3Gateway.startTurn", + seed: threadCreated, + hang: (started: Deferred.Deferred, cutOff: Deferred.Deferred): ServiceInput => { + let reads = 0; + return { + t3Gateway: { + getTurnStatus: () => { + reads += 1; + return reads === 1 + ? Deferred.succeed(started, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(cutOff, undefined)), + ) + : Effect.succeed({ turn: "completed" as const, reply: settledReply }); + }, + }, + }; + }, + expectedCalls: [ + "T3Gateway.getTurnStatus", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (at: number) => + toReplyPosted(toReplyPending(threadCreated, settledReply, at), postedReplyUri, at), + }, + { + observation: "NTBSAdapter.findPostedReply", + action: "NTBSAdapter.postReply", + seed: hungReplyPending, + hang: (started: Deferred.Deferred, cutOff: Deferred.Deferred): ServiceInput => { + let reads = 0; + return { + adapter: { + findPostedReply: () => { + reads += 1; + return reads === 1 + ? Deferred.succeed(started, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(cutOff, undefined)), + ) + : Effect.succeed(postedReplyUri); + }, + }, + }; + }, + expectedCalls: ["NTBSAdapter.findPostedReply", "NTBSAdapter.findPostedReply"], + expectedState: (at: number) => toReplyPosted(hungReplyPending, postedReplyUri, at), + }, + ] as const)( + "times out $observation, releases the lock, and does not call $action", + ({ observation, seed, hang, expectedCalls, expectedState }) => { + const started = Deferred.makeUnsafe(); + const cutOff = Deferred.makeUnsafe(); + + return withProcessor( + hang(started, cutOff), + ({ processor, repository, calls, pingActivity, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(seed); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(started); + + yield* TestClock.adjust("10 seconds"); + // The cancelled read proves the observe timeout cut the call off. + yield* Deferred.await(cutOff); + const resumedAt = yield* Clock.currentTimeMillis; + + // A crash would also have released the lock, so liveness needs its own check. + expect(run.pollUnsafe()).toBeUndefined(); + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([observation]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(seed); + + // A later thread-activity ping proves `run` outlived the timeout: only a live run + // consumes the ping and drives the exchange on from the state the timeout left. + yield* pingActivity(defaultThreadId); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual(expectedCalls); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + expectedState(resumedAt), + ); + + yield* Fiber.interrupt(run); + }), + ); + }, + ); + + /* + A failed status check is only "wait" while the state still has time left. Once it is expired + the failure must move the exchange to its terminal outcome instead: a failure reply posted for + WorkPlanned and ThreadCreated, Undeliverable for ReplyPending. Whether the check fails at once + or hangs, the outcome is the same; a failing or hung check must not strand the exchange past + its deadline. + */ + const neverCheckedReplyPending = toReplyPending( + threadCreated, + answer("A reply that was never checked"), + now, + ); + + const expiredCheckScenarios = [ + { + observation: "T3Gateway.getThreadStatus", + seed: planned, + fail: (): ServiceInput => ({ + t3Gateway: { + getThreadStatus: () => + new RetryableError({ + reason: "Thread lookup failed", + cause: "test failure", + method: "getThreadStatus", + }), + }, + }), + hang: (started: Deferred.Deferred): ServiceInput => ({ + t3Gateway: { + getThreadStatus: () => + Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)), + }, + }), + settledTag: "reply-posted" as const, + expectedCalls: [ + "T3Gateway.getThreadStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (at: number) => toReplyPosted(toExpired(planned, at), postedReplyUri, at), + }, + { + observation: "T3Gateway.getTurnStatus", + seed: threadCreated, + fail: (): ServiceInput => ({ + t3Gateway: { + getTurnStatus: () => + new RetryableError({ + reason: "Turn lookup failed", + cause: "test failure", + method: "getTurnStatus", + }), + }, + }), + hang: (started: Deferred.Deferred): ServiceInput => ({ + t3Gateway: { + getTurnStatus: () => + Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)), + }, + }), + settledTag: "reply-posted" as const, + expectedCalls: [ + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (at: number) => + toReplyPosted(toExpired(threadCreated, at), postedReplyUri, at), + }, + { + observation: "NTBSAdapter.findPostedReply", + seed: neverCheckedReplyPending, + fail: (): ServiceInput => ({ + adapter: { + findPostedReply: () => + new AdapterError({ reason: "Reply lookup failed", cause: "test failure" }), + }, + }), + hang: (started: Deferred.Deferred): ServiceInput => ({ + adapter: { + findPostedReply: () => + Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)), + }, + }), + settledTag: "undeliverable" as const, + expectedCalls: ["NTBSAdapter.findPostedReply"], + expectedState: (at: number) => + toUndeliverable( + neverCheckedReplyPending, + { message: "The platform did not accept the reply in time." }, + at, + ), + }, + ] as const; + + it.effect.each(expiredCheckScenarios)( + "expires an exchange to its terminal outcome when $observation fails after expiry", + ({ seed, fail, settledTag, expectedCalls, expectedState }) => + withProcessor(fail(), ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(seed); + + yield* TestClock.adjust("61 minutes"); + const expiredAt = yield* Clock.currentTimeMillis; + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, settledTag); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual(expectedCalls); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + expectedState(expiredAt), + ); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + The hung variant: the state is already expired when the check hangs, so the observation runs + to the observe timeout and the failure becomes unknown. Expiry, not the hang, decides the + outcome. + */ + it.effect.each(expiredCheckScenarios)( + "expires an exchange to its terminal outcome when $observation hangs after expiry", + ({ seed, hang, settledTag, expectedCalls, expectedState }) => { + const started = Deferred.makeUnsafe(); + + return withProcessor(hang(started), ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(seed); + + yield* TestClock.adjust("61 minutes"); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(started); + + yield* TestClock.adjust("10 seconds"); + const expiredAt = yield* Clock.currentTimeMillis; + + yield* awaitStoredTag(request.sourceUri, settledTag); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual(expectedCalls); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + expectedState(expiredAt), + ); + + yield* Fiber.interrupt(run); + }), + ); + }, + ); + + /* + Confirmed completion is recorded even after the state's deadline. A present thread is + recorded, a completed turn yields its reply, and a reply already on the platform is recorded + as posted instead of expiring or posting again. + */ + const discoveredPostedReplyUri = "test://reply/discovered-after-expiry"; + const lateReplyPending = toReplyPending( + threadCreated, + answer("A reply the platform already accepted"), + now, + ); + + it.effect.each([ + { + observation: "T3Gateway.getThreadStatus", + seed: planned, + succeed: (): ServiceInput => ({ + t3Gateway: { + getThreadStatus: () => Effect.succeed({ thread: "present" as const }), + getTurnStatus: () => Effect.succeed({ turn: "completed" as const, reply: settledReply }), + }, + }), + expectedCalls: [ + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (at: number) => + toReplyPosted( + toReplyPending(toThreadCreated(planned, at), settledReply, at), + postedReplyUri, + at, + ), + }, + { + observation: "T3Gateway.getTurnStatus", + seed: threadCreated, + succeed: (): ServiceInput => ({ + t3Gateway: { + getTurnStatus: () => Effect.succeed({ turn: "completed" as const, reply: settledReply }), + }, + }), + expectedCalls: [ + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (at: number) => + toReplyPosted(toReplyPending(threadCreated, settledReply, at), postedReplyUri, at), + }, + { + observation: "NTBSAdapter.findPostedReply", + seed: lateReplyPending, + succeed: (): ServiceInput => ({ + adapter: { + findPostedReply: () => Effect.succeed(discoveredPostedReplyUri), + }, + }), + expectedCalls: ["NTBSAdapter.findPostedReply"], + expectedState: (at: number) => toReplyPosted(lateReplyPending, discoveredPostedReplyUri, at), + }, + ] as const)( + "records the confirmed result of a $observation check that succeeds after expiry", + ({ seed, succeed, expectedCalls, expectedState }) => + withProcessor(succeed(), ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(seed); + + yield* TestClock.adjust("61 minutes"); + const confirmedAt = yield* Clock.currentTimeMillis; + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual(expectedCalls); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + expectedState(confirmedAt), + ); + + yield* Fiber.interrupt(run); + }), + ), + ); + + /* + Planning has its own timeout, shorter than the state's deadline. A plan that hangs is + abandoned at that timeout: nothing transitions, no coordinates are invented, and the record + stays RequestAccepted for a later pass. That pass either plans for real if the deadline has + not passed, or expires the record once it has. + The pass failure itself belongs to the background processor and is logged, not returned. + */ + it.effect.each([ + { + outcome: "re-plans and finishes", + laterAdvance: "1 minute", + expectedCalls: [ + "T3Gateway.planCoordinates", + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (acceptedState: typeof accepted, at: number) => + toReplyPosted( + toReplyPending( + toThreadCreated(toWorkPlanned(acceptedState, defaultWorkCoordinates, at), at), + settledReply, + at, + ), + postedReplyUri, + at, + ), + }, + { + outcome: "expires", + laterAdvance: "5 minutes", + expectedCalls: [ + "T3Gateway.planCoordinates", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ], + expectedState: (acceptedState: typeof accepted, at: number) => + toReplyPosted(toExpired(acceptedState, at), postedReplyUri, at), + }, + ] as const)( + "leaves RequestAccepted after a planning timeout, and a later pass $outcome", + ({ laterAdvance, expectedCalls, expectedState }) => { + const planStarted = Deferred.makeUnsafe(); + const planCutOff = Deferred.makeUnsafe(); + let planCalls = 0; + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => { + planCalls += 1; + return planCalls === 1 + ? Deferred.succeed(planStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(planCutOff, undefined)), + ) + : Effect.succeed(defaultWorkCoordinates); + }, + getThreadStatus: () => Effect.succeed({ thread: "present" }), + getTurnStatus: () => Effect.succeed({ turn: "completed", reply: settledReply }), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe( + Effect.forkChild({ startImmediately: true }), + ); + + // Staggered off the sweep boundary so the plan timeout and a sweep cannot fall on the same clock tick. + yield* TestClock.adjust("10 seconds"); + const acceptedAt = yield* Clock.currentTimeMillis; + const acceptedState = makeRequestAccepted(request, target, acceptedAt); + yield* processor.process(request, target); + yield* Deferred.await(planStarted); + + // The planning timeout is one minute, well under the state's five; the hung pass is abandoned without a transition. + yield* TestClock.adjust("1 minute"); + // The cancelled signal proves the timeout cut the call off, before the run is interrupted. + yield* Deferred.await(planCutOff); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(acceptedState); + + yield* Fiber.interrupt(firstRun); + + yield* TestClock.adjust(laterAdvance); + const at = yield* Clock.currentTimeMillis; + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual(expectedCalls); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + expectedState(acceptedState, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }, + ); + + /* + Provisioning has its own timeout too. A hung provision is abandoned at that timeout and the + exchange stays WorkPlanned, with no second provision attempted; the next pass observes before + acting. A thread the timed-out provision had in fact already created (the dispatch committed, + the call just never returned) is then discovered and recorded rather than provisioned again. + The worktree itself is untouched here: compensation lives inside the gateway, and only the + gateway's own test can see it. + */ + it.effect( + "leaves WorkPlanned after a provisioning timeout and later discovers a created thread", + () => { + const provisionStarted = Deferred.makeUnsafe(); + const provisionCutOff = Deferred.makeUnsafe(); + let threadStatusReads = 0; + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => { + threadStatusReads += 1; + return Effect.succeed( + threadStatusReads === 1 + ? { thread: "missing" as const } + : { thread: "present" as const }, + ); + }, + provisionThread: () => + Deferred.succeed(provisionStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(provisionCutOff, undefined)), + ), + getTurnStatus: () => + Effect.succeed({ turn: "completed" as const, reply: settledReply }), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe( + Effect.forkChild({ startImmediately: true }), + ); + + // Staggered off the sweep boundary so the provisioning timeout and a sweep cannot fall on the same clock tick. + yield* TestClock.adjust("10 seconds"); + const acceptedAt = yield* Clock.currentTimeMillis; + const acceptedState = makeRequestAccepted(request, target, acceptedAt); + const plannedState = toWorkPlanned(acceptedState, defaultWorkCoordinates, acceptedAt); + yield* processor.process(request, target); + yield* Deferred.await(provisionStarted); + + // Provisioning has five minutes, less than the state's fifteen. + yield* TestClock.adjust("5 minutes"); + // The cancelled signal proves the timeout cut the call off, before the run is interrupted. + yield* Deferred.await(provisionCutOff); + + // The plan survived the timeout and only the one provision was attempted. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(plannedState); + + const at = yield* Clock.currentTimeMillis; + yield* Fiber.interrupt(firstRun); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + // The second observation found the thread present, so provisioning was not repeated. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "T3Gateway.provisionThread", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted( + toReplyPending(toThreadCreated(plannedState, at), settledReply, at), + postedReplyUri, + at, + ), + ); + + yield* Fiber.interrupt(run); + }), + ); + }, + ); + + /* + Turn start has its own timeout too. A hung start is abandoned at that timeout, the exchange + stays ThreadCreated, and no second start is attempted. The next pass observes first, so a turn + the timed-out start had in fact already begun (the dispatch committed, the call just never + returned) is discovered rather than started twice. + */ + it.effect("leaves ThreadCreated after a turn-start timeout and later discovers the turn", () => { + const startStarted = Deferred.makeUnsafe(); + const startCutOff = Deferred.makeUnsafe(); + let turnStatusReads = 0; + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => Effect.succeed({ thread: "present" }), + getTurnStatus: () => { + turnStatusReads += 1; + return Effect.succeed( + turnStatusReads === 1 + ? { turn: "missing" as const } + : { turn: "completed" as const, reply: settledReply }, + ); + }, + startTurn: () => + Deferred.succeed(startStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(startCutOff, undefined)), + ), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* Deferred.await(startStarted); + + // Turn start has thirty seconds, well under the state's hour. + yield* TestClock.adjust("30 seconds"); + // The cancelled signal proves the timeout cut the call off, before the run is interrupted. + yield* Deferred.await(startCutOff); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + const at = yield* Clock.currentTimeMillis; + yield* Fiber.interrupt(firstRun); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + // The second observation found the turn, so it was not started a second time. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(toReplyPending(threadCreated, settledReply, at), postedReplyUri, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Posting has its own timeout too. A hung post is abandoned at that timeout, the exchange stays + ReplyPending, and no second post is attempted. The next pass observes first, so a reply the + timed-out post had in fact already delivered (the platform accepted it, the call just never + returned) is found on the platform and recorded instead of posted again. + */ + it.effect("leaves ReplyPending after a reply-post timeout and later discovers the reply", () => { + const postStarted = Deferred.makeUnsafe(); + const postCutOff = Deferred.makeUnsafe(); + const discoveredReplyUri = "test://reply/posted-before-timeout"; + let findReads = 0; + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => Effect.succeed({ thread: "present" }), + getTurnStatus: () => Effect.succeed({ turn: "completed", reply: settledReply }), + }, + adapter: { + findPostedReply: () => { + findReads += 1; + return Effect.succeed(findReads === 1 ? null : discoveredReplyUri); + }, + postReply: () => + Deferred.succeed(postStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(postCutOff, undefined)), + ), + }, + }, + ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* Deferred.await(postStarted); + + // Posting has thirty seconds, well under the state's hour. + yield* TestClock.adjust("30 seconds"); + // The cancelled signal proves the timeout cut the call off, before the run is interrupted. + yield* Deferred.await(postCutOff); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + const replyPending = toReplyPending(threadCreated, settledReply, now); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(replyPending); + + const at = yield* Clock.currentTimeMillis; + yield* Fiber.interrupt(firstRun); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + // The second lookup found the reply, so it was not posted a second time. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + "NTBSAdapter.findPostedReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(replyPending, discoveredReplyUri, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + The acknowledgement is best-effort and not part of the durable exchange. A hung one is cut + off at its own timeout and swallowed, never undoing the ThreadCreated state that was already + persisted before it was attempted. The pipeline simply carries on to the turn. + */ + it.effect("keeps ThreadCreated when the acknowledgement times out", () => { + const acknowledgeStarted = Deferred.makeUnsafe(); + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => Effect.succeed({ thread: "present" }), + }, + adapter: { + acknowledge: () => + Deferred.succeed(acknowledgeStarted, undefined).pipe(Effect.andThen(Effect.never)), + }, + }, + ({ processor, repository, calls, awaitCalls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* processor.process(request, target); + yield* Deferred.await(acknowledgeStarted); + + // Persisted before the acknowledgement was even attempted. + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* TestClock.adjust("10 seconds"); + yield* awaitCalls(5); + + // The timeout was swallowed and the pipeline continued as if the acknowledgement failed. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + "T3Gateway.getThreadStatus", + "NTBSAdapter.acknowledge", + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + An action may not outlive the deadline of the state it acts on. `act` gives the underlying + effect `min(its own limit, time left on the state)`, so a state already close to its deadline + cannot be held open for the full length of an action whose own limit is longer. + */ + it.effect("gives an action no more than the time remaining before its deadline", () => { + const startTurnStarted = Deferred.makeUnsafe(); + const startTurnInterrupted = Deferred.makeUnsafe(); + + return withProcessor( + { + t3Gateway: { + startTurn: () => + Deferred.succeed(startTurnStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(startTurnInterrupted, undefined)), + ), + }, + }, + ({ processor, repository, calls, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + // Ten seconds left before ThreadCreated expires, well under startTurn's thirty. + yield* TestClock.adjust("3590 seconds"); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(startTurnStarted); + + // One second short of the deadline: the action is still running, uncut. + yield* TestClock.adjust("9 seconds"); + yield* settle(); + expect(Deferred.isDoneUnsafe(startTurnInterrupted)).toBe(false); + + // At the deadline it is cut off, exactly as the state expires. + yield* TestClock.adjust("1 second"); + yield* settle(); + expect(Deferred.isDoneUnsafe(startTurnInterrupted)).toBe(true); + + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A timeout is not an outcome. It leaves the exchange exactly where it was, writing no failure + reply and cleaning up nothing. The next observation decides what actually happened. + */ + it.effect("leaves the outcome to the next observation after an action timeout", () => { + const startTurnStarted = Deferred.makeUnsafe(); + const startTurnInterrupted = Deferred.makeUnsafe(); + + return withProcessor( + { + t3Gateway: { + startTurn: () => + Deferred.succeed(startTurnStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(startTurnInterrupted, undefined)), + ), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + // Ten seconds left, so the turn-start timeout lands exactly on the deadline. + yield* TestClock.adjust("3590 seconds"); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(startTurnStarted); + yield* TestClock.adjust("10 seconds"); + yield* settle(); + + // The timeout wrote nothing: still the same non-terminal record, no reply. + expect(Deferred.isDoneUnsafe(startTurnInterrupted)).toBe(true); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + // The next observation decides: the turn is still missing and the deadline has passed, + // so the exchange expires to its failure reply. + yield* pingActivity(defaultThreadId); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + const at = yield* Clock.currentTimeMillis; + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(toExpired(threadCreated, at), postedReplyUri, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* An expired request skips planning and proceeds to its failure reply. */ + it.effect("does not start an action for a state that is already expired", () => { + return withProcessor({}, ({ processor, repository, calls, awaitStoredTag }) => + Effect.gen(function* () { + yield* repository.upsert(accepted); + + yield* TestClock.adjust("5 minutes"); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + const at = yield* Clock.currentTimeMillis; + // Planning never ran: the exchange expired to its failure reply instead. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(toExpired(accepted, at), postedReplyUri, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A run interrupted while a worker is mid-pass must not leave its thread marked as busy: the run that replaces it has to process that thread's events again, not swallow them. + */ + it.effect("processes a thread again after a run is interrupted mid-pass", () => { + const firstRecovery = Deferred.makeUnsafe(); + const parked = Deferred.makeUnsafe(); + const secondRecovery = Deferred.makeUnsafe(); + const reprocessed = Deferred.makeUnsafe(); + let reads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.gen(function* () { + reads += 1; + + if (reads === 1) { + yield* Deferred.succeed(firstRecovery, undefined); + } else if (reads === 2) { + yield* Deferred.succeed(parked, undefined); + yield* Effect.sleep("1 hour"); + } else if (reads === 3) { + yield* Deferred.succeed(secondRecovery, undefined); + } else if (reads === 4) { + yield* Deferred.succeed(reprocessed, undefined); + } + + return { turn: "active" as const }; + }), + }, + }, + ({ processor, repository, pingActivity }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + // First run: recovery reads (1), then a ping's pass parks mid-read (2). + const firstRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(firstRecovery); + yield* Effect.yieldNow; + + yield* pingActivity(defaultThreadId); + yield* Deferred.await(parked); + + yield* Fiber.interrupt(firstRun); + + // Second run: recovery reads (3), and the same ping has to be processed again (4). + const secondRun = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(secondRecovery); + yield* Effect.yieldNow; + + yield* pingActivity(defaultThreadId); + yield* Deferred.await(reprocessed); + + expect(reads).toBe(4); + + yield* Fiber.interrupt(secondRun); + }), + ); + }); + + /* + Activity that arrives for an exchange while recovery is reading it has to be read again after that pass: the event arrived during the pass, so folding it in would miss it. + */ + it.effect("waits for an in-flight recovery pass before checking the same exchange", () => { + const recoveryRead = Deferred.makeUnsafe(); + const release = Deferred.makeUnsafe(); + const checkedAgain = Deferred.makeUnsafe(); + let reads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.gen(function* () { + reads += 1; + + if (reads === 1) { + yield* Deferred.succeed(recoveryRead, undefined); + yield* Deferred.await(release); + } else if (reads === 2) { + yield* Deferred.succeed(checkedAgain, undefined); + } + + return { turn: "active" as const }; + }), + }, + }, + ({ processor, repository, pingActivity, findByThreadIdCalls, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(recoveryRead); + + yield* pingActivity(defaultThreadId); + yield* settle(); + + // Recovery is still reading: no further read can have happened, and the waiting pass must not be re-resolving the thread in a retry loop. + expect(reads).toBe(1); + expect(findByThreadIdCalls()).toBe(1); + + yield* Deferred.succeed(release, undefined); + yield* Deferred.await(checkedAgain); + + expect(reads).toBe(2); + expect(findByThreadIdCalls()).toBe(1); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Activity that arrives for an exchange while the sweeper is reading it has to be read again after that pass, exactly as behind startup recovery: the sweeper drives the exchange through the same pass, so folding the ping into a pass that already observed the state would miss its event. + */ + it.effect("waits for an in-flight sweep pass before checking the same exchange", () => { + const release = Deferred.makeUnsafe(); + const checkedAgain = Deferred.makeUnsafe(); + let reads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => + Effect.gen(function* () { + reads += 1; + + if (reads === 2) { + yield* Deferred.await(release); + } else if (reads === 3) { + yield* Deferred.succeed(checkedAgain, undefined); + } + + return { turn: "active" as const }; + }), + }, + }, + ({ processor, repository, pingActivity, findByThreadIdCalls, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + const sweepTookOver = () => reads >= 2; + // Read 1 is startup recovery. The sweeper's delay starts once that pass ends, so keep advancing until the sweep takes read 2 and parks there. + while (!sweepTookOver()) { + yield* TestClock.adjust("1 minute"); + yield* Effect.yieldNow; + } + + yield* pingActivity(defaultThreadId); + yield* settle(); + + // The sweep still owns the exchange: the ping waits without re-resolving the thread. + expect(reads).toBe(2); + expect(findByThreadIdCalls()).toBe(1); + + yield* Deferred.succeed(release, undefined); + yield* Deferred.await(checkedAgain); + + expect(reads).toBe(3); + expect(findByThreadIdCalls()).toBe(1); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A sweep that reaches an exchange whose activity pass is in flight skips it and moves on: waiting for that pass would let one busy exchange stall every later exchange, and every later sweep. + */ + it.effect("skips an exchange whose pass is in flight when sweeping", () => { + const recovered = Deferred.makeUnsafe(); + const parked = Deferred.makeUnsafe(); + const release = Deferred.makeUnsafe(); + const otherThreadSweptAgain = Deferred.makeUnsafe(); + let threadStatusReads = 0; + let provisions = 0; + let otherThreadReads = 0; + + return withProcessor( + { + t3Gateway: { + getThreadStatus: () => + Effect.gen(function* () { + threadStatusReads += 1; + + if (threadStatusReads === 1) { + yield* Deferred.succeed(recovered, undefined); + // Startup recovery leaves the planned exchange alone; the ping's pass then provisions it. + return { thread: "unknown" as const }; + } + + return { thread: "missing" as const }; + }), + getTurnStatus: () => + Effect.gen(function* () { + otherThreadReads += 1; + + if (otherThreadReads === 3) { + yield* Deferred.succeed(otherThreadSweptAgain, undefined); + } + + return { turn: "active" as const }; + }), + provisionThread: () => + Effect.gen(function* () { + provisions += 1; + yield* Deferred.succeed(parked, undefined); + // Long enough that the pass is still in flight when the sweeps run. + yield* Deferred.await(release); + }), + }, + }, + ({ processor, repository, pingActivity, findByThreadIdCalls }) => + Effect.gen(function* () { + yield* repository.upsert(planned); + yield* repository.upsert(secondThreadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + // Startup recovery reads the planned exchange first; the ping's pass then parks inside provisioning, owning the exchange across several sweep intervals. + yield* Deferred.await(recovered); + yield* pingActivity(defaultThreadId); + yield* Deferred.await(parked); + + const otherThreadWasSwept = () => otherThreadReads >= 2; + // The sweep's delay starts once recovery ends; each adjustment polls the sweep on. + while (!otherThreadWasSwept()) { + yield* TestClock.adjust("1 minute"); + yield* Effect.yieldNow; + } + + // The other exchange was swept while the parked one was skipped, not waited on. + expect(threadStatusReads).toBe(2); + expect(provisions).toBe(1); + + yield* TestClock.adjust("1 minute"); + yield* Deferred.await(otherThreadSweptAgain); + + expect(threadStatusReads).toBe(2); + expect(provisions).toBe(1); + expect(findByThreadIdCalls()).toBe(1); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + The sweeper is the backstop for a timeout nothing else wakes. After the timed-out attempt + leaves the exchange untouched, the next sweep re-drives it and a fresh observation finishes it. + */ + it.effect("re-drives a timed-out exchange from the sweeper", () => { + const startTurnStarted = Deferred.makeUnsafe(); + const reply = answer("Reply after the sweep"); + let turnStatusReads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => { + turnStatusReads += 1; + return Effect.succeed( + turnStatusReads === 1 + ? { turn: "missing" as const } + : { turn: "completed" as const, reply }, + ); + }, + startTurn: () => + Deferred.succeed(startTurnStarted, undefined).pipe(Effect.andThen(Effect.never)), + }, + }, + ({ processor, repository, calls, awaitStoredTag, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(startTurnStarted); + + // The attempt times out with the record untouched; nothing else wakes it. + yield* TestClock.adjust("30 seconds"); + yield* settle(); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + // One sweep interval after recovery finished, the sweeper picks it up again. + yield* TestClock.adjust("1 minute"); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + const at = yield* Clock.currentTimeMillis; + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(toReplyPending(threadCreated, reply, at), postedReplyUri, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + Thread activity wakes a timed-out exchange too. The ping arrives after the timed-out attempt, + re-runs the observation, and the confirmed result finishes the exchange. + */ + it.effect("re-drives a timed-out exchange from a thread-activity event", () => { + const startTurnStarted = Deferred.makeUnsafe(); + const reply = answer("Reply after the activity ping"); + let turnStatusReads = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: () => { + turnStatusReads += 1; + return Effect.succeed( + turnStatusReads === 1 + ? { turn: "missing" as const } + : { turn: "completed" as const, reply }, + ); + }, + startTurn: () => + Deferred.succeed(startTurnStarted, undefined).pipe(Effect.andThen(Effect.never)), + }, + }, + ({ processor, repository, calls, pingActivity, awaitStoredTag, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(startTurnStarted); + yield* TestClock.adjust("30 seconds"); + yield* settle(); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* pingActivity(defaultThreadId); + yield* awaitStoredTag(request.sourceUri, "reply-posted"); + + const at = yield* Clock.currentTimeMillis; + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.getTurnStatus", + "T3Gateway.startTurn", + "T3Gateway.getTurnStatus", + "NTBSAdapter.findPostedReply", + "NTBSAdapter.postReply", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + toReplyPosted(toReplyPending(threadCreated, reply, at), postedReplyUri, at), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A redelivery is not stranded by a pass that times out: it reads the recorded request and returns immediately, and the abandoned pass leaves the record untouched. + */ + it.effect("returns a redelivery while the first pass is still hung", () => { + const planStarted = Deferred.makeUnsafe(); + const planCutOff = Deferred.makeUnsafe(); + + return withProcessor( + { + t3Gateway: { + planCoordinates: () => + Deferred.succeed(planStarted, undefined).pipe( + Effect.andThen(Effect.never), + Effect.onInterrupt(() => Deferred.succeed(planCutOff, undefined)), + ), + }, + }, + ({ processor, repository, calls }) => + Effect.gen(function* () { + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + + // Staggered off the sweep boundary so the plan timeout and a sweep cannot fall on the same clock tick. + yield* TestClock.adjust("10 seconds"); + const acceptedAt = yield* Clock.currentTimeMillis; + yield* processor.process(request, target); + yield* Deferred.await(planStarted); + + // The record exists; the redelivery returns without waiting on the hung pass. + const second = yield* processor + .process(request, target) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Fiber.join(second); + + // Planning's timeout is a minute, well inside the state's five. + yield* TestClock.adjust("1 minute"); + // The cancelled read proves the timeout cut the pass off. + yield* Deferred.await(planCutOff); + + // The redelivery found the record and planned nothing; the abandoned pass left it untouched. + expect(calls.map((call) => `${call.service}.${call.method}`)).toEqual([ + "T3Gateway.planCoordinates", + ]); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual( + makeRequestAccepted(request, target, acceptedAt), + ); + + yield* Fiber.interrupt(run); + }), + ); + }); + + /* + A timeout is contained to its own exchange. The run keeps going after one: a second exchange + stored only after the first has timed out is still swept and reaches its reply. + */ + it.effect("does not let one timed-out exchange stop the others", () => { + const startTurnStarted = Deferred.makeUnsafe(); + const reply = answer("Reply from the untroubled exchange", secondWorkCoordinates); + let startTurnCalls = 0; + + return withProcessor( + { + t3Gateway: { + getTurnStatus: (state) => + state.sourceUri === secondRequest.sourceUri + ? Effect.succeed({ turn: "completed" as const, reply }) + : Effect.succeed({ turn: "missing" as const }), + // The stuck exchange hangs on its first turn start; later attempts are fine. + startTurn: (state) => { + if (state.sourceUri !== request.sourceUri) { + return Effect.void; + } + startTurnCalls += 1; + return startTurnCalls === 1 + ? Deferred.succeed(startTurnStarted, undefined).pipe(Effect.andThen(Effect.never)) + : Effect.void; + }, + }, + }, + ({ processor, repository, awaitStoredTag, settle }) => + Effect.gen(function* () { + yield* repository.upsert(threadCreated); + + const run = yield* processor.run.pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(startTurnStarted); + + // The stuck exchange times out during startup recovery, leaving the record untouched. + yield* TestClock.adjust("30 seconds"); + yield* settle(); + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + // Stored only now, so the sweeper is the only thing that can reach it. That it arrives + // at its reply proves the run survived the other exchange's timeout. + yield* repository.upsert(secondThreadCreated); + yield* TestClock.adjust("1 minute"); + yield* awaitStoredTag(secondRequest.sourceUri, "reply-posted"); + + expect(yield* repository.findBySourceUri(request.sourceUri)).toEqual(threadCreated); + + yield* Fiber.interrupt(run); + }), + ); + }); +}); diff --git a/apps/server/src/ntbs/processor.ts b/apps/server/src/ntbs/processor.ts new file mode 100644 index 000000000000..5e8abe77664a --- /dev/null +++ b/apps/server/src/ntbs/processor.ts @@ -0,0 +1,761 @@ +import { type ThreadId } from "@t3tools/contracts"; +import * as NTBS from "./exchange.ts"; +import { + Cause, + Clock, + Context, + Data, + Deferred, + Duration, + Effect, + Exit, + HashMap, + Option, + Queue, + Ref, + Result, + Semaphore, + Stream, +} from "effect"; +import { NTBSAdapter } from "./adapter.ts"; +import { T3Gateway } from "./t3gateway.ts"; +import { ExchangeRepository } from "./ExchangeRepository.ts"; + +/* +The processor is the executor and orchestrator of non-turn-based surfaces: it applies the business rules and connects T3 to the external platform. It does so through three services: + +- the adapter: communication with the external platform +- the T3 gateway: communication and dispatching of T3 internals +- the exchange repository: durable link between the two, stores the exchange state + +It exposes two public APIs: +1. `process` records an incoming message as an exchange and wakes `run` to work on it. +2. `run` subscribes to T3 activity and to recorded requests, and resumes the exchanges a previous run left unfinished. + +`run` also owns an internal sweeper: a periodic pass that re-drives every non-terminal exchange, the same thing startup recovery does but on an interval. +Activity and recorded requests are fire-and-forget wakes: without the sweeper one missed wake-up would leave an exchange stuck until the next restart. +Sweeping is cheap and safe because the cycle observes before acting: re-driving an exchange whose context has not moved just answers "wait" and stops. + +Both drive an exchange through the same cycle, repeated until it reaches a terminal state: + +load the stored state +-> read live context from the service that owns it +-> decide what to do given state and context +-> execute the decision +-> build the resulting state transition and persist it + +The cycle is replay safe: it observes before acting, so a crash or a redelivered message re-runs it without starting a second thread or posting a second reply. +*/ + +export class NTBSProcessorError extends Data.TaggedError("NTBSProcessorError")<{ + reason: string; + cause: unknown; +}> {} + +const SWEEP_INTERVAL = "1 minute"; + +/* + Process several exchanges at once so one slow call does not block the others. Limit concurrent handlers to keep resource usage bounded. +*/ +const MAX_CONCURRENT_ACTIVITY_HANDLERS = 8; + +/* + The following timeouts limit how long the NTBS processor waits for specific external events. + + E.g. the processor cannot hang forever waiting the response of a database query or for T3 to start a turn. + + With those we can make the user experience and business logic more linear and a stuck dependency cannot block the processing of an exchange forever. + + E.g. if `yield someReadOperation` remains stuck, without timeouts the processing would fall in a limbo forever with the processor holding the exchange's lock forever. +*/ +const OBSERVE_TIMEOUT = Duration.toMillis(Duration.seconds(10)); +const PLAN_COORDINATES_TIMEOUT = Duration.toMillis(Duration.minutes(1)); +const PROVISION_THREAD_TIMEOUT = Duration.toMillis(Duration.minutes(5)); +const START_TURN_TIMEOUT = Duration.toMillis(Duration.seconds(30)); +const POST_REPLY_TIMEOUT = Duration.toMillis(Duration.seconds(30)); +const ACKNOWLEDGE_TIMEOUT = Duration.toMillis(Duration.seconds(10)); + +/** + * TODO: Evaluate whether we can turn both observe and act below in one generic `attempt` helper. + * Also evaluate whether we need `Result` at all. + */ + +/** + * Checks external state without letting an unanswered check hold the exchange lock forever. + * The caller decides what to do with the failed observation. + */ +const observeWithTimeout = Effect.fn("NTBSProcessor.observeWithTimeout")(function* ( + state: NTBS.NonTerminalExchange, + effect: Effect.Effect, +) { + const now = yield* Clock.currentTimeMillis; + const remaining = NTBS.expiresAt(state) - now; + const timeout = remaining > 0 ? Math.min(OBSERVE_TIMEOUT, remaining) : OBSERVE_TIMEOUT; + return yield* effect.pipe(Effect.timeout(timeout), Effect.result); +}); + +/** + * Action equivalent of observeWithTimeout with one major difference: while observe allows for one additional execution after expiry, `act` does not retry. + * */ +const act = Effect.fn("NTBSProcessor.act")(function* ( + state: NTBS.NonTerminalExchange, + effect: Effect.Effect, + limit: number, +) { + const now = yield* Clock.currentTimeMillis; + const remaining = NTBS.expiresAt(state) - now; + if (remaining <= 0) { + return yield* new Cause.TimeoutError(); + } + + // A timeout cannot trigger a cleanup. + // It is not possible to undo queueing a command or the act of posting a platform response. The next attempt after a timeout should first re-observe the situation again. + return yield* effect.pipe(Effect.timeout(Math.min(limit, remaining))); +}); + +export interface NTBSProcessor { + /** + * Handles a request coming from an external platform. + * + * Does no filtering: the caller decides whether a request deserves T3 work, and everything passed here starts it. + * + * Returns once the request is recorded, not once it is answered: the record is where NTBS accepts responsibility, and `run` picks it up from there. The reply is posted later, when T3 reports the turn finished. + * Fails with a typed error only when the repository does. A failure after the record is the exchange's to keep: the record survives, and `run` retries it. + * + * Idempotent per `sourceUri`: a redelivery of an already-recorded request is a no-op, whatever state that exchange has reached. Concurrent deliveries of the same request are serialized, so only the first records it. + */ + readonly process: ( + request: NTBS.Request, + t3Target: NTBS.T3Target, + ) => Effect.Effect; + + /** + * The main loop of the processor. + * Subscribes to T3 activity and to the requests `process` records, then resumes every non-terminal exchange. Subscribing first means nothing is missed while recovery runs. After that, an exchange moves when its T3 thread does or when a request is recorded, with a periodic sweep re-driving every non-terminal exchange as the backstop for missed wake-ups. + * + * Expected failures are logged without stopping subsequent activity, requests or sweeps. + */ + readonly run: Effect.Effect; +} + +export const makeNTBSProcessorTag = (key: string) => Context.Service(key); + +type TransitionResult = + | { + readonly type: "transitioned"; + readonly state: NTBS.Exchange; + } + | { + readonly type: "unchanged"; + }; + +/** + * What the activity workers take from their queue: a thread whose T3 state may have moved, or a request that was just recorded. + */ +type ActivityPing = + | { readonly type: "thread"; readonly threadId: ThreadId } + | { readonly type: "recorded-request"; readonly sourceUri: string }; + +type NTBSProcessorRequirements = + /* + Communicates with the external platform. Which platform is decided by the context the processor is built in. + */ + | NTBSAdapter + /* + Creates worktrees and threads, starts turns, reports their progress, and provides the stream of T3 thread activity. + */ + | T3Gateway + /* + Stores and loads the exchange state, including the exchanges a previous run left unfinished. + */ + | ExchangeRepository; + +type ExchangeLock = { + readonly semaphore: Semaphore.Semaphore; + callers: number; +}; + +/** + * Builds a processor for the adapter found in the context. + * + * Build one per platform, each with its own adapter provided. + * + * TODO: Consider collapsing to a single runtime processor with one routing adapter that reads the platform from the sourceUri scheme (jira://, discord://) and delegates to the platform adapter. + * The current one-per-platform design has an unenforced assumption: `findNonTerminalExchanges` returns every stored exchange with no platform filter, so processors sharing a repository would re-drive each other's exchanges through the wrong adapter during recovery and sweeps. + * A single processor also means one lock map, one activity subscription, one sweeper, and retires `makeNTBSProcessorTag`. + */ +export const makeNTBSProcessor: Effect.Effect = + Effect.gen(function* () { + const adapter = yield* NTBSAdapter; + const t3 = yield* T3Gateway; + const repo = yield* ExchangeRepository; + + /* + Source URIs of requests `process` records. The queue lives outside `run`, so a wake offered before `run` starts or while it is down is not lost; if it is, startup recovery and the sweep advance the exchange anyway. + */ + const recordedRequests = yield* Queue.unbounded(); + + const orFail = (reason: string) => + Effect.mapError((cause: unknown) => new NTBSProcessorError({ reason, cause })); + + const transitionedTo = (state: NTBS.Exchange): TransitionResult => ({ + type: "transitioned", + state, + }); + + const unchanged: TransitionResult = { type: "unchanged" }; + + const persist = (state: State) => + repo.upsert(state).pipe(orFail("Failed to persist the exchange state"), Effect.as(state)); + + const expire = Effect.fn("NTBSProcessor.expire")(function* ( + state: NTBS.NonTerminalExchange, + now: number, + ) { + const next = yield* persist( + state.tag === "reply-pending" + ? NTBS.toUndeliverable( + state, + { message: "The platform did not accept the reply in time." }, + now, + ) + : NTBS.toExpired(state, now), + ); + return transitionedTo(next); + }); + + /** + * Serializes concurrent work on the same sourceUri, protecting the check-then-act record in `process` (findBySourceUri -> persist). + * The lock is in-process memory: single-writer is an assumption on the deployment, not something the code or the database enforces. + * Two processors on the same database would each pass the "no exchange yet" check, both record, and the upsert would silently overwrite the first record instead of failing. + * TODO: If we ever run more than one processor, this needs remote locking or a record that can lose (e.g. a unique insert on sourceUri that rejects the second writer). + */ + const exchangeLocks = new Map(); + + const withExchangeLock = (sourceUri: string, effect: Effect.Effect) => + Effect.suspend(() => { + let lock = exchangeLocks.get(sourceUri); + + if (lock === undefined) { + lock = { + semaphore: Semaphore.makeUnsafe(1), + callers: 0, + }; + exchangeLocks.set(sourceUri, lock); + } + + lock.callers += 1; + + return lock.semaphore.withPermit(effect).pipe( + Effect.ensuring( + Effect.sync(() => { + lock.callers -= 1; + if (lock.callers === 0 && exchangeLocks.get(sourceUri) === lock) { + exchangeLocks.delete(sourceUri); + } + }), + ), + ); + }); + + const processRequestAccepted = Effect.fn("NTBSProcessor.processRequestAccepted")(function* ( + state: NTBS.RequestAccepted, + ) { + const now = yield* Clock.currentTimeMillis; + const decision = NTBS.fromRequestAccepted(state, now); + + switch (decision.type) { + case "expire": { + return yield* expire(state, now); + } + + case "plan": { + // Planning creates nothing in T3, so there is nothing to observe first: plan, then record the outcome. + const outcome = yield* act( + state, + t3.planCoordinates(state.target.projectId, state.target.startBranchName), + PLAN_COORDINATES_TIMEOUT, + ).pipe(Effect.result); + const completedAt = yield* Clock.currentTimeMillis; + if (Result.isFailure(outcome)) { + if (outcome.failure._tag !== "FatalError") { + return yield* new NTBSProcessorError({ + reason: "Failed to plan the T3 work", + cause: outcome.failure, + }); + } + const next = yield* persist(NTBS.toRejected(state, outcome.failure, completedAt)); + return transitionedTo(next); + } + const next = yield* persist(NTBS.toWorkPlanned(state, outcome.success, completedAt)); + return transitionedTo(next); + } + } + }); + + const processWorkPlanned = Effect.fn("NTBSProcessor.processWorkPlanned")(function* ( + state: NTBS.WorkPlanned, + ) { + const observation = yield* observeWithTimeout(state, t3.getThreadStatus(state)); + const now = yield* Clock.currentTimeMillis; + const context: NTBS.WorkPlannedContext = Result.isFailure(observation) + ? { thread: "unknown" } + : observation.success; + if (Result.isFailure(observation)) { + yield* Effect.logWarning("Could not check whether the NTBS thread exists", { + sourceUri: state.sourceUri, + cause: observation.failure, + }); + } + const decision = NTBS.fromWorkPlanned(state, context, now); + + switch (decision.type) { + case "expire": { + return yield* expire(state, now); + } + + case "provision-thread": { + // TODO: Quite sure there's low hanging fruits here + const rejection = yield* act( + state, + t3.provisionThread(state), + PROVISION_THREAD_TIMEOUT, + ).pipe( + Effect.as(null), + Effect.catchTag("FatalError", (error) => Effect.succeed(error)), + orFail("Failed to provision the T3 thread"), + ); + + if (rejection !== null) { + const completedAt = yield* Clock.currentTimeMillis; + const next = yield* persist(NTBS.toRejected(state, rejection, completedAt)); + return transitionedTo(next); + } + + break; + } + + case "record-thread-created": + break; + + case "wait": + return unchanged; + } + + const completedAt = yield* Clock.currentTimeMillis; + const threadCreated = yield* persist(NTBS.toThreadCreated(state, completedAt)); + yield* adapter.acknowledge(threadCreated).pipe( + Effect.timeout(ACKNOWLEDGE_TIMEOUT), + Effect.catch((cause) => + Effect.logWarning("Failed to post the NTBS acknowledgement", { + sourceUri: threadCreated.sourceUri, + threadId: threadCreated.t3.threadId, + cause, + }), + ), + ); + return transitionedTo(threadCreated); + }); + + const processThreadCreated = Effect.fn("NTBSProcessor.processThreadCreated")(function* ( + state: NTBS.ThreadCreated, + ) { + const observation = yield* observeWithTimeout(state, t3.getTurnStatus(state)); + const now = yield* Clock.currentTimeMillis; + const context: NTBS.ThreadCreatedContext = Result.isFailure(observation) + ? { turn: "unknown" } + : observation.success; + if (Result.isFailure(observation)) { + yield* Effect.logWarning("Could not check the NTBS turn", { + sourceUri: state.sourceUri, + cause: observation.failure, + }); + } + const decision = NTBS.fromThreadCreated(state, context, now); + + switch (decision.type) { + case "expire": { + return yield* expire(state, now); + } + + case "start-turn": { + const rejection = yield* act(state, t3.startTurn(state), START_TURN_TIMEOUT).pipe( + Effect.as(null), + Effect.catchTag("FatalError", (error) => Effect.succeed(error)), + orFail("Failed to start the T3 turn"), + ); + + if (rejection !== null) { + const completedAt = yield* Clock.currentTimeMillis; + const replyPending = yield* persist(NTBS.toRejected(state, rejection, completedAt)); + return transitionedTo(replyPending); + } + + return unchanged; + } + + case "wait": + return unchanged; + + case "record-reply-pending": { + const next = yield* persist(NTBS.toReplyPending(state, decision.reply, now)); + return transitionedTo(next); + } + } + }); + + const processReplyPending = Effect.fn("NTBSProcessor.processReplyPending")(function* ( + state: NTBS.ReplyPending, + ) { + const observation = yield* observeWithTimeout(state, adapter.findPostedReply(state)); + const now = yield* Clock.currentTimeMillis; + const context: NTBS.ReplyPendingContext = Result.isFailure(observation) + ? { platformReply: "unknown" } + : observation.success === null + ? { platformReply: "missing" } + : { platformReply: "posted", replySourceUri: observation.success }; + if (Result.isFailure(observation)) { + yield* Effect.logWarning("Could not check whether the NTBS reply was posted", { + sourceUri: state.sourceUri, + cause: observation.failure, + }); + } + const decision = NTBS.fromReplyPending(state, context, now); + + switch (decision.type) { + case "expire": { + return yield* expire(state, now); + } + + case "post-reply": { + const delivery = yield* act(state, adapter.postReply(state), POST_REPLY_TIMEOUT).pipe( + Effect.map((postedReplySourceUri) => ({ + type: "posted" as const, + replySourceUri: postedReplySourceUri, + })), + Effect.catchTag("ReplyRejected", (error) => + Effect.succeed({ type: "rejected" as const, cause: error.cause }), + ), + orFail("Failed to post the platform reply"), + ); + + const completedAt = yield* Clock.currentTimeMillis; + const next = yield* persist( + delivery.type === "posted" + ? NTBS.toReplyPosted(state, delivery.replySourceUri, completedAt) + : NTBS.toUndeliverable(state, delivery.cause, completedAt), + ); + return transitionedTo(next); + } + + case "wait": + return unchanged; + + case "record-reply-posted": { + const next = yield* persist(NTBS.toReplyPosted(state, decision.replySourceUri, now)); + return transitionedTo(next); + } + } + }); + + const advanceExchange = Effect.fn("NTBSProcessor.advanceExchange")(function* ( + initial: NTBS.Exchange, + ) { + let state = initial; + + while (NTBS.isNonTerminal(state)) { + let result: TransitionResult; + + switch (state.tag) { + case "request-accepted": + result = yield* processRequestAccepted(state); + break; + + case "work-planned": + result = yield* processWorkPlanned(state); + break; + + case "thread-created": + result = yield* processThreadCreated(state); + break; + + case "reply-pending": + result = yield* processReplyPending(state); + break; + } + + if (result.type === "unchanged") { + return; + } + + state = result.state; + } + }); + + const advanceSavedExchange = Effect.fn("NTBSProcessor.advanceSavedExchange")(function* ( + sourceUri: string, + ) { + return yield* withExchangeLock( + sourceUri, + Effect.gen(function* () { + const exchange = yield* repo + .findBySourceUri(sourceUri) + .pipe(orFail("Failed to reload the exchange")); + + if (exchange === null || NTBS.isTerminal(exchange)) { + return; + } + + yield* advanceExchange(exchange); + }), + ); + }); + + /* + One pass over an exchange, called by the activity workers. + + A call that arrives while a pass is already running waits for it and then runs its own: the event that woke the worker arrived during that pass, so it has to be read after it. Waiting is also what keeps the thread from being requeued over and over while the pass is still in flight. + + `advanceSavedExchange` keeps the exchange lock, so this still serializes against `process`. + */ + const runningExchanges = new Map>(); + + const startExchangePass = (sourceUri: string): Effect.Effect => + Effect.suspend(() => { + const finished = Deferred.makeUnsafe(); + runningExchanges.set(sourceUri, finished); + + return advanceSavedExchange(sourceUri).pipe( + Effect.ensuring( + Effect.sync(() => { + runningExchanges.delete(sourceUri); + Deferred.doneUnsafe(finished, Exit.void); + }), + ), + ); + }); + + const resumeExchange = (sourceUri: string): Effect.Effect => + Effect.suspend(() => { + const running = runningExchanges.get(sourceUri); + + if (running === undefined) { + return startExchangePass(sourceUri); + } + + return Deferred.await(running).pipe(Effect.andThen(resumeExchange(sourceUri))); + }); + + /* + The pass the sweeper and startup recovery use, where a call is only a poke: an exchange that is already being processed is skipped. Activity for that exchange requests its own follow-up pass, and the next sweep provides recovery; waiting here would let one busy exchange stall the sequential sweep. + */ + const tryResumeExchange = (sourceUri: string): Effect.Effect => + Effect.suspend(() => { + if (runningExchanges.has(sourceUri)) { + return Effect.void; + } + + return startExchangePass(sourceUri); + }); + + const process = Effect.fn("NTBSProcessor.process")(function* ( + request: NTBS.Request, + t3Target: NTBS.T3Target, + ) { + /* + 1. Check whether an Exchange exists for this source URI. + 2. If there is already - we can return. We treat duplicate deliveries of requests with the same sourceUri as duplicates. No ops. + The read happens before the lock: otherwise a redelivery would park behind whatever background pass holds the lock for an exchange that is already recorded. + 3. If there isn't, take the lock and check again: a concurrent delivery may have recorded it meanwhile, and only the first one may win. + 4. Record the request as accepted and wake the background processor. + From the record on, a failure is the exchange's to keep, not the caller's: it is left for `run` to retry. + */ + + const existing = yield* repo + .findBySourceUri(request.sourceUri) + .pipe(orFail("Failed to find the exchange for the platform request")); + + if (existing !== null) { + return; + } + + return yield* withExchangeLock( + request.sourceUri, + Effect.gen(function* () { + const recorded = yield* repo + .findBySourceUri(request.sourceUri) + .pipe(orFail("Failed to find the exchange for the platform request")); + + if (recorded !== null) { + return; + } + + const now = yield* Clock.currentTimeMillis; + const accepted = yield* persist(NTBS.makeRequestAccepted(request, t3Target, now)); + yield* Queue.offer(recordedRequests, accepted.sourceUri); + }), + ); + }); + + const processThreadActivity = Effect.fn("NTBSProcessor.processThreadActivity")(function* ( + threadId: ThreadId, + ) { + const exchange = yield* repo + .findByThreadId(threadId) + .pipe(orFail("Failed to find the exchange for the active T3 thread")); + + if (exchange !== null) { + yield* resumeExchange(exchange.sourceUri); + } + }); + + const resumeNonTerminalExchanges = repo.findNonTerminalExchanges.pipe( + orFail("Failed to load non-terminal exchanges"), + Effect.flatMap((exchanges) => + Effect.forEach( + exchanges, + (exchange) => + tryResumeExchange(exchange.sourceUri).pipe( + Effect.catch((cause) => + Effect.logWarning("Failed to resume the NTBS exchange", { + sourceUri: exchange.sourceUri, + cause, + }), + ), + ), + { discard: true }, + ), + ), + Effect.catch((cause) => + Effect.logWarning("Failed to load NTBS exchanges for recovery", { cause }), + ), + ); + + /* + The sweeper: the same pass as startup recovery, repeated on an interval for the whole life of `run`. + Activity and recorded requests are fire-and-forget wakes; the sweeper checks exchanges even when none of them arrives. + Redundant sweeps are safe and cheap because the cycle observes before acting: an exchange whose context has not moved answers "wait" and stops. + The interval is a judgment call, low enough that a stranded exchange recovers within a tolerable wait for whoever asked, high enough that the periodic query stays negligible. + Delay first: `run` has just swept via startup recovery, so an immediate first pass would be pure noise. + */ + const sweepNonTerminalExchanges = resumeNonTerminalExchanges.pipe( + Effect.delay(SWEEP_INTERVAL), + Effect.forever, + ); + + const run = Effect.scoped( + Effect.gen(function* () { + /* + Thread activity is collapsed before the workers, so pending work grows with the number of threads that need a check, not with the number of events they emit. + + A thread is either waiting in the queue, being processed, or being processed with another check requested. An event for a waiting thread changes nothing: the pass that is about to start reads the state the event wrote. An event for a thread being processed asks for one more pass. + + A worker that must check its thread again puts it back at the end of the queue, so a busy thread cannot hold a worker while others wait. + + The queue and the tracking map live inside `run`: when a run is interrupted mid-pass, nothing survives that would mark a thread as still being processed and swallow its next events. + */ + const activityQueue = yield* Queue.unbounded(); + const pendingThreads = yield* Ref.make( + HashMap.empty(), + ); + + const enqueueThreadActivity = (threadId: ThreadId): Effect.Effect => + Effect.gen(function* () { + const action = yield* Ref.modify(pendingThreads, (threads) => { + const state = HashMap.get(threads, threadId); + + if (Option.isNone(state)) { + return ["enqueue", HashMap.set(threads, threadId, "waiting")] as const; + } + + if (state.value === "running") { + return ["skip", HashMap.set(threads, threadId, "checkAgain")] as const; + } + + return ["skip", threads] as const; + }); + + if (action === "enqueue") { + yield* Queue.offer(activityQueue, { type: "thread", threadId }); + } + }); + + /* + A failed pass is logged and dropped: the next event or the sweeper runs the exchange again. Defects get the same treatment, so one cannot kill a worker; only interruption ends a worker. + */ + const logPassFailure = + (message: string, context: Record) => + (pass: Effect.Effect) => + pass.pipe( + Effect.catchCause((cause) => + Cause.hasInterrupts(cause) + ? Effect.failCause(cause) + : Effect.logWarning(message, { ...context, cause }), + ), + ); + + const activityWorker = Effect.gen(function* () { + while (true) { + const ping = yield* Queue.take(activityQueue); + + if (ping.type === "recorded-request") { + /* + A request `process` just recorded. One wake per request, so there is nothing to collapse; a pass that is already running reloaded the record after taking the exchange lock, so skipping it loses nothing. + */ + yield* logPassFailure("Failed to process a recorded NTBS request", { + sourceUri: ping.sourceUri, + })(tryResumeExchange(ping.sourceUri)); + continue; + } + + const threadId = ping.threadId; + yield* Ref.update(pendingThreads, (threads) => + HashMap.set(threads, threadId, "running"), + ); + + /* + The thread is queued again only if an event asked for another pass while it ran; otherwise its entry is dropped and the next event or the sweeper runs it again. + */ + yield* logPassFailure("Failed to process NTBS thread activity", { threadId })( + processThreadActivity(threadId), + ); + + const anotherCheck = yield* Ref.modify(pendingThreads, (threads) => { + const requested = + Option.getOrUndefined(HashMap.get(threads, threadId)) === "checkAgain"; + + return requested + ? ([true, HashMap.set(threads, threadId, "waiting")] as const) + : ([false, HashMap.remove(threads, threadId)] as const); + }); + + if (anotherCheck) { + yield* Queue.offer(activityQueue, { type: "thread", threadId }); + } + } + }); + + yield* Stream.runForEach(t3.threadActivity, enqueueThreadActivity).pipe( + Effect.forkScoped({ startImmediately: true }), + ); + + yield* Stream.runForEach(Stream.fromQueue(recordedRequests), (sourceUri) => + Queue.offer(activityQueue, { type: "recorded-request", sourceUri }), + ).pipe(Effect.forkScoped({ startImmediately: true })); + + yield* Effect.forEach( + Array.from({ length: MAX_CONCURRENT_ACTIVITY_HANDLERS }), + () => Effect.forkScoped(activityWorker), + { discard: true }, + ); + + yield* resumeNonTerminalExchanges; + return yield* sweepNonTerminalExchanges; + }), + ); + + return { + process, + run, + }; + }); diff --git a/apps/server/src/ntbs/t3gateway.test.ts b/apps/server/src/ntbs/t3gateway.test.ts new file mode 100644 index 000000000000..3c7c0e4ddb41 --- /dev/null +++ b/apps/server/src/ntbs/t3gateway.test.ts @@ -0,0 +1,2774 @@ +import { describe, it, expect } from "@effect/vitest"; +import { t3GatewayLive, T3Gateway } from "./t3gateway.ts"; +import { DateTime, Deferred, Effect, Fiber, Layer, Option, Ref, FileSystem, Stream } from "effect"; +import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; +import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import { + ProjectionTurnRepository, + type ProjectionTurn, +} from "../persistence/Services/ProjectionTurns.ts"; +import { GitWorkflowService } from "../git/GitWorkflowService.ts"; +import { + ProjectSetupScriptOperationError, + ProjectSetupScriptRunner, +} from "../project/ProjectSetupScriptRunner.ts"; +import { Crypto } from "effect/Crypto"; +import { + CheckpointRef, + EventId, + GitCommandError, + MessageId, + type OrchestrationEvent, + OrchestrationProjectShell, + type OrchestrationSessionStatus, + OrchestrationThread, + OrchestrationThreadShell, + ProjectId, + ProviderInstanceId, + ServerSettingsError, + ThreadId, + TurnId, + VcsCreateWorktreeResult, + VcsListRefsResult, + VcsStatusLocalResult, +} from "@t3tools/contracts"; +import { isTemporaryWorktreeBranch } from "@t3tools/shared/git"; +import { toPersistenceSqlError } from "../persistence/Errors.ts"; +import { OrchestrationCommandInvariantError } from "../orchestration/Errors.ts"; +import { PlatformError, SystemError } from "effect/PlatformError"; +import { + makeRequestAccepted, + toThreadCreated, + toWorkPlanned, + type Request, + type T3Target, + type WorkCoordinates, +} from "./exchange.ts"; +import * as ServerSettings from "../serverSettings.ts"; + +/** + * Every mocked dependency records into one shared, ordered log. + * + * One array rather than one per service: only a single sequence can answer questions that span + * services — that the project is loaded before git runs, or that a rejection stopped the gateway + * before it minted anything. Per-service views are derivable from this; the ordering is not + * recoverable from them. + */ +type Call = { service: string; method: string; input: unknown }; + +const createCallLog = () => { + const calls: Array = []; + + const recordResult = + (service: string) => + (method: string, input: unknown, value: A) => + Effect.sync(() => { + calls.push({ service, method, input }); + return value; + }); + + const record = (service: string) => (method: string, input: unknown) => + Effect.sync(() => calls.push({ service, method, input })); + + // Widened so the mock wrappers stay the only writers: tests can read the log, not push into it. + return { calls: calls as ReadonlyArray, recordResult, record }; +}; + +type CallRecordResult = ReturnType["recordResult"]; + +type CallRecord = ReturnType["record"]; + +type CryptoInput = { + failRandomUUIDv4?: boolean; +}; + +const createCryptoMock = (recordResult: CallRecordResult, input?: CryptoInput) => { + const recordCrypto = recordResult("Crypto"); + + return Layer.unwrap( + Effect.gen(function* () { + const counter: Ref.Ref = yield* Ref.make(0); + + return Layer.mock(Crypto, { + "~effect/platform/Crypto": "~effect/platform/Crypto", + randomUUIDv4: + // recordCrypto("randomUUIDv4", undefined, ) + + input?.failRandomUUIDv4 + ? recordCrypto("randomUUIDv4", undefined, "noreach").pipe( + Effect.andThen( + new PlatformError( + new SystemError({ + _tag: "Unknown", + method: "randomUUIDv4", + module: "crypto something", + }), + ), + ), + ) + : Ref.getAndUpdate(counter, (num) => num + 1).pipe( + Effect.flatMap((num) => + recordCrypto("randomUUIDv4", undefined, "randomUUID" + num), + ), + ), + nextDoubleUnsafe: () => 0, + nextIntUnsafe: () => 0, + }); + }), + ); +}; + +const createGitCommandError = (exitCode?: number, detail = "") => + GitCommandError.make({ + command: "resolve", + cwd: "", + detail, + failureKind: "unknown", + operation: "", + exitCode, + }); + +type OrchestrationEngineInput = { + /** `"invariant"` fails with the decider's rejection; `true` with an operational persistence error. */ + dispatchFails?: boolean | "invariant"; + deleteFails?: boolean; + /** Signals, then hangs `dispatch` so a caller can interrupt a provision mid-flight. */ + dispatchStalls?: Deferred.Deferred; + /** Emitted through `streamDomainEvents` as a finite stream, unlike the live infinite PubSub one. */ + domainEvents?: ReadonlyArray; +}; + +// TODO: We need to make sure and analyze what happens when it is dispatched +// Old processor treated it as a synchronous event, but that might be a lie +const createOrchestrationEngineServiceMock = ( + recordResult: CallRecordResult, + callRecord: CallRecord, + input?: OrchestrationEngineInput, +) => { + const _record = recordResult("OrchestrationEngineService"); + + const call = callRecord("OrchestrationEngineService"); + + return Layer.mock(OrchestrationEngineService, { + dispatch: (_command) => + call("dispatch", _command).pipe( + Effect.andThen(() => + input?.dispatchStalls + ? Deferred.succeed(input.dispatchStalls, undefined).pipe(Effect.andThen(Effect.never)) + : input?.dispatchFails || (_command.type === "thread.delete" && input?.deleteFails) + ? Effect.fail( + input?.dispatchFails === "invariant" + ? new OrchestrationCommandInvariantError({ + commandType: _command.type, + detail: "rejected by the decider", + }) + : toPersistenceSqlError("some operation")("some cause"), + ) + : Effect.succeed({ sequence: 0 }), + ), + ), + streamDomainEvents: Stream.fromIterable(input?.domainEvents ?? []), + }); +}; + +type PSQMInput = { + getProjectShellById?: + | { + success: Partial; + } + | { failure: unknown } + | { missing: true }; + isThreadMissing?: boolean; + isGetThreadShellByIdError?: boolean; + isThreadDetailMissing?: boolean; + isGetThreadDetailByIdError?: boolean; + /** Rendered as messages on the thread detail; assistant unless a role is given. */ + threadMessages?: ReadonlyArray<{ id: MessageId; text: string; role?: "user" | "assistant" }>; + sessionStatus?: OrchestrationSessionStatus; + sessionLastError?: string; +}; + +const createPSQM = (record: CallRecordResult, input?: PSQMInput) => { + const recordPSQM = record("ProjectionSnapshotQuery"); + + const isProjectMissing = input?.getProjectShellById && "missing" in input.getProjectShellById; + + const isGetProjectError = input?.getProjectShellById && "failure" in input.getProjectShellById; + + return Layer.mock(ProjectionSnapshotQuery, { + getProjectShellById: (projectId) => + recordPSQM("getProjectShellById", projectId, null).pipe( + Effect.andThen( + isGetProjectError + ? toPersistenceSqlError("some sql error")("somecause") + : Effect.option( + isProjectMissing + ? Effect.fail("missing") + : Effect.succeed({ + id: projectId, + workspaceRoot: "root", + title: "project-title", + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + updatedAt: DateTime.formatIso(DateTime.nowUnsafe()), + defaultModelSelection: null, + scripts: [], + ...(input?.getProjectShellById && + "success" in input.getProjectShellById && { + ...input.getProjectShellById.success, + }), + }), + ), + ), + ), + getThreadShellById: (threadId) => + recordPSQM( + "getThreadShellById", + threadId, + input?.isThreadMissing + ? Option.none() + : Option.some({ + archivedAt: null, + branch: "some-branch", + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + hasActionableProposedPlan: false, + hasPendingApprovals: false, + hasPendingUserInput: false, + id: threadId, + interactionMode: "default", + latestTurn: null, + latestUserMessageAt: null, + modelSelection: { + instanceId: ProviderInstanceId.make("instanceId"), + model: "custom", + options: [], + }, + pullRequests: [], + projectId: ProjectId.make("projectId"), + runtimeMode: "auto", + session: { + threadId, + activeTurnId: null, + lastError: null, + providerName: null, + runtimeMode: "auto", + status: "ready", + updatedAt: DateTime.formatIso(DateTime.nowUnsafe()), + providerInstanceId: ProviderInstanceId.make("providerInstanceId"), + }, + settledAt: null, + settledOverride: "active", + title: "some title", + updatedAt: DateTime.formatIso(DateTime.nowUnsafe()), + worktreePath: null, + }), + ).pipe( + Effect.filterOrFail( + () => !input || input.isGetThreadShellByIdError !== true, + () => toPersistenceSqlError("some sql error")("somecause"), + ), + ), + getThreadDetailById: (threadId) => + recordPSQM( + "getThreadDetailById", + threadId, + input?.isThreadDetailMissing + ? Option.none() + : Option.some({ + id: threadId, + projectId: ProjectId.make("projectId"), + title: "some title", + modelSelection: { + instanceId: ProviderInstanceId.make("instanceId"), + model: "custom", + options: [], + }, + pullRequests: [], + runtimeMode: "auto", + interactionMode: "default", + branch: "some-branch", + worktreePath: null, + latestTurn: null, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + updatedAt: DateTime.formatIso(DateTime.nowUnsafe()), + archivedAt: null, + settledOverride: null, + settledAt: null, + deletedAt: null, + messages: (input?.threadMessages ?? []).map((message) => ({ + id: message.id, + role: message.role ?? ("assistant" as const), + text: message.text, + turnId: null, + streaming: false, + createdAt: DateTime.formatIso(DateTime.nowUnsafe()), + updatedAt: DateTime.formatIso(DateTime.nowUnsafe()), + })), + queuedMessages: [], + pendingTurnStart: null, + proposedPlans: [], + activities: [], + checkpoints: [], + session: { + threadId, + status: input?.sessionStatus ?? "ready", + providerName: null, + activeTurnId: null, + lastError: input?.sessionLastError ?? null, + runtimeMode: "auto", + updatedAt: DateTime.formatIso(DateTime.nowUnsafe()), + providerInstanceId: ProviderInstanceId.make("providerInstanceId"), + }, + }), + ).pipe( + Effect.filterOrFail( + () => !input || input.isGetThreadDetailByIdError !== true, + () => toPersistenceSqlError("some sql error")("somecause"), + ), + ), + }); +}; + +type ProjectionTurnRepositoryInput = { + turns?: ReadonlyArray; + listByThreadIdFails?: boolean; +}; + +const createProjectionTurnRepositoryMock = ( + recordResult: CallRecordResult, + input?: ProjectionTurnRepositoryInput, +) => { + const record = recordResult("ProjectionTurnRepository"); + + return Layer.mock(ProjectionTurnRepository, { + listByThreadId: (callInput) => + record("listByThreadId", callInput, input?.turns ?? []).pipe( + Effect.filterOrFail( + () => !input || input.listByThreadIdFails !== true, + () => toPersistenceSqlError("some sql error")("somecause"), + ), + ), + }); +}; + +type GitLayerInput = { + createdWorktreePath?: string; + createWorkreeFails?: boolean | { detail: string }; + failBranchResolution?: "non-zero-exit" | "no-exit-code"; + fetchRemoteFails?: boolean; + listRefsFails?: boolean; + localStatus?: { isRepo?: boolean; refName?: string }; + localStatusFails?: boolean; + remoteExists?: boolean; + remoteExistsFails?: boolean; + resolvedRemoteSha?: string; + removeWorkTreeFails?: boolean; + worktreeBranchExists?: boolean; + worktreeBranchPath?: string; +}; + +// TODO: Can't we simplify it by leveraging default values in params? +// we can pass default arguments in JS +const createGitWorkflowServiceMock = ( + recordResult: CallRecordResult, + callRecord: CallRecord, + input?: GitLayerInput, +) => { + const recordGit = recordResult("GitWorkflowService"); + + const record = callRecord("GitWorkflowService"); + + return Layer.mock(GitWorkflowService, { + createWorktree: (callInput) => + record("createWorktree", callInput).pipe( + Effect.andThen(() => + input?.createWorkreeFails + ? Effect.fail( + createGitCommandError( + undefined, + typeof input.createWorkreeFails === "object" + ? input.createWorkreeFails.detail + : "", + ), + ) + : Effect.succeed( + VcsCreateWorktreeResult.make({ + worktree: { + path: callInput.path ?? input?.createdWorktreePath ?? "path", + refName: callInput.newRefName ?? callInput.refName, + }, + }), + ), + ), + ), + remoteExists: (callInput) => + recordGit("remoteExists", callInput, !input || input.remoteExists !== false).pipe( + Effect.filterOrFail( + () => !input || !input.remoteExistsFails, + () => createGitCommandError(), + ), + ), + fetchRemote: (callInput) => + recordGit("fetchRemote", callInput, undefined).pipe( + Effect.filterOrFail( + () => !input || input.fetchRemoteFails !== true, + () => createGitCommandError(), + ), + ), + localStatus: (callInput) => + recordGit( + "localStatus", + callInput, + VcsStatusLocalResult.make({ + isRepo: input?.localStatus?.isRepo ?? false, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: input?.localStatus?.refName ?? null, + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + }), + ).pipe( + Effect.filterOrFail( + () => !input?.localStatusFails, + () => createGitCommandError(), + ), + ), + listRefs: (callInput) => + recordGit( + "listRefs", + callInput, + VcsListRefsResult.make({ + refs: input?.worktreeBranchExists + ? [ + { + name: callInput.query ?? "worktreeBranchName", + current: false, + isDefault: false, + worktreePath: input.worktreeBranchPath ?? null, + }, + ] + : [], + isRepo: true, + hasPrimaryRemote: true, + nextCursor: null, + totalCount: input?.worktreeBranchExists ? 1 : 0, + }), + ).pipe( + Effect.filterOrFail( + () => !input?.listRefsFails, + () => createGitCommandError(), + ), + ), + removeWorktree: (callInput) => + record("removeWorktree", callInput).pipe( + Effect.andThen(() => + input?.removeWorkTreeFails ? Effect.fail(createGitCommandError()) : Effect.void, + ), + ), + pruneWorktrees: (callInput) => record("pruneWorktrees", callInput), + + resolveRemoteTrackingCommit: (callInput) => + recordGit("resolveRemoteTrackingCommit", callInput, { + commitSha: input?.resolvedRemoteSha ?? "sha123", + remoteRefName: "remoteRefName", + }).pipe( + Effect.flatMap((val) => + input?.failBranchResolution + ? createGitCommandError(input.failBranchResolution === "non-zero-exit" ? 1 : undefined) + : Effect.succeed(val), + ), + ), + }); +}; + +type ProjectSetupScriptRunnerInput = { + runForThreadFails?: boolean; +}; + +const ProjectSetupScriptRunnerMock = ( + _recordResult: CallRecordResult, + callRecord: CallRecord, + input?: ProjectSetupScriptRunnerInput, +) => { + // const record = recordResult("ProjestSetupScriptRunnerMock"); + const call = callRecord("ProjectSetupScriptRunnerMock"); + + return Layer.mock(ProjectSetupScriptRunner, { + runForThread: (callInput) => + call("runForThread", callInput).pipe( + Effect.andThen(() => + input?.runForThreadFails + ? Effect.fail( + ProjectSetupScriptOperationError.make({ + _tag: "ProjectSetupScriptOperationError", + cause: "somecause", + operation: "openTerminal", + threadId: callInput.threadId, + worktreePath: callInput.worktreePath, + }), + ) + : Effect.succeed({ status: "no-script" }), + ), + ), + }); +}; + +type FileSystemInput = { + worktreePathExists?: boolean; + existsFails?: boolean; + removeFails?: boolean; +}; + +const createFileSystemMock = (recordResult: CallRecordResult, input?: FileSystemInput) => { + const recordFs = recordResult("FileSystem"); + + const fail = (method: string) => + new PlatformError(new SystemError({ _tag: "Unknown", method, module: "FileSystem" })); + + return FileSystem.layerNoop({ + exists: (path) => + recordFs("exists", path, input?.worktreePathExists === true).pipe( + Effect.filterOrFail( + () => !input || input.existsFails !== true, + () => fail("exists"), + ), + ), + remove: (path, options) => + recordFs("remove", { path, options }, undefined).pipe( + Effect.filterOrFail( + () => !input || input.removeFails !== true, + () => fail("remove"), + ), + ), + }); +}; + +/** + * Builds a gateway plus the log of everything its dependencies were asked to do. + * + * Called per test rather than per block: each failure mode needs its own mock configuration, so + * there is nothing worth sharing, and a log created per test beats resetting a shared one. + */ +const createT3Gateway = (input?: { + pqsm?: PSQMInput; + gwfs?: GitLayerInput; + crypto?: CryptoInput; + orchestrationEngine?: OrchestrationEngineInput; + projectSetupScriptRunner?: ProjectSetupScriptRunnerInput; + fileSystem?: FileSystemInput; + turnRepository?: ProjectionTurnRepositoryInput; + serverSettings?: Layer.Layer; +}) => { + const { calls, recordResult, record } = createCallLog(); + + return { + calls, + layer: t3GatewayLive.pipe( + Layer.provide( + Layer.mergeAll( + createOrchestrationEngineServiceMock(recordResult, record, input?.orchestrationEngine), + createPSQM(recordResult, input?.pqsm), + ProjectSetupScriptRunnerMock(recordResult, record, input?.projectSetupScriptRunner), + createGitWorkflowServiceMock(recordResult, record, input?.gwfs), + createProjectionTurnRepositoryMock(recordResult, input?.turnRepository), + createCryptoMock(recordResult, input?.crypto), + input?.serverSettings ?? + ServerSettings.layerTest({ + defaultModelSelection: { + instanceId: ProviderInstanceId.make("claude-code"), + model: "claude-sonnet-4-6", + }, + }), + createFileSystemMock(recordResult, input?.fileSystem), + ), + ), + ), + }; +}; + +const now = 1_700_000_000_000; + +describe("T3Gateway", () => { + describe("planCoordinates", () => { + /* + Recap. This will, in order: + - fetch the project details for projectId + - if it cannot load the project due to errors, it will fail with a recoverable error + - it if can: + - if the project exists: it will return it + - if it does not: it will fail with a T3Rejected error, one that cannot be retried + - it checks if the git remote exists + - if it cannot load: retryable fail + - if it can but it does not exist: T3Rejected, it cannot be retried + - it tries to fetch it + - this cannot be rejected, it can only return a retryable error. + It would make no sense to error, as remote exists step before confirmed it exists. + - last step: try to get the commit sha for the remote branch with that name + + Now that we have the git and project references: + - generate a threadId + - generate a userMessageId + - generate a branch name for the temporary git worktree + - return the coordinates + + */ + describe("successful planning", () => { + it.effect("pins the selected branch to the commit fetched from origin", () => { + /* + Declared once and threaded through the project mock, so the assertions below prove the cwd git receives is the workspace the project lookup returned, rather than two literals that happen to agree. + */ + const workspaceRoot = "/workspaces/project-under-test"; + const projectId = ProjectId.make("test-1"); + + const { calls, layer } = createT3Gateway({ + pqsm: { getProjectShellById: { success: { workspaceRoot } } }, + gwfs: { remoteExists: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const coordinates = yield* t3Gateway.planCoordinates(projectId, "main"); + + expect(coordinates).toEqual({ + projectId, + startBranchName: "main", + startCommitSha: "sha123", + threadId: "randomUUID0", + userMessageId: "randomUUID1", + worktreeBranchName: "ntbs/randomUUID0", + }); + + /* + The crypto mock hands out a deterministic sequence, so the ids are pinned exactly rather than matched loosely: the thread is minted before its first message, and the branch carries the thread's id, not the message's. + `expect.any(String)` would let a swapped or reused identifier through. + */ + expect(isTemporaryWorktreeBranch(coordinates.worktreeBranchName)).toBe(false); + + /* + Order matters as much as the arguments. The tip is only current because the fetch + precedes it — reading first would resolve whatever origin pointed at the last time + anything fetched in this workspace. And git must run in the workspace the project + lookup returned: the wrong one still resolves a real sha, from the wrong repository. + */ + expect(calls).toEqual([ + { + service: "ProjectionSnapshotQuery", + method: "getProjectShellById", + input: projectId, + }, + { + service: "GitWorkflowService", + method: "remoteExists", + input: { cwd: workspaceRoot, remoteName: "origin" }, + }, + { + service: "GitWorkflowService", + method: "fetchRemote", + input: { cwd: workspaceRoot, remoteName: "origin" }, + }, + { + service: "GitWorkflowService", + method: "resolveRemoteTrackingCommit", + input: { cwd: workspaceRoot, refName: "main", fallbackRemoteName: "origin" }, + }, + { service: "Crypto", method: "randomUUIDv4", input: undefined }, + { service: "Crypto", method: "randomUUIDv4", input: undefined }, + ]); + }).pipe(Effect.provide(layer)); + }); + }); + + describe("fatal errors", () => { + it.effect( + "rejects a project that does not exist without performing provisioning work", + () => { + const projectId = ProjectId.make("non-existing-project"); + + const { calls, layer } = createT3Gateway({ + pqsm: { getProjectShellById: { missing: true } }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const error = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(error._tag).toBe("FatalError"); + + expect(error.method).toBe("projectionSnapshotQuery.getProjectShellById"); + + // Nothing after the lookup: no git, and no identifiers minted for work that cannot run. + expect(calls).toEqual([ + { + service: "ProjectionSnapshotQuery", + method: "getProjectShellById", + input: projectId, + }, + ]); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect("rejects a project whose repository has no origin remote", () => { + const { layer } = createT3Gateway({ + gwfs: { remoteExists: false }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("gitWorkflowService.remoteExists"); + }).pipe(Effect.provide(layer)); + }); + }); + + describe("operational failures", () => { + it.effect("fails retryably when the project lookup fails", () => { + const { layer, calls } = createT3Gateway({ + pqsm: { + getProjectShellById: { failure: "no project resolving" }, + }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + + expect(result.method).toBe("projectionSnapshotQuery.getProjectShellById"); + + const methods = calls.map((call) => call.method); + + expect(methods).toEqual(["getProjectShellById"]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when checking for the origin remote existance fails", () => { + const { layer, calls } = createT3Gateway({ + gwfs: { + remoteExistsFails: true, + }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + + expect(result.method).toBe("gitWorkflowService.remoteExists"); + + const methods = calls.map((call) => call.method); + + expect(methods).toEqual(["getProjectShellById", "remoteExists"]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when fetching origin fails", () => { + const { layer, calls } = createT3Gateway({ + gwfs: { + fetchRemoteFails: true, + }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + + expect(result.method).toBe("gitWorkflowService.fetchRemote"); + + const methods = calls.map((call) => call.method); + + expect(methods).toEqual(["getProjectShellById", "remoteExists", "fetchRemote"]); + }).pipe(Effect.provide(layer)); + }); + + /* + A non-zero exit could mean the branch is missing, but also a repository read failure; the error does not distinguish them, so the request is retried until its deadline instead of rejected on a guess. Nothing is minted for work that may still run. + */ + it.effect("fails retryably when resolving the branch tip exits non-zero", () => { + const { layer, calls } = createT3Gateway({ + gwfs: { + failBranchResolution: "non-zero-exit", + }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("gitWorkflowService.resolveRemoteTrackingCommit"); + expect(result.reason).toContain("Could not resolve branch"); + + const methods = calls.map((call) => call.method); + + expect(methods).toEqual([ + "getProjectShellById", + "remoteExists", + "fetchRemote", + "resolveRemoteTrackingCommit", + ]); + }).pipe(Effect.provide(layer)); + }); + + /* + A git failure carrying no exit code means git never ran to completion (timeout, spawn failure). + */ + it.effect("fails retryably when reading the branch tip fails without a git exit code", () => { + const { layer, calls } = createT3Gateway({ + gwfs: { + failBranchResolution: "no-exit-code", + }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + + expect(result.method).toBe("gitWorkflowService.resolveRemoteTrackingCommit"); + + const methods = calls.map((call) => call.method); + + expect(methods).toEqual([ + "getProjectShellById", + "remoteExists", + "fetchRemote", + "resolveRemoteTrackingCommit", + ]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when the exchange IDs cannot be minted", () => { + const { layer, calls } = createT3Gateway({ + crypto: { + failRandomUUIDv4: true, + }, + }); + + const projectId = ProjectId.make("projectId"); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.planCoordinates(projectId, "main").pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + + expect(result.method).toBe("crypto.randomUUIDv4"); + + const methods = calls.map((call) => call.method); + + expect(methods).toEqual([ + "getProjectShellById", + "remoteExists", + "fetchRemote", + "resolveRemoteTrackingCommit", + "randomUUIDv4", + ]); + }).pipe(Effect.provide(layer)); + }); + }); + }); + + describe("getThreadStatus", () => { + /** + * What does getThreadStatus does? + * + * It reports whether the T3 thread for the exchange exists ("present") or not ("missing"). + * + * It runs only once in the processor, for Exchanges that are in the + * `RequestClaimed` status, in the `processRequesClaimed` effect. + * + * It returns the `RequestClaimedContext` needed by the decider function `fromRequestClaimed` to calculate the following policy `RequestClaimedDecision`. + * + * The thread can either be "missing" or "present". + * + * It can only fail with a RetryableError. + */ + /* + Built from fixed coordinates on purpose: the subject is the lookup, so minting identifiers through `planCoordinates` would only add an unrelated pipeline to the test's setup and its call log. + */ + const coordinates: WorkCoordinates = { + projectId: ProjectId.make("projectId"), + startBranchName: "startBranchName", + startCommitSha: "startCommitSha", + threadId: ThreadId.make("threadId"), + userMessageId: MessageId.make("userMessageId"), + worktreeBranchName: "worktreeBranchName", + }; + + const workPlanned = toWorkPlanned( + makeRequestAccepted( + { + attachments: [], + snapshot: "getThreadStatus snapshot", + sourceUri: "test://get-thread-status", + }, + { projectId: coordinates.projectId, startBranchName: coordinates.startBranchName }, + now, + ), + coordinates, + now, + ); + + describe("happy cases", () => { + it.effect("it returns that the missing thread", () => { + const { calls, layer } = createT3Gateway({ + pqsm: { + isThreadMissing: true, + }, + }); + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getThreadStatus(workPlanned); + + expect(result.thread).toBe("missing"); + // The lookup is for the thread the exchange recorded, not a freshly minted id. + expect(calls.find((call) => call.method === "getThreadShellById")?.input).toBe( + workPlanned.t3.threadId, + ); + }).pipe(Effect.provide(layer)); + }); + + it.effect("it returns that the thread is present", () => { + const { calls, layer } = createT3Gateway({ + pqsm: { + isThreadMissing: false, + }, + }); + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getThreadStatus(workPlanned); + + expect(result.thread).toBe("present"); + expect(calls.find((call) => call.method === "getThreadShellById")?.input).toBe( + workPlanned.t3.threadId, + ); + }).pipe(Effect.provide(layer)); + }); + }); + + describe("operational failures", () => { + // Note: we're really not caring _why_. + // Albeit, as of writing there's only retryable errors? + it.effect("cannot get the thread", () => { + const { calls, layer } = createT3Gateway({ + pqsm: { + isGetThreadShellByIdError: true, + }, + }); + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getThreadStatus(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(calls.find((call) => call.method === "getThreadShellById")?.input).toBe( + workPlanned.t3.threadId, + ); + }).pipe(Effect.provide(layer)); + }); + }); + }); + + describe("provisionThread", () => { + /* + Info: used only once in `processor.ts` in `processRequestClaimed` so when the current status of an exchange is `RequesClaimed`. + + When the exchange is in that status, `getThreadStatus`, tested above, provides the actual context of thread. + + We know that the NTBS system has now received the external request, and saved it along the coordinates minted via `planCoordinates`. + + What we *don't* know is whether the actual T3 thread has been started or not. + + Why is that? + + After thread creation, threads are provisioned, what can happen is that T3 starts the thread but it is not recorded in the NTBS exchange (e.g. thread starts -> app crashes -> thread start doesn't get recorded). + + So we must double check starting from a RequestClaimed Exchange that the thread did not indeed start before. + + What does `provisionThread` even do anyway? + + It handles worktree and thread creation as well as executing setup scripts. + + (N.B. In theory we should skip setup scripts if it was already done as well). + + ## How did it work in the old processor? + + 1. create worktree + 2. "thread.create" in orchestrationEngineService.dispatch command + 2.a if anything goes wrong during thread.create -> removes the worktree + 3. run the scripts via projectScriptRunner.runForThread + + Return value: provisionThread returns nothing. TODO: Is there anything important that gets retrieved there (some information)? + + Quite sure the current implementation can be updated and made better than the current void into null and rejection !== null in `processor.ts` as of 6d70ff461df16d1a052ce3656131613647940028. + + What does `provisionThread` depends on? + 1. GitWorkflowService for worktree discovery, creation, and deletion + 2. OrchestrationEngineService for dispatching the command to create the thread + 3. ProjectScriptRunner for executing the scripts in the thread/cwd + */ + const request: Request = { + attachments: [], + snapshot: "come on, do something", + sourceUri: "test://source-uri", + }; + + const coordinates: WorkCoordinates = { + projectId: ProjectId.make("projectId"), + startBranchName: "startBranchName", + startCommitSha: "startCommitSha", + threadId: ThreadId.make("threadId"), + userMessageId: MessageId.make("userMessageId"), + worktreeBranchName: "worktreeBranchName", + }; + + const target: T3Target = { + projectId: coordinates.projectId, + startBranchName: coordinates.startBranchName, + }; + + const workPlanned = toWorkPlanned(makeRequestAccepted(request, target, now), coordinates, now); + + describe("model selection", () => { + const projectSelection = { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + options: [{ id: "reasoningEffort", value: "high" }], + }; + const serverSelection = { + instanceId: ProviderInstanceId.make("claude-code"), + model: "claude-sonnet-4-6", + }; + + it.effect.each([ + { + name: "project overrides server", + projectModel: projectSelection, + serverModel: serverSelection, + expected: projectSelection, + }, + { + name: "uses project default when server default is unset", + projectModel: projectSelection, + serverModel: null, + expected: projectSelection, + }, + { + name: "inherits server default", + projectModel: null, + serverModel: serverSelection, + expected: serverSelection, + }, + ])("$name", ({ projectModel, serverModel, expected }) => { + const { calls, layer } = createT3Gateway({ + pqsm: { getProjectShellById: { success: { defaultModelSelection: projectModel } } }, + serverSettings: ServerSettings.layerTest({ defaultModelSelection: serverModel }), + }); + + return Effect.gen(function* () { + const gateway = yield* T3Gateway; + yield* gateway.provisionThread(workPlanned); + + expect(calls.find((call) => call.method === "dispatch")?.input).toMatchObject({ + type: "thread.create", + modelSelection: expected, + }); + }).pipe(Effect.provide(layer)); + }); + + it.effect("rejects missing defaults before creating a worktree or thread", () => { + const { calls, layer } = createT3Gateway({ + serverSettings: ServerSettings.layerTest({ defaultModelSelection: null }), + }); + + return Effect.gen(function* () { + const gateway = yield* T3Gateway; + const error = yield* gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(error).toMatchObject({ + _tag: "FatalError", + method: "provisionThread", + reason: + "No default model is configured for this project or server. Set a model in project or machine settings and submit the request again.", + }); + expect(calls.map((call) => call.method)).toEqual(["getProjectShellById"]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("retries a settings read failure before creating a worktree or thread", () => { + const cause = new ServerSettingsError({ + settingsPath: "settingsPath", + operation: "read-file", + cause: "Settings unavailable", + }); + const { calls, layer } = createT3Gateway({ + serverSettings: Layer.mock(ServerSettings.ServerSettingsService, { + getSettings: Effect.fail(cause), + }), + }); + + return Effect.gen(function* () { + const gateway = yield* T3Gateway; + const error = yield* gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(error).toMatchObject({ + _tag: "RetryableError", + method: "serverSettings.getSettings", + cause, + }); + expect(calls.map((call) => call.method)).toEqual(["getProjectShellById"]); + }).pipe(Effect.provide(layer)); + }); + }); + + describe("happy case", () => { + /* + Pristine first attempt: `createWorktree` takes the fresh-create arm, dispatch succeeds so the stale-observation recovery never fires, scripts run last. + */ + it.effect("provisions worktree, thread, and scripts in order from a clean slate", () => { + const createdWorktreePath = "/git-selected/worktree"; + const { calls, layer } = createT3Gateway({ + gwfs: { createdWorktreePath }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + "randomUUIDv4", + "dispatch", + "runForThread", + ]); + + // Fresh-create arm, off the commit pinned at claim. + const createInput = calls.find((call) => call.method === "createWorktree")?.input; + expect(createInput).toMatchObject({ + path: null, + refName: coordinates.startCommitSha, + newRefName: coordinates.worktreeBranchName, + baseRefName: coordinates.startBranchName, + }); + // Fork-only option; the adapter must stay portable to upstream. + expect(createInput).not.toHaveProperty("deferDependencyInstall"); + expect(calls.find((call) => call.method === "dispatch")?.input).toMatchObject({ + type: "thread.create", + worktreePath: createdWorktreePath, + }); + expect(calls.find((call) => call.method === "runForThread")?.input).toMatchObject({ + worktreePath: createdWorktreePath, + }); + }).pipe(Effect.provide(layer)); + }); + + /* + A failed dispatch is not trusted at face value: the "thread is missing" observation that led us here can be stale (crash after a committed create, projection lag), so the gateway re-checks and adopts the existing thread. + Note the scripts still run — skipping them when provisioning already completed is an open TODO. + */ + it.effect("succeeds when dispatch fails because the thread already exists", () => { + const { calls, layer } = createT3Gateway({ + orchestrationEngine: { dispatchFails: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + "randomUUIDv4", + "dispatch", + "getThreadShellById", + "runForThread", + ]); + }).pipe(Effect.provide(layer)); + }); + + /* + Resume: the path already holds a checkout of the minted branch, so git is asked, agrees, and no worktree work happens at all. + */ + it.effect("reuses an intact worktree left by an interrupted attempt", () => { + const { calls, layer } = createT3Gateway({ + fileSystem: { worktreePathExists: true }, + gwfs: { + worktreeBranchExists: true, + worktreeBranchPath: "/existing/worktree", + localStatus: { isRepo: true, refName: coordinates.worktreeBranchName }, + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + "localStatus", + "randomUUIDv4", + "dispatch", + "runForThread", + ]); + }).pipe(Effect.provide(layer)); + }); + + /* + Resume: Git reports the branch at a path that no longer contains its checkout, so the path is cleared and the surviving branch is checked out again. + */ + it.effect("replaces debris at a registered worktree path", () => { + const { calls, layer } = createT3Gateway({ + fileSystem: { worktreePathExists: true }, + gwfs: { + worktreeBranchExists: true, + worktreeBranchPath: "/existing/worktree", + localStatus: { isRepo: false }, + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + "localStatus", + "removeWorktree", + "createWorktree", + "randomUUIDv4", + "dispatch", + "runForThread", + ]); + + const createInput = calls.find((call) => call.method === "createWorktree")?.input; + expect(createInput).toMatchObject({ + path: null, + refName: coordinates.worktreeBranchName, + }); + expect(createInput).not.toHaveProperty("newRefName"); + }).pipe(Effect.provide(layer)); + }); + + it.effect("replaces a registered worktree checked out on another branch", () => { + const { calls, layer } = createT3Gateway({ + fileSystem: { worktreePathExists: true }, + gwfs: { + worktreeBranchExists: true, + worktreeBranchPath: "/existing/worktree", + localStatus: { isRepo: true, refName: "some-other-branch" }, + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + // Being a repo is not enough: the ref has to be the minted branch, so this checkout is cleared and recreated like any other debris. + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + "localStatus", + "removeWorktree", + "createWorktree", + "randomUUIDv4", + "dispatch", + "runForThread", + ]); + + const createInput = calls.find((call) => call.method === "createWorktree")?.input; + expect(createInput).toMatchObject({ + path: null, + refName: coordinates.worktreeBranchName, + }); + expect(createInput).not.toHaveProperty("newRefName"); + }).pipe(Effect.provide(layer)); + }); + + it.effect("prunes a missing registered checkout and recreates it from its branch", () => { + const { calls, layer } = createT3Gateway({ + gwfs: { + worktreeBranchExists: true, + worktreeBranchPath: "/missing/worktree", + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + "pruneWorktrees", + "createWorktree", + "randomUUIDv4", + "dispatch", + "runForThread", + ]); + expect(calls.find((call) => call.method === "createWorktree")?.input).toMatchObject({ + path: null, + refName: coordinates.worktreeBranchName, + }); + }).pipe(Effect.provide(layer)); + }); + + /* + Resume: a crashed attempt created the branch but not the checkout, so the branch is checked out instead of re-branching from the start commit. + */ + it.effect( + "checks out a branch surviving from a crashed attempt instead of re-creating it", + () => { + const { calls, layer } = createT3Gateway({ + gwfs: { worktreeBranchExists: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + "randomUUIDv4", + "dispatch", + "runForThread", + ]); + + // Checkout arm: the surviving branch itself, no new branch minted. + const createInput = calls.find((call) => call.method === "createWorktree")?.input; + expect(createInput).toMatchObject({ refName: coordinates.worktreeBranchName }); + expect(createInput).not.toHaveProperty("newRefName"); + }).pipe(Effect.provide(layer)); + }, + ); + }); + + describe("failures", () => { + /* + The project is refetched here because planning's snapshot may be stale or the project may have been deleted since. A failed lookup is operational, so the pass retries before touching Git or T3. + */ + it.effect("fails retryably when re-fetching the project fails", () => { + const { calls, layer } = createT3Gateway({ + pqsm: { getProjectShellById: { failure: "no project resolving" } }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("projectionSnapshotQuery.getProjectShellById"); + expect(calls.map((call) => call.method)).toEqual(["getProjectShellById"]); + }).pipe(Effect.provide(layer)); + }); + + it.effect( + "fails retryably when dispatch fails operationally and the thread is genuinely missing", + () => { + const { calls, layer } = createT3Gateway({ + orchestrationEngine: { dispatchFails: true }, + pqsm: { isThreadMissing: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("orchestrationEngine.dispatch"); + + /* + A retryable failure cleans up nothing: no removeWorktree, no scripts. + */ + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + "randomUUIDv4", + "dispatch", + "getThreadShellById", + ]); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect( + "fails fatally when T3 rejects creation and the thread is genuinely missing", + () => { + const { calls, layer } = createT3Gateway({ + orchestrationEngine: { dispatchFails: "invariant" }, + pqsm: { isThreadMissing: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("orchestrationEngine.dispatch"); + expect(calls.map((call) => call.method)).toContain("removeWorktree"); + expect(calls.filter((call) => call.method === "dispatch")).toHaveLength(1); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect("keeps a failed recovery lookup retryable", () => { + const { layer } = createT3Gateway({ + orchestrationEngine: { dispatchFails: "invariant" }, + pqsm: { isGetThreadShellByIdError: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("projectionSnapshotQuery.getThreadShellById"); + }).pipe(Effect.provide(layer)); + }); + + /* + The one moment ownership truly ends: a fatal error removes the worktree. + */ + it.effect( + "fails fatally when setup cannot launch, deleting the thread before its worktree", + () => { + const { calls, layer } = createT3Gateway({ + projectSetupScriptRunner: { runForThreadFails: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("projectScriptRunner.runForThread"); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + "randomUUIDv4", + "dispatch", + "runForThread", + "randomUUIDv4", + "dispatch", + "removeWorktree", + ]); + }).pipe(Effect.provide(layer)); + }, + ); + + /* + Reproduces the orphan half of H3: removing the worktree while leaving the thread behind + points T3 at a path that no longer exists. A fatal provisioning failure after the thread was + created must delete that thread too. + */ + it.effect("deletes the thread it created when provisioning fails fatally", () => { + const { calls, layer } = createT3Gateway({ + projectSetupScriptRunner: { runForThreadFails: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + const dispatched = calls + .filter((call) => call.method === "dispatch") + .map((call) => call.input); + + expect(calls.map((call) => call.method)).toContain("removeWorktree"); + expect(dispatched).toContainEqual( + expect.objectContaining({ + type: "thread.delete", + threadId: workPlanned.t3.threadId, + }), + ); + }).pipe(Effect.provide(layer)); + }); + + it.effect("keeps the worktree when thread deletion fails, preserving the setup error", () => { + const { calls, layer } = createT3Gateway({ + orchestrationEngine: { deleteFails: true }, + projectSetupScriptRunner: { runForThreadFails: true }, + }); + + return Effect.gen(function* () { + const gateway = yield* T3Gateway; + const error = yield* gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(error._tag).toBe("FatalError"); + expect(error.method).toBe("projectScriptRunner.runForThread"); + expect( + calls.filter((call) => call.method === "dispatch").map((call) => call.input), + ).toContainEqual( + expect.objectContaining({ + type: "thread.delete", + threadId: workPlanned.t3.threadId, + }), + ); + expect(calls.map((call) => call.method)).not.toContain("removeWorktree"); + }).pipe(Effect.provide(layer)); + }); + + it.effect("keeps a recovered thread and its worktree when setup cannot launch", () => { + const { calls, layer } = createT3Gateway({ + orchestrationEngine: { dispatchFails: "invariant" }, + projectSetupScriptRunner: { runForThreadFails: true }, + }); + + return Effect.gen(function* () { + const gateway = yield* T3Gateway; + const error = yield* gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(error._tag).toBe("FatalError"); + expect(error.method).toBe("projectScriptRunner.runForThread"); + expect(calls.map((call) => call.method)).toContain("getThreadShellById"); + expect(calls.filter((call) => call.method === "dispatch")).toHaveLength(1); + expect(calls.map((call) => call.method)).not.toContain("removeWorktree"); + }).pipe(Effect.provide(layer)); + }); + + /* + An unexpected stale registration that was not discoverable from our branch cannot be cleaned up safely. + */ + it.effect( + "fails fatally when worktree creation finds an unrelated stale registration", + () => { + const { calls, layer } = createT3Gateway({ + gwfs: { + createWorkreeFails: { detail: "'/worktreesDir/x' is missing but already registered" }, + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("gitWorkflowService.createWorktree"); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + ]); + }).pipe(Effect.provide(layer)); + }, + ); + + /* + The same stale registration, reported by Git as locked rather than already registered: still not ours to clean up safely. + */ + it.effect("fails fatally when worktree creation finds a locked stale registration", () => { + const { calls, layer } = createT3Gateway({ + gwfs: { createWorkreeFails: { detail: "'/worktreesDir/x' is missing but locked" } }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("gitWorkflowService.createWorktree"); + expect(result.reason).toBe( + "The worktree path is still registered to a deleted checkout and needs `git worktree prune`", + ); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + ]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when worktree creation fails for any other reason", () => { + const { calls, layer } = createT3Gateway({ + gwfs: { createWorkreeFails: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("gitWorkflowService.createWorktree"); + + // Retryable, so the failed creation attempt is not cleaned up. + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + ]); + }).pipe(Effect.provide(layer)); + }); + + /* + The ensureWorktree walk: every read can fail operationally, and each failure is retryable — nothing was changed yet, so the next pass re-derives the same facts. + */ + it.effect("fails retryably when checking for a surviving worktree branch fails", () => { + const { calls, layer } = createT3Gateway({ gwfs: { listRefsFails: true } }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("gitWorkflowService.listRefs"); + expect(calls.map((call) => call.method)).toEqual(["getProjectShellById", "listRefs"]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when inspecting the worktree path fails", () => { + const { calls, layer } = createT3Gateway({ + fileSystem: { existsFails: true }, + gwfs: { worktreeBranchExists: true, worktreeBranchPath: "/existing/worktree" }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("fileSystem.exists"); + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + ]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when inspecting the existing worktree fails", () => { + const { calls, layer } = createT3Gateway({ + fileSystem: { worktreePathExists: true }, + gwfs: { + worktreeBranchExists: true, + worktreeBranchPath: "/existing/worktree", + localStatusFails: true, + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("gitWorkflowService.localStatus"); + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + "localStatus", + ]); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails retryably when clearing the leftover path fails both ways", () => { + const { calls, layer } = createT3Gateway({ + fileSystem: { worktreePathExists: true, removeFails: true }, + gwfs: { + worktreeBranchExists: true, + worktreeBranchPath: "/existing/worktree", + removeWorkTreeFails: true, + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("gitWorkflowService.removeWorktree"); + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "exists", + "localStatus", + // Git refused, and the filesystem fallback failed with it. + "removeWorktree", + "remove", + ]); + }).pipe(Effect.provide(layer)); + }); + + /* + Interruption is not a fatal error. The processor times a hung provision out and interrupts + it, and cleanup must stay reserved for the fatal path: no removeWorktree, so the next + reconcile pass can still observe whatever the dispatch managed to commit. + */ + it.effect("keeps the worktree when a provision is interrupted", () => { + const dispatchStalled = Deferred.makeUnsafe(); + const { calls, layer } = createT3Gateway({ + orchestrationEngine: { dispatchStalls: dispatchStalled }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const provision = yield* t3Gateway + .provisionThread(workPlanned) + .pipe(Effect.forkChild({ startImmediately: true })); + yield* Deferred.await(dispatchStalled); + yield* Fiber.interrupt(provision); + + expect(calls.map((call) => call.method)).toEqual([ + "getProjectShellById", + "listRefs", + "createWorktree", + "randomUUIDv4", + "dispatch", + ]); + }).pipe(Effect.provide(layer)); + }); + + /* + Cleanup is best-effort: a worktree that also refuses to be removed must not mask the script failure. + */ + it.effect("still reports the script failure when the cleanup itself fails", () => { + const { calls, layer } = createT3Gateway({ + projectSetupScriptRunner: { runForThreadFails: true }, + gwfs: { removeWorkTreeFails: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.provisionThread(workPlanned).pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("projectScriptRunner.runForThread"); + + expect(calls.map((call) => call.method)).toContain("removeWorktree"); + }).pipe(Effect.provide(layer)); + }); + }); + }); + + describe("getTurnStatus", () => { + /* + What is `getTurnStatus` used for? + + In `processor.ts` it has one single caller, the `processThreadCreated` function. + + By now, we have an Exchange stored as being in the `ThreadCreated` state: + - we have successfully minted a thread id, a user message id and a new branch name + - we have used those to create a new worktree whose path derives from the workspace basename and the branch name, and which is associated to that specific thread and external platform request + - we have stored this information + + And now? + + Operationally only one thing is needed: starting the turn and having the agent do its thing and come up with some response to the original user. + + But what if a turn was started and then some failure/crash caused the turn start not to be recorded by the system? It would make no sense to re-start the turn, or the operation could fail. Thus, the first thing we want to do when processing a `ThreadCreated` exchange is to verify whether it already started a turn and verify its status. + + Note that the answer is not binary: `ThreadCreatedContext` reports the turn as "missing", "active" or "completed" (carrying the reply), and `fromThreadCreated` maps those to `start-turn`, `wait` and `record-reply-pending` respectively. + + And thus, here, we verify the behavior of `getTurnStatus` on T3Gateway service. + */ + + const threadCreated = toThreadCreated( + toWorkPlanned( + makeRequestAccepted( + { + attachments: [], + snapshot: "getTurnStatus - snapshot", + sourceUri: "test://get-turn-status", + }, + { projectId: ProjectId.make("projectId"), startBranchName: "startBranchName" }, + now, + ), + { + projectId: ProjectId.make("projectId"), + startBranchName: "startBranchName", + startCommitSha: "startCommitSha", + threadId: ThreadId.make("threadId"), + userMessageId: MessageId.make("userMessageId"), + worktreeBranchName: "worktreeBranchName", + }, + now, + ), + now, + ); + + /** The coordinates every reply out of our turn carries. */ + const turn = { + threadId: threadCreated.t3.threadId, + userMessageId: threadCreated.t3.userMessageId, + turnId: TurnId.make("turnId"), + }; + + const settled = { type: "settled", ...turn } as const; + + // A failure observed before any turn adopted our message. + const settledWithoutTurn = { type: "settled", ...turn, turnId: null } as const; + + /** + * A projected turn on the exchange's thread. Defaults describe the turn our own message + * started; tests override `pendingMessageId` to plant other messages' turns, and `state` / + * `assistantMessageId` to shape the outcome. + */ + const makeProjectionTurn = (input?: Partial): ProjectionTurn => ({ + threadId: threadCreated.t3.threadId, + turnId: TurnId.make("turnId"), + pendingMessageId: threadCreated.t3.userMessageId, + sourceProposedPlanThreadId: null, + sourceProposedPlanId: null, + assistantMessageId: null, + state: "pending", + requestedAt: DateTime.formatIso(DateTime.nowUnsafe()), + startedAt: null, + completedAt: null, + checkpointTurnCount: null, + checkpointRef: null, + checkpointStatus: null, + checkpointFiles: [], + ...input, + }); + + it.effect("answers { turn: 'missing' } when the thread has no turns at all", () => { + const { calls, layer } = createT3Gateway({ turnRepository: { turns: [] } }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ turn: "missing" }); + + // Both lookups are scoped to the exchange's own thread. + expect(calls).toEqual([ + { + service: "ProjectionTurnRepository", + method: "listByThreadId", + input: { threadId: threadCreated.t3.threadId }, + }, + { + service: "ProjectionSnapshotQuery", + method: "getThreadDetailById", + input: threadCreated.t3.threadId, + }, + ]); + }).pipe(Effect.provide(layer)); + }); + /* + Turns started by other messages (another platform, the web UI) are not ours: "does this + thread have a turn?" is the wrong question, "did our message start one?" is the right one. + */ + it.effect( + "answers { turn: 'missing' } when the thread has turns but none whose pendingMessageId matches the exchange's userMessageId", + () => { + const { layer } = createT3Gateway({ + turnRepository: { + turns: [ + makeProjectionTurn({ pendingMessageId: MessageId.make("someone-else") }), + makeProjectionTurn({ pendingMessageId: null, state: "completed" }), + ], + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ turn: "missing" }); + }).pipe(Effect.provide(layer)); + }, + ); + it.effect("answers { turn: 'active' } when the matching turn is pending", () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "pending" })] }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ turn: "active" }); + }).pipe(Effect.provide(layer)); + }); + + it.effect("answers { turn: 'active' } when the matching turn is running", () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "running" })] }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ turn: "active" }); + }).pipe(Effect.provide(layer)); + }); + it.effect( + "answers a completed turn with an answer reply carrying the assistant message text verbatim", + () => { + const assistantMessageId = MessageId.make("assistantMessageId"); + + const { layer } = createT3Gateway({ + turnRepository: { + turns: [makeProjectionTurn({ state: "completed", assistantMessageId })], + }, + pqsm: { + threadMessages: [{ id: assistantMessageId, text: "the agent's answer" }], + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { type: "answer", text: "the agent's answer", ...turn }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect( + "picks our turn's reply when the thread holds several turns from other messages alongside ours", + () => { + const assistantMessageId = MessageId.make("ourAssistantMessageId"); + const foreignAssistantMessageId = MessageId.make("foreignAssistantMessageId"); + + const { layer } = createT3Gateway({ + turnRepository: { + turns: [ + // A completed foreign turn before ours: picking "the first completed turn" would grab this one. + makeProjectionTurn({ + pendingMessageId: MessageId.make("someone-else"), + state: "completed", + assistantMessageId: foreignAssistantMessageId, + }), + makeProjectionTurn({ state: "completed", assistantMessageId }), + makeProjectionTurn({ pendingMessageId: null, state: "running" }), + ], + }, + pqsm: { + threadMessages: [ + { id: foreignAssistantMessageId, text: "someone else's answer" }, + { id: assistantMessageId, text: "our answer" }, + ], + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { type: "answer", text: "our answer", ...turn }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + it.effect( + "answers a completed turn with a failure reply when the turn has no assistantMessageId", + () => { + const { layer } = createT3Gateway({ + turnRepository: { + turns: [makeProjectionTurn({ state: "completed", assistantMessageId: null })], + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { + type: "failure", + text: "T3 completed without producing a response.", + cause: settled, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect( + "answers a completed turn with a failure reply when the assistant message is missing or has empty text", + () => { + const assistantMessageId = MessageId.make("assistantMessageId"); + + const turns = [makeProjectionTurn({ state: "completed", assistantMessageId })]; + + // The turn names an assistant message the thread does not contain. + const missingMessage = createT3Gateway({ + turnRepository: { turns }, + pqsm: { threadMessages: [] }, + }); + + // The message exists but holds nothing worth posting. + const emptyText = createT3Gateway({ + turnRepository: { turns }, + pqsm: { threadMessages: [{ id: assistantMessageId, text: " \n " }] }, + }); + + const expected = { + turn: "completed", + reply: { + type: "failure", + text: "T3 completed without producing a response.", + cause: settled, + }, + }; + + const getTurnStatus = Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + return yield* t3Gateway.getTurnStatus(threadCreated); + }); + + return Effect.gen(function* () { + expect(yield* getTurnStatus.pipe(Effect.provide(missingMessage.layer))).toEqual(expected); + expect(yield* getTurnStatus.pipe(Effect.provide(emptyText.layer))).toEqual(expected); + }); + }, + ); + it.effect( + "answers a completed turn with a failure reply carrying session.lastError when the turn errored", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "error" })] }, + pqsm: { sessionLastError: "provider exploded" }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { type: "failure", text: "provider exploded", cause: settled }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect( + "answers a completed turn with a generic failure reply when the turn errored without a recorded lastError", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "error" })] }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { + type: "failure", + text: "T3 failed while processing this request.", + cause: settled, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + it.effect( + "answers a completed turn with a cancellation reply when the turn was interrupted", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "interrupted" })] }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { + type: "cancellation", + text: "T3 stopped processing this request.", + ...turn, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + /* + An observed fact, not a lookup error: retrying cannot bring the thread back, so the exchange must progress to a failure reply instead of staying open forever. + */ + it.effect( + "answers a completed turn with a failure reply when the turn settled but the thread is gone", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "completed" })] }, + pqsm: { isThreadDetailMissing: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { + type: "failure", + text: "T3 finished, but its thread could no longer be found.", + cause: settled, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + /* + When the provider fails to start a turn, T3 keeps two facts: + 1. our message on the thread is stored + 2. the session is marked as errored + + The current test verifies that if conditions 1 and 2 are met, but there is no turn retrieved from T3, then we're in an error state. + */ + it.effect( + "answers a completed turn with a failure reply when no turn adopted our message and the session errored", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [] }, + pqsm: { + threadMessages: [ + { id: threadCreated.t3.userMessageId, text: "snapshot", role: "user" }, + ], + sessionStatus: "error", + sessionLastError: "codex: command not found", + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { + type: "failure", + text: "codex: command not found", + cause: settledWithoutTurn, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + /* + The previous case checked whether we had both a session error and a message recorded. If we did, we concluded that there was an error provider-side. + + Here, we test the same situation, but without the user message recorded. As T3 saves the message _before_ starting the turn and the turn is not here, we never dispatched the turn start, so it is safe to do it now. + */ + it.effect( + "answers { turn: 'missing' } when the session errored but our message never reached the thread", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [] }, + pqsm: { sessionStatus: "error", sessionLastError: "codex: command not found" }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ turn: "missing" }); + }).pipe(Effect.provide(layer)); + }, + ); + + /* + In ThreadCreated the thread existed. No turn and no thread means it was deleted since, and + no retry can bring it back. + */ + it.effect( + "answers a failure reply when no turn adopted our message and the thread is gone", + () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [] }, + pqsm: { isThreadDetailMissing: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated); + + expect(result).toEqual({ + turn: "completed", + reply: { + type: "failure", + text: "T3's thread could no longer be found.", + cause: settledWithoutTurn, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect("fails with RetryableError when listing the thread's turns fails", () => { + const { layer } = createT3Gateway({ turnRepository: { listByThreadIdFails: true } }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("projectionTurnRepository.listByThreadId"); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails with RetryableError when the thread detail fetch fails transiently", () => { + const { layer } = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "completed" })] }, + pqsm: { isGetThreadDetailByIdError: true }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.getTurnStatus(threadCreated).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("projectionSnapshotQuery.getThreadDetailById"); + }).pipe(Effect.provide(layer)); + }); + + /* + The detail fetch exists only to read a settled reply; running it earlier would add a failure mode to arms that need nothing from it. + */ + it.effect("performs no thread detail lookup when the turn is active", () => { + const active = createT3Gateway({ + turnRepository: { turns: [makeProjectionTurn({ state: "running" })] }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + yield* t3Gateway.getTurnStatus(threadCreated); + + expect(active.calls.map((call) => call.method)).toEqual(["listByThreadId"]); + }).pipe(Effect.provide(active.layer)); + }); + }); + + describe("startTurn", () => { + /* + What is `startTurn` used for? + + It has a single call site, `processThreadCreated`. From a business-logic perspective the following has happened: + 1. A user on an external platform has sent a message that has been processed and recorded. + 2. A threadId, userMessageId and branch names have been minted for this incoming message. + 3. A `RequestClaimed` is saved to the exchange repository. We now have a durable record of the incoming request and the t3 coordinates of the work associated to it. + 4. A git worktree is created, the branch is checked out, the scripts of the project have been run. a `ThreadCreated` is recorded to the `Exchange` repository. + 5. Now that we have a thread, we want to start the turn, but only if there is no turn already for this very thread and userMessageId. `getTurnStatus` does exactly that: given the `ThreadCreated` it retrieves the related information to determine whether a previous run may have already started a turn that has never been recorded, or never completed. + 6. We now know that we're safe to start the turn. + + So, what do we do in `startTurn`? + + Essentially one thing: dispatch `thread.turn.start` command to the orchestration engine, sending the captured request snapshot as the first user message, under the minted userMessageId, with the stored attachments. That `userMessageId` becomes the turn's `pendingMessageId`, which is exactly the identity `getTurnStatus` matches on. + + Note what `startTurn` does not: + - It does **not** start a turn in the "physical" sense of waiting for a synchronous confirmation that the turn has effectively started in some harness. It merely returns once the command is dispatched and durably accepted; the provider adopting the turn and running it happens asynchronously after. Even a start failure after this point does not surface at `startTurn` level. It will be catched after, during a `getTurnStatus` run. + - Needless to say, it doesn't wait for a turn completion either, as it doesn't even wait for it to start. + + Why is "dispatched and durably accepted" enough? Because the engine appends the events and writes the projected turn rows in one SQL transaction, and only then returns. + `getTurnStatus` reads the very rows that transaction writes, so a crash anywhere leaves both the events and the turn row, or neither: there is no window where a turn started but cannot be seen by the next cycle. + This matters because a duplicate dispatch would not fail: the decider queues it while our turn is pending or active, or starts a second turn if it already completed. + So the protection against double starts is never sending one, not recovering from a rejection. + + A successful `startTurn` transitions nothing: the processor returns "unchanged" and the exchange stays `ThreadCreated` until `getTurnStatus` observes a settled turn. + + TODO: Consider listening to t3 events to confirm the turn has started maybe? + + As `startTurn` is an action both error classifications apply. We may get both Retryable as well as Fatal errors. + */ + + const threadCreated = toThreadCreated( + toWorkPlanned( + makeRequestAccepted( + { + attachments: [], + snapshot: "please fix the flaky login test", + sourceUri: "test://start-turn", + }, + { projectId: ProjectId.make("projectId"), startBranchName: "startBranchName" }, + now, + ), + { + projectId: ProjectId.make("projectId"), + startBranchName: "startBranchName", + startCommitSha: "startCommitSha", + threadId: ThreadId.make("threadId"), + userMessageId: MessageId.make("userMessageId"), + worktreeBranchName: "worktreeBranchName", + }, + now, + ), + now, + ); + + /* + Only the identity relationships are asserted, not the full command payload: the userMessageId linkage is what makes the turn findable by `getTurnStatus`, and minting a fresh id here instead would deadlock every exchange without any error surfacing. + The command `type` is part of the assertion too, so a `thread.create` carrying a message cannot pass as a turn start. + */ + it.effect( + "dispatches the turn start for our thread carrying the snapshot under the exchange's userMessageId", + () => { + const { calls, layer } = createT3Gateway(); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + yield* t3Gateway.startTurn(threadCreated); + + const dispatch = calls.find((call) => call.method === "dispatch"); + expect(dispatch?.input).toMatchObject({ + type: "thread.turn.start", + threadId: threadCreated.t3.threadId, + message: { + messageId: threadCreated.t3.userMessageId, + text: threadCreated.snapshot, + attachments: threadCreated.attachments, + }, + }); + }).pipe(Effect.provide(layer)); + }, + ); + + it.effect("fails with FatalError when the decider rejects the turn start", () => { + const { layer } = createT3Gateway({ orchestrationEngine: { dispatchFails: "invariant" } }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.startTurn(threadCreated).pipe(Effect.flip); + + expect(result._tag).toBe("FatalError"); + expect(result.method).toBe("orchestrationEngine.dispatch"); + }).pipe(Effect.provide(layer)); + }); + + it.effect("fails with RetryableError when the dispatch fails operationally", () => { + const { layer } = createT3Gateway({ orchestrationEngine: { dispatchFails: true } }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const result = yield* t3Gateway.startTurn(threadCreated).pipe(Effect.flip); + + expect(result._tag).toBe("RetryableError"); + expect(result.method).toBe("orchestrationEngine.dispatch"); + }).pipe(Effect.provide(layer)); + }); + }); + + describe("threadActivity", () => { + /* + `threadActivity` represents the last and final piece of the `t3Gateway`. + + It is the only `T3Gateway` service not returning an effect. Instead it exposes a `Stream` to which the processor has to subscribe. + + And the NTBS processor does exactly that. When the `run` Effect of the NTBS processor is yielded it subscribes to thread activity. + + `subscribeToThreadActivity` does `Stream.runForEach(t3.threadActivity, (threadId) => ...does something with the thread id). + + The important takeaway seems to be the fact that it merely seems to signal that something has happened/changed for some `threadId`. It is then up to the processor to lookup whether that threadId is of interest to the processor or not. + + What does `threadActivity` does in practice then and how does it work? Apparently, it should just subscribe to the main t3 event emitter, filter events for those that related to thread changes and merely stream the threadId of those events. There is no "who's listening" gap here: a `Stream` is a lazy description, and nobody subscribes until someone runs it. `OrchestrationEngineService` exposes `streamDomainEvents`, a `Stream.fromPubSub` that creates a fresh subscription each time it is run, so `threadActivity` is just that stream piped through a filter mapping events to their threadId. The subscription to the engine's PubSub is established exactly when the processor's Stream.runForEach starts, with no separate "start listening" step for `T3Gateway` to perform. + + The filter is an allow-list derived from the projection fields the processor reads, not a guess at which events look important. + + `getThreadStatus` only asks whether the thread row exists: `thread.created` and `thread.deleted`. `getTurnStatus` reads the thread's turns, its session, and its messages: `thread.turn-start-requested`, `thread.turn-interrupt-requested`, `thread.turn-diff-completed`, and `thread.session-set` can change turn state; non-streaming `thread.message-sent` adds the user message used to recognize a failed start or the assistant's final reply; `thread.messages-resynced` and `thread.reverted` rewrite the message rows it scans. Thread metadata (`thread.meta-updated`) is out because it changes none of this data. If a read grows a new dependency, this list grows with it — a field an event writes but the filter drops strands the exchange until the next sweep. + + Activity is the one payload-dependent exception. Ordinary `thread.activity-appended` events are noise, but two kinds mutate turn rows: `context-compaction` and `provider.turn.start.failed` both delete the pending turn start, which `listByThreadId` answers from. + + The excluded noise is the bulk of a live turn: streaming deltas are `thread.message-sent` too, with `streaming: true`, and ordinary activity fires as the agent works. Forwarded, they wake the processor for every token, and each wake costs a repository read and a T3 status read to learn nothing — an exchange being observed mid-turn has not moved until its turn settles. + + A ping never arrives "too early". When the engine dispatches a command, everything happens inside one SQL transaction: events appended, projection rows written, receipt stored. Only after that transaction commits does the engine publish the event to the PubSub feeding this stream. So by the time the processor receives a ping for a thread, the database already contains whatever that event changed: when the ping wakes the processor and it calls getTurnStatus, the turn row it queries is guaranteed to reflect the event that caused the ping. There is no window where we get pinged "turn completed", read the projection, and still see the turn as running. Without this ordering we would need retry-until-visible logic; with it, ping then read is safe as-is. + + But a ping can fail to arrive at all. The PubSub only delivers to subscribers that exist at publish time. If an event fires while nobody is subscribed — the classic case being server startup, before the processor has forked its Stream.runForEach — that ping is simply gone. Nothing replays it. The design accepts that because missed pings are covered elsewhere: startup recovery re-drives every non-terminal exchange when the processor boots, and the planned sweeper periodically re-drives non-terminal exchanges. The ping is an optimization for latency — react immediately instead of waiting for the next sweep — not the mechanism correctness depends on. Pings we do get are always safe to act on immediately; pings we don't get are someone else's job to compensate for. + */ + + const threadId = ThreadId.make("activity-thread"); + const projectId = ProjectId.make("activity-project"); + + const baseEventFields = { + sequence: 0, + occurredAt: "2026-01-01T00:00:00.000Z", + commandId: null, + causationEventId: null, + correlationId: null, + metadata: {}, + } as const; + + const threadEvent: OrchestrationEvent = { + ...baseEventFields, + type: "thread.session-set", + eventId: EventId.make("thread-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + session: { + threadId, + status: "running", + providerName: null, + runtimeMode: "full-access", + activeTurnId: null, + lastError: null, + updatedAt: "2026-01-01T00:00:00.000Z", + }, + }, + }; + + const projectEvent: OrchestrationEvent = { + ...baseEventFields, + type: "project.deleted", + eventId: EventId.make("project-event"), + aggregateKind: "project", + aggregateId: projectId, + payload: { projectId, deletedAt: "2026-01-01T00:00:00.000Z" }, + }; + + const messageSentEvent = ( + eventId: string, + messageId: MessageId, + streaming: boolean, + role: "assistant" | "user" = "assistant", + ): OrchestrationEvent => ({ + ...baseEventFields, + type: "thread.message-sent", + eventId: EventId.make(eventId), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + messageId, + role, + text: role === "user" ? "the request" : streaming ? "partial ans" : "the answer", + turnId: role === "user" ? null : TurnId.make("turn-1"), + streaming, + createdAt: baseEventFields.occurredAt, + updatedAt: baseEventFields.occurredAt, + }, + }); + + const activityEvent: OrchestrationEvent = { + ...baseEventFields, + type: "thread.activity-appended", + eventId: EventId.make("activity-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + activity: { + id: EventId.make("activity-1"), + tone: "tool", + kind: "command", + summary: "ran a command", + payload: null, + turnId: null, + createdAt: baseEventFields.occurredAt, + }, + }, + }; + + /* + One event per field group the processor's reads depend on: thread existence, turn state, session state, the user message and final reply, message resync and revert, and the two activity kinds that delete a pending turn start. + */ + const keptEvents: ReadonlyArray = [ + { + ...baseEventFields, + type: "thread.created", + eventId: EventId.make("created-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + projectId, + title: "activity thread", + modelSelection: { + instanceId: ProviderInstanceId.make("instanceId"), + model: "custom", + options: [], + }, + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: "/tmp/activity-thread", + createdAt: baseEventFields.occurredAt, + updatedAt: baseEventFields.occurredAt, + }, + }, + { + ...baseEventFields, + type: "thread.turn-start-requested", + eventId: EventId.make("turn-start-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + messageId: MessageId.make("turn-message"), + runtimeMode: "full-access", + interactionMode: "default", + createdAt: baseEventFields.occurredAt, + }, + }, + { + ...baseEventFields, + type: "thread.turn-interrupt-requested", + eventId: EventId.make("turn-interrupt-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + turnId: TurnId.make("turn-1"), + createdAt: baseEventFields.occurredAt, + }, + }, + { + ...baseEventFields, + type: "thread.turn-diff-completed", + eventId: EventId.make("turn-diff-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + turnId: TurnId.make("turn-1"), + checkpointTurnCount: 1, + checkpointRef: CheckpointRef.make("refs/t3/checkpoints/activity-thread/turn/1"), + status: "ready", + files: [], + assistantMessageId: MessageId.make("complete-message"), + completedAt: baseEventFields.occurredAt, + }, + }, + messageSentEvent("user-event", MessageId.make("turn-message"), false, "user"), + messageSentEvent("complete-event", MessageId.make("complete-message"), false), + { + ...baseEventFields, + type: "thread.messages-resynced", + eventId: EventId.make("resynced-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + afterMessageId: null, + messages: [ + { + id: MessageId.make("resynced-message"), + role: "assistant", + text: "resynced answer", + turnId: null, + streaming: false, + createdAt: baseEventFields.occurredAt, + updatedAt: baseEventFields.occurredAt, + }, + ], + reason: "provider stream dropped updates", + }, + }, + { + ...baseEventFields, + type: "thread.reverted", + eventId: EventId.make("reverted-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { threadId, turnCount: 1 }, + }, + { + ...baseEventFields, + type: "thread.activity-appended", + eventId: EventId.make("failed-turn-start-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + activity: { + id: EventId.make("failed-turn-start-activity"), + tone: "error", + kind: "provider.turn.start.failed", + summary: "Provider turn start failed", + payload: null, + turnId: null, + createdAt: baseEventFields.occurredAt, + }, + }, + }, + { + ...baseEventFields, + type: "thread.activity-appended", + eventId: EventId.make("compaction-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + activity: { + id: EventId.make("compaction-activity"), + tone: "info", + kind: "context-compaction", + summary: "Context compacted", + payload: { requestId: "turn-message", state: "completed" }, + turnId: null, + createdAt: baseEventFields.occurredAt, + }, + }, + }, + { + ...baseEventFields, + type: "thread.session-set", + eventId: EventId.make("session-set-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { + threadId, + session: { + threadId, + status: "running", + providerName: null, + runtimeMode: "full-access", + activeTurnId: null, + lastError: null, + updatedAt: baseEventFields.occurredAt, + }, + }, + }, + { + ...baseEventFields, + type: "thread.deleted", + eventId: EventId.make("deleted-event"), + aggregateKind: "thread", + aggregateId: threadId, + payload: { threadId, deletedAt: baseEventFields.occurredAt }, + }, + ]; + + it.effect("emits the threadId of thread events and drops project events", () => { + const { layer } = createT3Gateway({ + orchestrationEngine: { domainEvents: [projectEvent, threadEvent] }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const emitted = yield* Stream.runCollect(t3Gateway.threadActivity); + + expect(emitted).toEqual([threadId]); + }).pipe(Effect.provide(layer)); + }); + + /* + A streaming turn is the loudest thing in the engine: every token is a `thread.message-sent` and every tool call appends an activity. None of it can change an exchange: the processor reacts to turns settling, not to turns progressing. This activity's kind has no projection arm at all, unlike the two exceptional kinds the kept test pins. + */ + it.effect("drops streaming deltas and ordinary activity appends", () => { + const { layer } = createT3Gateway({ + orchestrationEngine: { + domainEvents: [ + messageSentEvent("delta-event", MessageId.make("delta-message"), true), + activityEvent, + ], + }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const emitted = yield* Stream.runCollect(t3Gateway.threadActivity); + + expect(emitted).toEqual([]); + }).pipe(Effect.provide(layer)); + }); + + /* + The counterpart to the drop test: everything the processor's reads can answer differently on has to come through, or an exchange waits for the next one-minute sweep instead of reacting to T3. + */ + it.effect("emits every event the status reads can change on", () => { + const { layer } = createT3Gateway({ + orchestrationEngine: { domainEvents: keptEvents }, + }); + + return Effect.gen(function* () { + const t3Gateway = yield* T3Gateway; + + const emitted = yield* Stream.runCollect(t3Gateway.threadActivity); + + expect(emitted).toEqual(keptEvents.map(() => threadId)); + }).pipe(Effect.provide(layer)); + }); + }); +}); diff --git a/apps/server/src/ntbs/t3gateway.ts b/apps/server/src/ntbs/t3gateway.ts new file mode 100644 index 000000000000..fcdf50f0e071 --- /dev/null +++ b/apps/server/src/ntbs/t3gateway.ts @@ -0,0 +1,919 @@ +/* +The T3 gateway module exposes the interface that the NTBS processor uses to communicate +with T3, similar to how adapter models the interaction with the external platform. + */ + +import { + CommandId, + DEFAULT_PROVIDER_INTERACTION_MODE, + MessageId, + OrchestrationCommand, + type ProjectId, + ThreadId, +} from "@t3tools/contracts"; +import type * as NTBS from "./exchange.ts"; +import { + Context, + Crypto, + Data, + DateTime, + Effect, + FileSystem, + Layer, + Option, + Result, + Stream, +} from "effect"; +import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts"; +import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import { ProjectionTurnRepository } from "../persistence/Services/ProjectionTurns.ts"; +import { GitWorkflowService } from "../git/GitWorkflowService.ts"; +import { ProjectSetupScriptRunner } from "../project/ProjectSetupScriptRunner.ts"; +import { DEFAULT_THREAD_TITLE } from "@t3tools/shared/threadTitle"; +import { ServerSettingsService } from "../serverSettings.ts"; + +/* + NTBS architecture: + + 1. Adapter + Responsible for the communication with the external platform (Jira, Discord, Teams, etc). + - `acknowledge` confirms T3 is processing the user request + - `postReply` sends the reply to the platform + - `findPostedReplies` retries the replies sent to the platform (but maybe not recorded due to crash) + + 2. ExchangeRepository + Responsible for saving `Exchange` data, entities that model the incoming message -> reply cycle and the relations to T3 data (threads, messages, turns). + + 3. T3 gateway + Models the interaction with T3's own api and VCS lifecycle: creating threads, worktrees, starting turns, etc. + + 4. NTBS Processor + The orchestrator between 1, 2, 3 and 4. +*/ + +/** + * A classification, not a scheduling request: it states the step is safe to retry, not that anything will retry it. + * A failed retryable step leaves the exchange state untouched, so the exchange simply remains non-terminal, and whatever re-drives non-terminal exchanges re-runs the cycle from persisted state. + */ +export class RetryableError extends Data.TaggedError("RetryableError")<{ + reason: string; + cause: unknown; + method: string; +}> {} + +/** + * T3 will never accept this work. + * + * The mirror classification: retrying is pointless, so the exchange must progress to a terminal state instead of staying open. + * + * Actions (`planCoordinates`, `provisionThread`, `startTurn`) fail with `FatalError` when T3 rejects the work, and the processor converts that into a reply-pending failure. + * Reads (`getThreadStatus`, `getTurnStatus`) never carry `FatalError`: an unrecoverable fact they observe goes into the context, and the decider drives the same terminal transition. + * Both roads end at the same place: a failure reply to the user. + */ +export class FatalError extends Data.TaggedError("FatalError")<{ + reason: string; + cause: unknown; + method: string; +}> {} + +type T3GatewayRequirements = + /* + Dispatches thread creation and turn-start commands. + Provides the T3 event stream used to detect outcomes. + */ + | OrchestrationEngineService + /* + Loads the selected T3 project and reads thread outcomes. + */ + | ProjectionSnapshotQuery + /* + Finds the exact projected turn associated with the original T3 user message. + */ + | ProjectionTurnRepository + /* + Creates the isolated branch and worktree for each external request. + */ + | GitWorkflowService + /* + Runs the project setup scripts in the newly created worktree before agent work begins. + */ + | ProjectSetupScriptRunner + /* + Generates unique identifiers for the new thread, message, commands, and worktree branch. + */ + | Crypto.Crypto + /* + Supplies the environment's current default model when the project inherits it. + */ + | ServerSettingsService + /* + Probes and clears leftover worktree directories during reentrant provisioning. + */ + | FileSystem.FileSystem; + +/** A branch on `origin` and the commit it pointed at when it was resolved. */ +interface RemoteBranchTip { + readonly branchName: string; + readonly commitSha: string; +} + +/* + A failed create can still expose an unexpected stale registration. Registrations + discovered through `listRefs` are pruned before creation; anything left here is + terminal because the gateway does not know which unrelated path would be safe to prune. +*/ +const isStaleWorktreeRegistration = (cause: { readonly detail: string }): boolean => + /missing but (?:already registered|locked)/i.test(cause.detail); + +export interface T3Gateway { + /** + * Pins the requested branch to its current commit on `origin` and mints the thread, message, and + * worktree branch identifiers recorded at claim. + * + * Creates nothing: no thread, no worktree, no turn. Every call mints fresh identifiers, so call it + * once per request and persist the result — a second call orphans the work the first one planned. + */ + readonly planCoordinates: ( + projectId: ProjectId, + startBranchName: string, + ) => Effect.Effect; + + /** + * A missing thread is a normal answer here, it is what triggers provisioning; only at ThreadCreated does the same observation become an anomaly. + */ + readonly getThreadStatus: ( + state: NTBS.WorkPlanned, + ) => Effect.Effect; + + /** Reentrant: worktree, thread creation and setup scripts, each skipped if already done. */ + readonly provisionThread: ( + state: NTBS.WorkPlanned, + ) => Effect.Effect; + + /** Reports turn progress, interpreting a finished turn into a `Reply`: the agent's verbatim response when it produced one, a synthesized failure or cancellation note otherwise. + * + * The question it answers isn't really "does this thread have a turn?" but "did **our** message start a turn?". This is an important distinction because user messages to the same thread in T3 can come from different sources and interfaces. We want to know about the turn that should start stemming from a user in the external platform with a specific userMessageId. + * + * This is the invariant that makes recovery safe. + * + * It's a pure read, errors are Retryable only. Every lookup failure means "ask again later", nothing it learns can reject the exchange. + * + * Unrecoverable edge cases like "turn completed but thread not found" map to "completed" turns whose reply is a failure. + * + */ + readonly getTurnStatus: ( + state: NTBS.ThreadCreated, + ) => Effect.Effect; + + /** + * Safety here is borrowed from the orchestration engine, not proven locally: dispatch returns only after the events and the projected turn rows commit in one SQL transaction, so a successful dispatch is immediately visible to `getTurnStatus` and a crash leaves both or neither. + * That property is what makes observe-before-act sufficient against double starts, because a duplicate `thread.turn.start` would not fail — the decider queues it or starts a second turn. + * If the engine ever projected asynchronously, this module would silently start duplicate turns and no test in this package would notice; the engine's own atomicity tests (OrchestrationEngine.test.ts, "rolls back all events for a multi-event command when projection fails mid-dispatch") are what pin it. + */ + readonly startTurn: ( + state: NTBS.ThreadCreated, + ) => Effect.Effect; + + /** Threads whose T3 state just changed; the processor reconciles each. */ + readonly threadActivity: Stream.Stream; +} + +export const T3Gateway = Context.Service("t3code/ntbs/t3Gateway"); + +const T3GatewayLive: Effect.Effect = Effect.gen( + function* () { + const orFail = + (severity: S) => + (method: string, reason: string) => + Effect.mapError( + (cause: unknown) => + (severity === "fatal" + ? new FatalError({ reason, cause, method }) + : new RetryableError({ reason, cause, method })) as S extends "fatal" + ? FatalError + : RetryableError, + ); + + const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; + + const serverSettings = yield* ServerSettingsService; + + const orchestrationEngine = yield* OrchestrationEngineService; + + /* + The lookup failing is operational; the project being absent is not. + A deleted or archived project will never come back, so retrying is pointless. + */ + const getProject = (projectId: ProjectId) => + projectionSnapshotQuery.getProjectShellById(projectId).pipe( + orFail("retryable")( + "projectionSnapshotQuery.getProjectShellById", + "Could not load project " + projectId, + ), + Effect.flatMap( + Option.match({ + onSome: Effect.succeed, + onNone: () => + Effect.fail( + new FatalError({ + method: "projectionSnapshotQuery.getProjectShellById", + reason: "Project " + projectId + " does not exist", + cause: null, + }), + ), + }), + ), + ); + + const gitWorkflowService = yield* GitWorkflowService; + + /** + * Resolves `branchName` to the commit it currently points at on `origin`. + * + * Fetches first, so the answer reflects the current remote tip even when the local copy is behind. Only `origin` is consulted: local state is never a fallback, because two requests naming the same branch must start from the same commit. + * + * Rejects when the project has no `origin`. A `branchName` that does not resolve is retried until the exchange's deadline instead, because a missing branch cannot be told apart from a repository that merely failed to read. + */ + const resolveRemoteBranchTip = ( + cwd: string, + startBranchName: string, + ): Effect.Effect => + Effect.gen(function* () { + // Check if origin exist. If not, T3 will never be able to accept this work. + // The lookup failing is operational; a definitive `false` is not. + yield* gitWorkflowService.remoteExists({ cwd, remoteName: "origin" }).pipe( + orFail("retryable")( + "gitWorkflowService.remoteExists", + "Could not check whether the remote 'origin' exists", + ), + Effect.filterOrFail( + (exists) => exists, + () => + new FatalError({ + method: "gitWorkflowService.remoteExists", + reason: "Remote 'origin' does not exist", + cause: null, + }), + ), + ); + + // Since it exists, let's fetch the latest remote state + yield* gitWorkflowService + .fetchRemote({ cwd, remoteName: "origin" }) + .pipe( + orFail("retryable")( + "gitWorkflowService.fetchRemote", + "Could not fetch origin. try again", + ), + ); + + /* + Reads the local `refs/remotes/origin/*` namespace the fetch above just refreshed; + no network is involved. + + A missing branch and a repository read failure both surface here as a failed + command, and nothing in the error tells them apart. Everything is retried instead: + the state's deadline ends the attempts, while a wrong rejection is permanent. + */ + return yield* gitWorkflowService + .resolveRemoteTrackingCommit({ + cwd, + refName: startBranchName, + fallbackRemoteName: "origin", + }) + .pipe( + Effect.map((resolved) => ({ + branchName: startBranchName, + commitSha: resolved.commitSha, + })), + Effect.mapError( + (cause) => + new RetryableError({ + method: "gitWorkflowService.resolveRemoteTrackingCommit", + reason: "Could not resolve branch '" + startBranchName + "' on origin", + cause, + }), + ), + ); + }); + + const fileSystem = yield* FileSystem.FileSystem; + + /** + * Finds or creates the checkout for `worktreeBranchName` and returns the path + * Git actually uses. Repository-level Git operations run from `workspaceRoot`; + * thread-scoped work uses the returned checkout path. Git owns path selection, + * while the exchange persists only the branch needed to resume provisioning. + */ + const ensureWorktree = (input: { + readonly workspaceRoot: string; + readonly worktreeBranchName: string; + readonly startCommitSha: string; + readonly startBranchName: string; + }): Effect.Effect => + Effect.gen(function* () { + const branch = yield* gitWorkflowService + .listRefs({ + cwd: input.workspaceRoot, + query: input.worktreeBranchName, + refKind: "local", + refresh: true, + }) + .pipe( + Effect.map((result) => + result.refs.find((ref) => ref.name === input.worktreeBranchName), + ), + orFail("retryable")( + "gitWorkflowService.listRefs", + "Could not check whether the worktree branch already exists", + ), + ); + + if (branch?.worktreePath) { + const existingWorktreePath = branch.worktreePath; + const pathExists = yield* fileSystem + .exists(existingWorktreePath) + .pipe(orFail("retryable")("fileSystem.exists", "Could not inspect the worktree path")); + + if (pathExists) { + const status = yield* gitWorkflowService + .localStatus({ cwd: existingWorktreePath }) + .pipe( + orFail("retryable")( + "gitWorkflowService.localStatus", + "Could not inspect the existing worktree", + ), + ); + + if (status.isRepo && status.refName === input.worktreeBranchName) { + return existingWorktreePath; + } + + yield* gitWorkflowService + .removeWorktree({ cwd: input.workspaceRoot, path: existingWorktreePath, force: true }) + .pipe( + Effect.catch(() => fileSystem.remove(existingWorktreePath, { recursive: true })), + orFail("retryable")( + "gitWorkflowService.removeWorktree", + "Could not clear the leftover worktree path", + ), + ); + } else { + yield* gitWorkflowService + .pruneWorktrees({ cwd: input.workspaceRoot }) + .pipe( + orFail("retryable")( + "gitWorkflowService.pruneWorktrees", + "Could not clear the stale worktree registration", + ), + ); + } + } + + return yield* gitWorkflowService + .createWorktree( + branch + ? { + // A previous attempt created the branch; check it out instead of re-branching. + cwd: input.workspaceRoot, + path: null, + refName: input.worktreeBranchName, + } + : { + // First real attempt: branch off the commit pinned at claim. + cwd: input.workspaceRoot, + path: null, + refName: input.startCommitSha, + newRefName: input.worktreeBranchName, + baseRefName: input.startBranchName, + }, + ) + .pipe( + Effect.map((result) => result.worktree.path), + Effect.mapError((cause) => + isStaleWorktreeRegistration(cause) + ? new FatalError({ + method: "gitWorkflowService.createWorktree", + reason: + "The worktree path is still registered to a deleted checkout and needs `git worktree prune`", + cause, + }) + : new RetryableError({ + method: "gitWorkflowService.createWorktree", + reason: "Could not create the worktree for " + input.worktreeBranchName, + cause, + }), + ), + ); + }); + + const crypto = yield* Crypto.Crypto; + const randomUUID = crypto.randomUUIDv4.pipe( + orFail("retryable")("crypto.randomUUIDv4", "Failed creating a UUID v4"), + ); + + const getNow = DateTime.now.pipe(Effect.map(DateTime.formatIso)); + + const projectScriptRunner = yield* ProjectSetupScriptRunner; + + const projectionTurnRepository = yield* ProjectionTurnRepository; + + const planCoordinates = ( + projectId: ProjectId, + startBranchName: string, + ): Effect.Effect => + Effect.gen(function* () { + /* + 1. Resolve the target project + 2. Resolve the branch - commit pair against which we will create our work tree. + 3. Mind thread, branch, message IDs + */ + + const project = yield* getProject(projectId); + + const remoteBranchTip = yield* resolveRemoteBranchTip( + project.workspaceRoot, + startBranchName, + ); + + const threadUUID = yield* randomUUID; + const threadId = ThreadId.make(threadUUID); + + const userMessageId = MessageId.make(yield* randomUUID); + + /* + The branch carries the full thread UUID so a stray branch identifies its thread + without truncating its identifier. The `ntbs/` prefix keeps T3 from treating it as + one of its temporary placeholders (`t3code/`), which it renames on the first turn. + */ + const worktreeBranchName = `ntbs/${threadUUID}`; + + const coordinates: NTBS.WorkCoordinates = { + projectId, + startBranchName: remoteBranchTip.branchName, + startCommitSha: remoteBranchTip.commitSha, + threadId, + userMessageId, + worktreeBranchName, + }; + return coordinates; + }); + + /* TODO: We doing a lot of work behind the scenes just to know whether the thread exists or is missing, this screams sql query or something not a snapshot query + */ + const getThreadStatus = ( + state: NTBS.WorkPlanned, + ): Effect.Effect => + projectionSnapshotQuery.getThreadShellById(state.t3.threadId).pipe( + Effect.map((maybeThread) => ({ + thread: Option.isNone(maybeThread) ? ("missing" as const) : ("present" as const), + })), + orFail("retryable")( + "projectionSnapshotQuery.getThreadShellById", + "Could not check whether thread " + state.t3.threadId + " exists", + ), + ); + + const getTurnStatus = ( + state: NTBS.ThreadCreated, + ): Effect.Effect => + Effect.gen(function* () { + const turns = yield* projectionTurnRepository + .listByThreadId({ threadId: state.t3.threadId }) + .pipe( + orFail("retryable")( + "projectionTurnRepository.listByThreadId", + "Could not load the turns of thread " + state.t3.threadId, + ), + ); + + /* + `.find` is safe: a userMessageId labels at most one turn. It is minted once per request, + and a turn start is only repeated by recovery when no turn exists for it yet. + */ + const turn = turns.find((turn) => turn.pendingMessageId === state.t3.userMessageId); + + // The thread detail holds both the thread's messages and its session. + const loadThreadDetail = projectionSnapshotQuery + .getThreadDetailById(state.t3.threadId) + .pipe( + orFail("retryable")( + "projectionSnapshotQuery.getThreadDetailById", + "Could not load thread " + state.t3.threadId, + ), + ); + + if (turn === undefined) { + /* + No turn for our message. Two cases: + 1. we never dispatched the turn start -> missing, start it + 2. the provider failed before starting -> T3 keeps our message and marks the session + as errored, but never links a turn to our message -> failure reply + + Note: Loading the whole thread detail is expensive. That is fine for the one-minute sweep, but this arm also runs on every activity ping between our turn-start and T3 marking the session as running, and any streaming thread in the system pings during that window. TODO: We should review and find cheaper strategies. + */ + // No turn ever adopted our message, so a failure here refers to the thread and message only. + const settledWithoutTurn: NTBS.FailureCause = { + type: "settled", + threadId: state.t3.threadId, + userMessageId: state.t3.userMessageId, + turnId: null, + }; + + const maybeThread = yield* loadThreadDetail; + if (Option.isNone(maybeThread)) { + // The thread existed when we reached ThreadCreated, so it was deleted since. + // Retrying cannot bring it back: report the failure. + return { + turn: "completed", + reply: { + type: "failure", + text: "T3's thread could no longer be found.", + cause: settledWithoutTurn, + }, + } as const; + } + + const thread = maybeThread.value; + const hasOurMessage = thread.messages.some( + (message) => message.role === "user" && message.id === state.t3.userMessageId, + ); + + if (hasOurMessage && thread.session?.status === "error") { + return { + turn: "completed", + reply: { + type: "failure", + text: thread.session.lastError ?? "T3 failed while processing this request.", + cause: settledWithoutTurn, + }, + } as const; + } + + return { turn: "missing" } as const; + } + + // A row without a turn id is the pending-start placeholder; T3 assigns one when the provider adopts the turn. + if (turn.turnId === null || turn.state === "pending" || turn.state === "running") { + return { turn: "active" } as const; + } + + // Every reply from here on came out of this turn. + const coordinates: NTBS.TurnCoordinates = { + threadId: state.t3.threadId, + userMessageId: state.t3.userMessageId, + turnId: turn.turnId, + }; + + // Only a settled turn needs the thread detail: the reply text lives in its messages. + const maybeThread = yield* loadThreadDetail; + + if (Option.isNone(maybeThread)) { + // The turn settled but its thread is gone. An observed fact, not a lookup error: retrying cannot bring the thread back, so it becomes a failure reply. + return { + turn: "completed", + reply: { + type: "failure", + text: "T3 finished, but its thread could no longer be found.", + cause: { type: "settled", ...coordinates }, + }, + } as const; + } + + const thread = maybeThread.value; + + switch (turn.state) { + case "completed": { + const assistantMessage = + turn.assistantMessageId === null + ? undefined + : thread.messages.find((message) => message.id === turn.assistantMessageId); + const text = assistantMessage?.text.trim() ?? ""; + + return { + turn: "completed", + reply: + text.length > 0 + ? ({ type: "answer", text, ...coordinates } as const) + : ({ + type: "failure", + text: "T3 completed without producing a response.", + cause: { type: "settled", ...coordinates }, + } as const), + } as const; + } + + case "error": + return { + turn: "completed", + reply: { + type: "failure", + text: thread.session?.lastError ?? "T3 failed while processing this request.", + cause: { type: "settled", ...coordinates }, + }, + } as const; + + case "interrupted": + return { + turn: "completed", + reply: { + type: "cancellation", + text: "T3 stopped processing this request.", + ...coordinates, + }, + } as const; + } + }); + + const startTurn = ( + state: NTBS.ThreadCreated, + ): Effect.Effect => + Effect.gen(function* () { + const commandId = CommandId.make(yield* randomUUID); + const createdAt = yield* getNow; + + yield* orchestrationEngine + .dispatch( + OrchestrationCommand.make({ + type: "thread.turn.start", + commandId, + threadId: state.t3.threadId, + message: { + messageId: state.t3.userMessageId, + role: "user", + text: state.snapshot, + attachments: state.attachments, + }, + runtimeMode: "full-access", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + createdAt, + }), + ) + .pipe( + /* + Verdict vs accident. An invariant error is the decider rejecting the command against current state (thread deleted, queue full): deterministic, retrying re-asks a question already answered, so it is fatal and becomes a failure reply. + Everything else is infrastructure failing before any verdict; the transaction rolled back, nothing committed, and asking again later is meaningful. + Judgment call: "queue full" is an invariant that time can heal (the queue drains when the active turn completes), but a full queue on an NTBS-owned thread means something else is hammering it, and a visible failure beats silently retrying into it. + */ + Effect.mapError((cause) => + cause._tag === "OrchestrationCommandInvariantError" + ? new FatalError({ + method: "orchestrationEngine.dispatch", + reason: "T3 rejected the turn start for thread " + state.t3.threadId, + cause, + }) + : new RetryableError({ + method: "orchestrationEngine.dispatch", + reason: "Could not dispatch thread.turn.start for thread " + state.t3.threadId, + cause, + }), + ), + ); + }); + + /* + This forwards the events that can change what the gateway's status queries answer about a thread, so its consumers are only signalled about changes that may require further action. + + The filter has to move with those queries: when one of them starts reading a different field, the events that write it belong here, or a consumer sees the change only on its next sweep. + + Ordinary activity appends change nothing the queries answer, but `context-compaction` and `provider.turn.start.failed` do, because both delete the pending turn start. Streaming deltas are `thread.message-sent` with `streaming: true`: the bulk of a live turn, and none of them change what the queries answer before the turn settles. + */ + const threadActivity = orchestrationEngine.streamDomainEvents.pipe( + Stream.filterMap((event) => { + if (event.aggregateKind !== "thread") { + return Result.failVoid; + } + + const threadId = event.aggregateId as ThreadId; // safe to cast as filtered the aggregate + + switch (event.type) { + case "thread.created": + case "thread.deleted": + case "thread.turn-start-requested": + case "thread.turn-interrupt-requested": + case "thread.turn-diff-completed": + case "thread.session-set": + case "thread.messages-resynced": + case "thread.reverted": + return Result.succeed(threadId); + + case "thread.message-sent": + return event.payload.streaming ? Result.failVoid : Result.succeed(threadId); + + case "thread.activity-appended": { + const kind = event.payload.activity.kind; + return kind === "context-compaction" || kind === "provider.turn.start.failed" + ? Result.succeed(threadId) + : Result.failVoid; + } + + default: + return Result.failVoid; + } + }), + ); + + /** + * Creates the actual thread in T3 with the recorded claimed request. + * + */ + const provisionThread = ( + state: NTBS.WorkPlanned, + ): Effect.Effect => + Effect.gen(function* () { + /* + * In order we need to: + * 1. get the actual project details, where is the workspace root path located at? + * 2. Find an existing checkout for the planned branch, or ask Git to create one. + * 3. Dispatch T3 thread creation with the path Git returned. + * 4. Run the scripts for that project. + */ + + /* + `provisionThread` is a resumable checklist, not a transaction. + + Every attempt re-derives its *facts* from live project and Git state, then walks three steps, each one "check, then do", so a retry after any interruption skips whatever already happened. + + **Worktree**. If the directory exists, reuse it. If only the branch survives from a crashed attempt, recreate the checkout from that branch instead of re-branching from the start commit. Otherwise create it fresh from the pinned commit. + + **Thread**. Create it. If the dispatch fails but the thread turns out to exist, a stale observation raced us and the step is already done. + + **Setup scripts**. Failure to launch setup is fatal; script completion is not tracked by T3. + + On a retryable failure, cleanup nothing. The half-finished work is owned by the exchange record and is exactly what the next reconcile pass resumes from. + + On a fatal failure, delete a thread created by this attempt before removing its worktree. If deletion fails, keep the worktree so the surviving thread still has a directory. A thread found during recovery and its worktree belong to an earlier attempt and are left intact. The branch ref is left behind. + */ + // We refetch because the project details we had from `planCoordinates` might have changed, the project might've been deleted, etc + const project = yield* getProject(state.t3.projectId); + const modelSelection = + project.defaultModelSelection ?? + (yield* serverSettings.getSettings.pipe( + orFail("retryable")( + "serverSettings.getSettings", + "Could not load the default model for thread " + state.t3.threadId, + ), + )).defaultModelSelection; + + if (modelSelection === null) { + return yield* new FatalError({ + method: "provisionThread", + reason: + "No default model is configured for this project or server. Set a model in project or machine settings and submit the request again.", + cause: null, + }); + } + + const { workspaceRoot } = project; + + const worktreePath = yield* ensureWorktree({ + workspaceRoot, + worktreeBranchName: state.t3.worktreeBranchName, + startCommitSha: state.t3.startCommitSha, + startBranchName: state.t3.startBranchName, + }); + + let threadCreationState: "not-created" | "created" | "recovered" = "not-created"; + + yield* Effect.gen(function* () { + const commandId = CommandId.make(yield* randomUUID); + const createdAt = yield* getNow; + + yield* orchestrationEngine + .dispatch( + OrchestrationCommand.make({ + type: "thread.create", + branch: state.t3.worktreeBranchName, + worktreePath: worktreePath, + threadId: state.t3.threadId, + // T3 generates the real title after the first turn starts. + title: DEFAULT_THREAD_TITLE, + modelSelection: modelSelection, + commandId, + createdAt, + projectId: project.id, + runtimeMode: "full-access", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + }), + ) + .pipe( + Effect.tap(() => { + threadCreationState = "created"; + return Effect.void; + }), + /* + A previous attempt may have created the thread before crashing. + If the thread exists after a failed dispatch, this step is already + done. A failed lookup is not evidence that it is absent. + */ + Effect.catch((cause) => + projectionSnapshotQuery.getThreadShellById(state.t3.threadId).pipe( + Effect.catch((lookupCause) => + Effect.fail( + new RetryableError({ + method: "projectionSnapshotQuery.getThreadShellById", + reason: + "Could not determine whether thread " + + state.t3.threadId + + " was created", + cause: lookupCause, + }), + ), + ), + Effect.map(Option.isSome), + Effect.flatMap((threadExists) => + threadExists + ? Effect.sync(() => { + threadCreationState = "recovered"; + }) + : Effect.fail( + // TODO: `OrchestrationCommandInvariantError` does not expose + // which invariant failed. Treat it as fatal for now, but T3 + // needs a structured rejection reason before NTBS can distinguish + // a missing project from other rejected create attempts. + cause._tag === "OrchestrationCommandInvariantError" + ? new FatalError({ + method: "orchestrationEngine.dispatch", + reason: + "T3 rejected thread creation for thread " + state.t3.threadId, + cause, + }) + : new RetryableError({ + method: "orchestrationEngine.dispatch", + reason: + "Could not dispatch thread.create for thread " + + state.t3.threadId, + cause, + }), + ), + ), + ), + ), + ); + + /* + Failure to launch setup is fatal to provisioning. Once launched, setup + may still be running or fail later; T3 does not report its completion. + NTBS follows that behavior. + TODO: Revisit if T3 exposes setup completion. + */ + yield* projectScriptRunner + .runForThread({ + threadId: state.t3.threadId, + projectId: project.id, + projectCwd: project.workspaceRoot, + worktreePath, + }) + .pipe( + orFail("fatal")( + "projectScriptRunner.runForThread", + "Failed to launch setup while provisioning thread", + ), + ); + }).pipe( + Effect.tapError((error) => { + if (error._tag !== "FatalError" || threadCreationState === "recovered") { + return Effect.void; + } + + return Effect.gen(function* () { + if (threadCreationState === "created") { + yield* orchestrationEngine.dispatch( + OrchestrationCommand.make({ + type: "thread.delete", + commandId: CommandId.make(yield* randomUUID), + threadId: state.t3.threadId, + }), + ); + } + + yield* gitWorkflowService.removeWorktree({ + cwd: workspaceRoot, + path: worktreePath, + force: true, + }); + }).pipe( + Effect.catch((cause) => + Effect.logWarning("Failed to clean up NTBS thread provisioning", { + threadId: state.t3.threadId, + worktreePath, + cause, + }), + ), + ); + }), + ); + }); + + return { + planCoordinates, + getThreadStatus, + provisionThread, + getTurnStatus, + startTurn, + threadActivity, + }; + }, +); + +export const t3GatewayLive = Layer.effect(T3Gateway, T3GatewayLive); diff --git a/apps/server/src/observability/Metrics.ts b/apps/server/src/observability/Metrics.ts index 886833d6e2c7..a09179cbab21 100644 --- a/apps/server/src/observability/Metrics.ts +++ b/apps/server/src/observability/Metrics.ts @@ -50,6 +50,10 @@ export const providerTurnsTotal = Metric.counter("t3_provider_turns_total", { description: "Total provider turn lifecycle operations.", }); +export const providerTurnRecoveriesTotal = Metric.counter("t3_provider_turn_recoveries_total", { + description: "Total provider turn restart-recovery candidates and outcomes.", +}); + export const providerTurnDuration = Metric.timer("t3_provider_turn_duration", { description: "Provider turn request duration.", }); diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts index b88f7f012d46..7b2a124f17d7 100644 --- a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts +++ b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts @@ -119,6 +119,7 @@ function createProviderServiceHarness( sendTurn: () => unsupported(), compactThread: () => unsupported(), interruptTurn: () => unsupported(), + compactSession: () => unsupported(), respondToRequest: () => unsupported(), respondToUserInput: () => unsupported(), stopSession: () => unsupported(), diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts index 6d062ebcab4b..f4eed1ad0d3b 100644 --- a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts +++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts @@ -130,6 +130,76 @@ const hasMetricSnapshot = ( ); describe("OrchestrationEngine", () => { + it("keeps a thread worktree path when stale metadata tries to clear it", async () => { + const system = await createOrchestrationSystem(); + const projectId = asProjectId("project-worktree-sticky"); + const threadId = ThreadId.make("thread-worktree-sticky"); + const worktreePath = "/tmp/project-worktree/.t3/worktrees/demo"; + + await system.run( + system.engine.dispatch({ + type: "project.create", + commandId: CommandId.make("cmd-worktree-sticky-project"), + projectId, + title: "Worktree Sticky", + workspaceRoot: "/tmp/project-worktree", + defaultModelSelection: { + instanceId: ProviderInstanceId.make("opencode"), + model: "opencode-go/glm-5.2", + }, + createdAt: now(), + }), + ); + await system.run( + system.engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-worktree-sticky-thread"), + threadId, + projectId, + title: "Worktree sticky thread", + modelSelection: { + instanceId: ProviderInstanceId.make("opencode"), + model: "opencode-go/glm-5.2", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "full-access", + branch: "t3code/demo", + worktreePath, + createdAt: now(), + }), + ); + await system.run( + system.engine.dispatch({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-worktree-sticky-turn"), + threadId, + runtimeMode: "full-access", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + message: { + messageId: asMessageId("msg-worktree-sticky"), + role: "user", + text: "what directory are you in?", + attachments: [], + }, + createdAt: now(), + }), + ); + await system.run( + system.engine.dispatch({ + type: "thread.meta.update", + commandId: CommandId.make("cmd-worktree-sticky-stale-clear"), + threadId, + branch: "main", + worktreePath: null, + }), + ); + + const thread = (await system.readModel()).threads.find((entry) => entry.id === threadId); + expect(thread?.branch).toBe("main"); + expect(thread?.worktreePath).toBe(worktreePath); + await system.dispose(); + }); + it.each(["running", "stopped"] as const)( "sends async answers with a %s session and rejects old duplicate replies", async (status) => { @@ -397,6 +467,8 @@ describe("OrchestrationEngine", () => { settledAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -409,6 +481,8 @@ describe("OrchestrationEngine", () => { threads: projectionSnapshot.threads.map((thread) => ({ ...thread, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -453,9 +527,12 @@ describe("OrchestrationEngine", () => { getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), getThreadDetailById: () => Effect.succeed(Option.none()), getThreadDetailSnapshot: () => Effect.succeed(Option.none()), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.succeed(Option.none()), }), ), Layer.provide( @@ -841,6 +918,7 @@ describe("OrchestrationEngine", () => { threadId: ThreadId.make("thread-archive"), requestId: CommandId.make("cmd-thread-archive-title-regeneration"), title: "Stale generated title", + createdAt: now(), }), ); expect( diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.ts index fb2fadde5e63..e1c58af5fa91 100644 --- a/apps/server/src/orchestration/Layers/OrchestrationEngine.ts +++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.ts @@ -14,6 +14,7 @@ import * as Deferred from "effect/Deferred"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; +import * as HashMap from "effect/HashMap"; import * as Layer from "effect/Layer"; import * as Metric from "effect/Metric"; import * as Option from "effect/Option"; @@ -40,8 +41,14 @@ import { type OrchestrationDispatchError, type OrchestrationProjectorDecodeError, } from "../Errors.ts"; +import { + createEmptyCommandReadModel, + findThreadById, + fromWireReadModel, + type CommandReadModel, +} from "../commandReadModel.ts"; import { decideOrchestrationCommand } from "../decider.ts"; -import { createEmptyReadModel, projectEvent } from "../projector.ts"; +import { projectEvent } from "../projector.ts"; import { OrchestrationProjectionPipeline } from "../Services/ProjectionPipeline.ts"; import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; import { ThreadBackgroundLivenessService } from "../ThreadBackgroundLiveness.ts"; @@ -91,15 +98,15 @@ const makeOrchestrationEngine = Effect.gen(function* () { const crypto = yield* Crypto.Crypto; const nowIso = Effect.map(DateTime.now, DateTime.formatIso); - let commandReadModel = createEmptyReadModel(yield* nowIso); + let commandReadModel: CommandReadModel = createEmptyCommandReadModel(yield* nowIso); const commandQueue = yield* Queue.unbounded(); const eventPubSub = yield* PubSub.unbounded(); const projectEventsOntoReadModel = ( - baseReadModel: OrchestrationReadModel, + baseReadModel: CommandReadModel, events: ReadonlyArray, - ): Effect.Effect => + ): Effect.Effect => Effect.gen(function* () { let nextReadModel = baseReadModel; for (const event of events) { @@ -219,18 +226,20 @@ const makeOrchestrationEngine = Effect.gen(function* () { envelope.command.linkedPullRequest !== undefined ) { const threadId = envelope.command.threadId; - const thread = commandReadModel.threads.find((thread) => thread.id === threadId); + const thread = findThreadById(commandReadModel, threadId); if (thread !== undefined) { const project = yield* projectionSnapshotQuery.getProjectShellById(thread.projectId); if (Option.isSome(project)) { - commandReadModel = { - ...commandReadModel, - projects: commandReadModel.projects.map((entry) => - entry.id === thread.projectId - ? { ...entry, repositoryIdentity: project.value.repositoryIdentity } - : entry, - ), - }; + const existing = HashMap.get(commandReadModel.projects, thread.projectId); + if (Option.isSome(existing)) { + commandReadModel = { + ...commandReadModel, + projects: HashMap.set(commandReadModel.projects, thread.projectId, { + ...existing.value, + repositoryIdentity: project.value.repositoryIdentity, + }), + }; + } } } } @@ -411,12 +420,21 @@ const makeOrchestrationEngine = Effect.gen(function* () { }; yield* projectionPipeline.bootstrap; - commandReadModel = yield* projectionSnapshotQuery.getCommandReadModel(); + // Seed the in-memory command model from the DB projection. Deleted threads + // are dropped so the model starts consistent with the projector's eviction + // policy (see commandReadModel.ts / the `thread.deleted` projector branch). + commandReadModel = fromWireReadModel(yield* projectionSnapshotQuery.getCommandReadModel(), { + dropDeletedThreads: true, + }); const worker = Effect.forever(Queue.take(commandQueue).pipe(Effect.flatMap(processEnvelope))); yield* Effect.forkScoped(worker); yield* Effect.logDebug("orchestration engine started").pipe( - Effect.annotateLogs({ sequence: commandReadModel.snapshotSequence }), + Effect.annotateLogs({ + sequence: commandReadModel.snapshotSequence, + threadCount: HashMap.size(commandReadModel.threads), + projectCount: HashMap.size(commandReadModel.projects), + }), ); const readEvents: OrchestrationEngineShape["readEvents"] = (fromSequenceExclusive, limit) => diff --git a/apps/server/src/orchestration/Layers/OrphanSessionRecovery.test.ts b/apps/server/src/orchestration/Layers/OrphanSessionRecovery.test.ts new file mode 100644 index 000000000000..032999f8c545 --- /dev/null +++ b/apps/server/src/orchestration/Layers/OrphanSessionRecovery.test.ts @@ -0,0 +1,23 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { shouldSettleAfterServerRestart } from "./OrphanSessionRecovery.ts"; + +describe("OrphanSessionRecovery", () => { + it("gives a live auto-woken provider process precedence over orphan settlement", () => { + expect( + shouldSettleAfterServerRestart({ + claimsLive: true, + hasLiveProcess: true, + }), + ).toBe(false); + }); + + it("settles a persisted live claim when no provider process exists", () => { + expect( + shouldSettleAfterServerRestart({ + claimsLive: true, + hasLiveProcess: false, + }), + ).toBe(true); + }); +}); diff --git a/apps/server/src/orchestration/Layers/OrphanSessionRecovery.ts b/apps/server/src/orchestration/Layers/OrphanSessionRecovery.ts new file mode 100644 index 000000000000..66612d67b02e --- /dev/null +++ b/apps/server/src/orchestration/Layers/OrphanSessionRecovery.ts @@ -0,0 +1,314 @@ +import { + CommandId, + DEFAULT_RUNTIME_MODE, + type OrchestrationSession, + type ThreadId, +} from "@t3tools/contracts"; +import { + resolveOrphanSettleSessionStatus, + sessionHadInProgressWork, +} from "@t3tools/shared/sessionWake"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; + +import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; +import { + OrphanSessionRecovery, + type OrphanSessionRecoveryReason, + type OrphanSessionRecoveryShape, +} from "../Services/OrphanSessionRecovery.ts"; +import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; +import { ProviderService } from "../../provider/Services/ProviderService.ts"; +import { ProviderSessionDirectory } from "../../provider/Services/ProviderSessionDirectory.ts"; + +function isLiveClaimingSessionStatus( + status: OrchestrationSession["status"] | undefined | null, +): boolean { + return status === "starting" || status === "running"; +} + +export function shouldSettleAfterServerRestart(input: { + readonly claimsLive: boolean; + readonly hasLiveProcess: boolean; +}): boolean { + return input.claimsLive && !input.hasLiveProcess; +} + +function inProgressWorkFromShell( + shell: + | { + readonly session?: { + readonly activeTurnId?: string | null; + } | null; + readonly latestTurn?: { readonly state?: string | null } | null; + readonly hasPendingApprovals?: boolean; + readonly hasPendingUserInput?: boolean; + } + | null + | undefined, +): boolean { + if (shell === null || shell === undefined) return false; + return sessionHadInProgressWork({ + activeTurnId: shell.session?.activeTurnId ?? null, + latestTurnState: shell.latestTurn?.state ?? null, + hasPendingApprovals: shell.hasPendingApprovals === true, + hasPendingUserInput: shell.hasPendingUserInput === true, + }); +} + +const make = Effect.gen(function* () { + const orchestrationEngine = yield* OrchestrationEngineService; + const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; + const providerService = yield* ProviderService; + const directory = yield* ProviderSessionDirectory; + const crypto = yield* Crypto.Crypto; + + const hasLiveProcess: OrphanSessionRecoveryShape["hasLiveProcess"] = (threadId) => + providerService.listSessions().pipe( + Effect.map((sessions) => + sessions.some((session) => String(session.threadId) === String(threadId)), + ), + Effect.orElseSucceed(() => false), + ); + + const markRuntimeStopped = (threadId: ThreadId) => + directory.getBinding(threadId).pipe( + Effect.flatMap((binding) => { + if (Option.isNone(binding)) { + return Effect.void; + } + const current = binding.value; + if (current.status === "stopped") { + return Effect.void; + } + return directory.upsert({ + threadId: current.threadId, + provider: current.provider, + ...(current.providerInstanceId !== undefined + ? { providerInstanceId: current.providerInstanceId } + : {}), + ...(current.adapterKey !== undefined ? { adapterKey: current.adapterKey } : {}), + status: "stopped", + ...(current.resumeCursor !== undefined ? { resumeCursor: current.resumeCursor } : {}), + runtimePayload: { + ...(typeof current.runtimePayload === "object" && + current.runtimePayload !== null && + !Array.isArray(current.runtimePayload) + ? (current.runtimePayload as Record) + : {}), + activeTurnId: null, + lastError: "Recovered orphan provider runtime.", + }, + ...(current.runtimeMode !== undefined ? { runtimeMode: current.runtimeMode } : {}), + }); + }), + Effect.catch(() => Effect.void), + ); + + const settleThread: OrphanSessionRecoveryShape["settleThread"] = (input) => + Effect.gen(function* () { + const now = DateTime.formatIso(yield* DateTime.now); + // Callers may pass interrupted/stopped; still demote to ready when nothing + // was actually in progress so zombie "running" sessions do not Wake Required. + const shellForDecision = yield* projectionSnapshotQuery + .getThreadShellById(input.threadId) + .pipe( + Effect.map(Option.getOrUndefined), + Effect.orElseSucceed(() => undefined), + ); + const preferred = input.status ?? "interrupted"; + const hadInProgressWork = inProgressWorkFromShell(shellForDecision); + const status = + preferred === "ready" + ? "ready" + : resolveOrphanSettleSessionStatus({ + hadInProgressWork, + preferredWhenInProgress: preferred === "stopped" ? "stopped" : "interrupted", + }); + + // Best-effort: stop any live process and clear the runtime binding. + yield* providerService + .stopSession({ threadId: input.threadId }) + .pipe(Effect.catch(() => markRuntimeStopped(input.threadId))); + // stopSession no-ops when there is no binding/process — still force runtime. + yield* markRuntimeStopped(input.threadId); + + const shell = shellForDecision; + const previous = shell?.session ?? null; + const session: OrchestrationSession = { + threadId: input.threadId, + status, + providerName: previous?.providerName ?? null, + ...(previous?.providerInstanceId !== undefined + ? { providerInstanceId: previous.providerInstanceId } + : {}), + runtimeMode: previous?.runtimeMode ?? DEFAULT_RUNTIME_MODE, + activeTurnId: null, + lastError: + status === "interrupted" + ? `Recovered orphan session (${input.reason}). Send a follow-up to resume.` + : status === "ready" + ? null + : (previous?.lastError ?? null), + updatedAt: now, + }; + + const commandId = yield* crypto.randomUUIDv4.pipe( + Effect.orElseSucceed(() => `orphan-settle-${input.threadId}-${now}`), + ); + yield* orchestrationEngine + .dispatch({ + type: "thread.session.set", + commandId: CommandId.make(commandId), + threadId: input.threadId, + session, + createdAt: now, + }) + .pipe( + Effect.catch((cause) => + Effect.logWarning("orphan session settle dispatch failed", { + threadId: input.threadId, + reason: input.reason, + cause, + }), + ), + ); + + yield* Effect.logWarning("settled orphan provider session", { + threadId: input.threadId, + reason: input.reason, + status, + }); + }); + + const settleIfOrphan: OrphanSessionRecoveryShape["settleIfOrphan"] = ( + threadId, + reason: OrphanSessionRecoveryReason = "resync_zombie_running", + ) => + Effect.gen(function* () { + if (yield* hasLiveProcess(threadId)) { + return false; + } + + const shell = yield* projectionSnapshotQuery.getThreadShellById(threadId).pipe( + Effect.map(Option.getOrUndefined), + Effect.orElseSucceed(() => undefined), + ); + const binding = yield* directory.getBinding(threadId).pipe( + Effect.map(Option.getOrUndefined), + Effect.orElseSucceed(() => undefined), + ); + + const sessionStatus = shell?.session?.status; + const hasActiveTurn = shell?.session?.activeTurnId != null; + const runtimeClaimsLive = binding?.status === "running" || binding?.status === "starting"; + + if (!isLiveClaimingSessionStatus(sessionStatus) && !hasActiveTurn && !runtimeClaimsLive) { + return false; + } + + // settleThread demotes to ready when nothing was in progress. + yield* settleThread({ + threadId, + reason, + status: "interrupted", + }); + return true; + }); + + const settleAllAfterServerRestart: OrphanSessionRecoveryShape["settleAllAfterServerRestart"] = + () => + Effect.gen(function* () { + const snapshot = yield* projectionSnapshotQuery + .getShellSnapshot() + .pipe(Effect.orElseSucceed(() => ({ threads: [] as const }))); + const bindings = yield* directory.listBindings().pipe(Effect.orElseSucceed(() => [])); + const threadIds = new Set(); + + let settledSessions = 0; + let interruptedSessions = 0; + for (const thread of snapshot.threads) { + const claimsLive = isLiveClaimingSessionStatus(thread.session?.status); + const processIsLive = claimsLive ? yield* hasLiveProcess(thread.id) : false; + // A replacement process started after boot (for example #9167 + // continuation) is live — never classify that as an orphan. + if ( + !shouldSettleAfterServerRestart({ + claimsLive, + hasLiveProcess: processIsLive, + }) + ) { + continue; + } + const hadInProgressWork = inProgressWorkFromShell(thread); + const status = resolveOrphanSettleSessionStatus({ hadInProgressWork }); + yield* settleThread({ + threadId: thread.id, + reason: "server_restart", + status, + }); + threadIds.add(String(thread.id)); + settledSessions += 1; + if (status === "interrupted") interruptedSessions += 1; + } + + let settledRuntimes = 0; + for (const binding of bindings) { + const claimsLive = binding.status === "running" || binding.status === "starting"; + if (!claimsLive) { + continue; + } + if (threadIds.has(String(binding.threadId))) { + // Already settled with the shell session above. + settledRuntimes += 1; + continue; + } + if ( + !shouldSettleAfterServerRestart({ + claimsLive, + hasLiveProcess: yield* hasLiveProcess(binding.threadId), + }) + ) { + continue; + } + // Runtime claims live without a matching shell running session — + // clear the binding. Only Wake Required when shell still shows work. + const shell = yield* projectionSnapshotQuery.getThreadShellById(binding.threadId).pipe( + Effect.map(Option.getOrUndefined), + Effect.orElseSucceed(() => undefined), + ); + const status = resolveOrphanSettleSessionStatus({ + hadInProgressWork: inProgressWorkFromShell(shell), + }); + yield* settleThread({ + threadId: binding.threadId, + reason: "server_restart", + status, + }); + settledRuntimes += 1; + } + + if (settledSessions > 0 || settledRuntimes > 0) { + yield* Effect.logInfo("orphan settle after server restart", { + settledSessions, + interruptedSessions, + readyOnlySessions: Math.max(0, settledSessions - interruptedSessions), + settledRuntimes, + }); + } + + return { settledSessions, settledRuntimes }; + }); + + return { + hasLiveProcess, + settleThread, + settleIfOrphan, + settleAllAfterServerRestart, + } satisfies OrphanSessionRecoveryShape; +}); + +export const OrphanSessionRecoveryLive = Layer.effect(OrphanSessionRecovery, make); diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts index a038a5662169..c9dc2a54e465 100644 --- a/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts +++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts @@ -620,6 +620,138 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => { ); }); +it.layer( + Layer.fresh(makeProjectionPipelinePrefixedTestLayer("t3-projection-streaming-shell-summary-")), +)("OrchestrationProjectionPipeline", (it) => { + it.effect("does not rescan thread shell history for streaming assistant messages", () => + Effect.gen(function* () { + const projectionPipeline = yield* OrchestrationProjectionPipeline; + const eventStore = yield* OrchestrationEventStore; + const sql = yield* SqlClient.SqlClient; + const threadId = ThreadId.make("thread-streaming-shell-summary"); + const messageId = MessageId.make("message-streaming-shell-summary"); + const createdAt = "2026-01-01T00:00:00.000Z"; + const deltaAt = "2026-01-01T00:00:01.000Z"; + const appendAndProject = (event: Parameters[0]) => + eventStore + .append(event) + .pipe(Effect.flatMap((savedEvent) => projectionPipeline.projectEvent(savedEvent))); + + yield* appendAndProject({ + type: "project.created", + eventId: EventId.make("evt-streaming-shell-summary-1"), + aggregateKind: "project", + aggregateId: ProjectId.make("project-streaming-shell-summary"), + occurredAt: createdAt, + commandId: CommandId.make("cmd-streaming-shell-summary-1"), + causationEventId: null, + correlationId: CorrelationId.make("cmd-streaming-shell-summary-1"), + metadata: {}, + payload: { + projectId: ProjectId.make("project-streaming-shell-summary"), + title: "Streaming shell summary", + workspaceRoot: "/tmp/project-streaming-shell-summary", + defaultModelSelection: null, + scripts: [], + createdAt, + updatedAt: createdAt, + }, + }); + + yield* appendAndProject({ + type: "thread.created", + eventId: EventId.make("evt-streaming-shell-summary-2"), + aggregateKind: "thread", + aggregateId: threadId, + occurredAt: createdAt, + commandId: CommandId.make("cmd-streaming-shell-summary-2"), + causationEventId: null, + correlationId: CorrelationId.make("cmd-streaming-shell-summary-2"), + metadata: {}, + payload: { + threadId, + projectId: ProjectId.make("project-streaming-shell-summary"), + title: "Streaming shell summary", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + runtimeMode: "full-access", + branch: null, + worktreePath: null, + createdAt, + updatedAt: createdAt, + }, + }); + + // A streaming assistant delta must not read activity history. This invalid + // sentinel makes any accidental list/decode deterministic and immediately red. + yield* sql` + INSERT INTO projection_thread_activities ( + activity_id, + thread_id, + turn_id, + tone, + kind, + summary, + payload_json, + sequence, + created_at + ) VALUES ( + 'activity-streaming-shell-summary', + ${threadId}, + NULL, + 'info', + 'test.sentinel', + 'must not be decoded', + '{', + NULL, + ${createdAt} + ) + `; + + yield* appendAndProject({ + type: "thread.message-sent", + eventId: EventId.make("evt-streaming-shell-summary-3"), + aggregateKind: "thread", + aggregateId: threadId, + occurredAt: deltaAt, + commandId: CommandId.make("cmd-streaming-shell-summary-3"), + causationEventId: null, + correlationId: CorrelationId.make("cmd-streaming-shell-summary-3"), + metadata: {}, + payload: { + threadId, + messageId, + role: "assistant", + text: "delta", + turnId: null, + streaming: true, + createdAt, + updatedAt: deltaAt, + }, + }); + + const messageRows = yield* sql<{ + readonly text: string; + readonly isStreaming: number; + }>` + SELECT text, is_streaming AS "isStreaming" + FROM projection_thread_messages + WHERE message_id = ${messageId} + `; + assert.deepEqual(messageRows, [{ text: "delta", isStreaming: 1 }]); + + const threadRows = yield* sql<{ readonly updatedAt: string }>` + SELECT updated_at AS "updatedAt" + FROM projection_threads + WHERE thread_id = ${threadId} + `; + assert.deepEqual(threadRows, [{ updatedAt: deltaAt }]); + }), + ); +}); + it.layer(Layer.fresh(makeProjectionPipelinePrefixedTestLayer("t3-base-")))( "OrchestrationProjectionPipeline", (it) => { diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts index e303e7323729..8818d08e6745 100644 --- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts +++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts @@ -36,6 +36,7 @@ import { type ProjectionThreadProposedPlan, ProjectionThreadProposedPlanRepository, } from "../../persistence/Services/ProjectionThreadProposedPlans.ts"; +import { ProjectionQueuedMessageRepository } from "../../persistence/Services/ProjectionQueuedMessages.ts"; import * as ProjectionThreadPullRequests from "../../persistence/ProjectionThreadPullRequests.ts"; import { ProjectionThreadSessionRepository } from "../../persistence/Services/ProjectionThreadSessions.ts"; import { @@ -49,10 +50,12 @@ import { ProjectionStateRepositoryLive } from "../../persistence/Layers/Projecti import { ProjectionThreadActivityRepositoryLive } from "../../persistence/Layers/ProjectionThreadActivities.ts"; import { ProjectionThreadMessageRepositoryLive } from "../../persistence/Layers/ProjectionThreadMessages.ts"; import { ProjectionThreadProposedPlanRepositoryLive } from "../../persistence/Layers/ProjectionThreadProposedPlans.ts"; +import { ProjectionQueuedMessageRepositoryLive } from "../../persistence/Layers/ProjectionQueuedMessages.ts"; import { ProjectionThreadSessionRepositoryLive } from "../../persistence/Layers/ProjectionThreadSessions.ts"; import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts"; import { ProjectionThreadRepositoryLive } from "../../persistence/Layers/ProjectionThreads.ts"; import { ServerConfig } from "../../config.ts"; +import * as PrLookupFreeze from "../../git/PrLookupFreeze.ts"; import { OrchestrationProjectionPipeline, type OrchestrationProjectionPipelineShape, @@ -68,6 +71,7 @@ export const ORCHESTRATION_PROJECTOR_NAMES = { projects: "projection.projects", threads: "projection.threads", threadMessages: "projection.thread-messages", + queuedMessages: "projection.queued-messages", threadProposedPlans: "projection.thread-proposed-plans", threadActivities: "projection.thread-activities", threadSessions: "projection.thread-sessions", @@ -338,7 +342,7 @@ const decodeQuestionAttachmentAnswer = Schema.decodeUnknownOption(UserInputAttac function collectThreadAttachmentRelativePaths( threadId: string, - messages: ReadonlyArray, + messages: ReadonlyArray>, ): Set { const threadSegment = toSafeThreadAttachmentSegment(threadId); if (!threadSegment) { @@ -485,6 +489,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti const projectionThreadRepository = yield* ProjectionThreadRepository; const projectionThreadMessageRepository = yield* ProjectionThreadMessageRepository; const projectionThreadProposedPlanRepository = yield* ProjectionThreadProposedPlanRepository; + const projectionQueuedMessageRepository = yield* ProjectionQueuedMessageRepository; const projectionThreadPullRequestRepository = yield* ProjectionThreadPullRequests.ProjectionThreadPullRequestRepository; const projectionThreadActivityRepository = yield* ProjectionThreadActivityRepository; @@ -495,6 +500,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti const fileSystem = yield* FileSystem.FileSystem; const path = yield* Path.Path; const serverConfig = yield* ServerConfig; + const prLookupFreeze = yield* PrLookupFreeze.PrLookupFreeze; const applyProjectsProjection: ProjectorDefinition["apply"] = Effect.fn( "applyProjectsProjection", @@ -579,16 +585,84 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti return; } - const [latestUserMessageAt, hasActionableProposedPlan, activities, pendingApprovalCount] = - yield* Effect.all([ - projectionThreadMessageRepository.getLatestUserMessageAt({ threadId }), - projectionThreadProposedPlanRepository.hasActionableByThreadId({ - threadId, - latestTurnId: existingRow.value.latestTurnId, - }), - projectionThreadActivityRepository.listUserInputLifecycleByThreadId({ threadId }), - projectionPendingApprovalRepository.countPendingByThreadId({ threadId }), - ]); + // Keep origin/participants rebuild from user messages (fork). Activities + // and pending approvals use the cheaper SQLite-filtered queries from + // upstream so a long-running thread's tool payloads stay off the heap. + // latestUserMessageAt is a dedicated query so summary refresh does not + // decode message bodies (#9662). If attachments_json is corrupt, keep + // the existing origin/participants instead of failing the refresh. + const [ + latestUserMessageAt, + hasActionableProposedPlan, + activities, + pendingApprovalCount, + messages, + ] = yield* Effect.all([ + projectionThreadMessageRepository.getLatestUserMessageAt({ threadId }), + projectionThreadProposedPlanRepository.hasActionableByThreadId({ + threadId, + latestTurnId: existingRow.value.latestTurnId, + }), + projectionThreadActivityRepository.listUserInputLifecycleByThreadId({ threadId }), + projectionPendingApprovalRepository.countPendingByThreadId({ threadId }), + projectionThreadMessageRepository + .listByThreadId({ threadId }) + .pipe(Effect.orElseSucceed(() => [] as const)), + ]); + + // Rebuild origin + participants from projected user messages so shell stays + // consistent after resync/replay (not only first-write stamps). + type ParticipantRow = NonNullable<(typeof existingRow.value)["participantSummaries"]>[number]; + const rebuiltParticipants: Array = []; + let rebuiltOrigin = existingRow.value.originSource ?? null; + for (const message of messages) { + if (message.role !== "user" || message.source === undefined) { + continue; + } + if (rebuiltOrigin === null || rebuiltOrigin === undefined) { + rebuiltOrigin = message.source; + } + if (message.source.personId !== undefined && message.source.username !== undefined) { + const personId = message.source.personId; + const existingParticipantIndex = rebuiltParticipants.findIndex( + (entry) => entry.personId === personId, + ); + if (existingParticipantIndex === -1) { + rebuiltParticipants.push({ + personId, + username: message.source.username, + firstChannel: message.source.channel, + channels: [message.source.channel], + firstParticipatedAt: message.createdAt, + }); + } else { + const existingParticipant = rebuiltParticipants[existingParticipantIndex]!; + if (!existingParticipant.channels?.includes(message.source.channel)) { + rebuiltParticipants[existingParticipantIndex] = { + ...existingParticipant, + channels: [ + ...(existingParticipant.channels ?? + (existingParticipant.firstChannel === undefined + ? [] + : [existingParticipant.firstChannel])), + message.source.channel, + ], + }; + } + } + } + } + // Origin person first when present. + if (rebuiltOrigin?.personId !== undefined) { + const originId = rebuiltOrigin.personId; + rebuiltParticipants.sort((left, right) => { + if (left.personId === originId) return -1; + if (right.personId === originId) return 1; + return left.firstParticipatedAt.localeCompare(right.firstParticipatedAt); + }); + } + const originSource = rebuiltOrigin; + const participantSummaries = rebuiltParticipants; const pendingUserInputCount = derivePendingUserInputCountFromActivities(activities); @@ -598,6 +672,8 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti pendingApprovalCount, pendingUserInputCount, hasActionableProposedPlan: hasActionableProposedPlan ? 1 : 0, + originSource: originSource ?? null, + participantSummaries, }); }); @@ -682,6 +758,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti if (Option.isNone(existingRow)) { return; } + const wasSettled = existingRow.value.settledOverride === "settled"; yield* projectionThreadRepository.upsert({ ...existingRow.value, settledOverride: "settled", @@ -690,6 +767,10 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti activeOrderKey: null, updatedAt: event.payload.updatedAt, }); + // Idempotent re-settles must not double-count freeze interest. + if (!wasSettled) { + yield* prLookupFreeze.noteWorktreeSettled(existingRow.value.worktreePath); + } return; } @@ -700,6 +781,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti if (Option.isNone(existingRow)) { return; } + const wasSettled = existingRow.value.settledOverride === "settled"; yield* projectionThreadRepository.upsert({ ...existingRow.value, settledOverride: event.payload.reason === "user" ? "active" : null, @@ -713,6 +795,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti : event.payload.updatedAt, updatedAt: event.payload.updatedAt, }); + if (wasSettled) { + yield* prLookupFreeze.noteWorktreeUnsettled(existingRow.value.worktreePath); + } return; } @@ -1007,6 +1092,8 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti return; } + case "thread.message-queued": + case "thread.queued-message-removed": case "thread.proposed-plan-upserted": case "thread.activity-appended": case "thread.approval-response-requested": @@ -1034,10 +1121,15 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti if (Option.isNone(existingRow)) { return; } + // Keep the completed turn pointer when the session clears activeTurnId + // (ready/idle/interrupted). Wiping latest_turn_id made response bridges + // that key off latestTurn miss already-finished turns after restart. + const nextLatestTurnId = + event.payload.session.activeTurnId ?? existingRow.value.latestTurnId; yield* projectionThreadRepository.upsert({ ...existingRow.value, // activeTurnId describes current work; a terminal session must not erase history. - latestTurnId: event.payload.session.activeTurnId ?? existingRow.value.latestTurnId, + latestTurnId: nextLatestTurnId, updatedAt: event.occurredAt, }); yield* refreshThreadShellSummary(event.payload.threadId); @@ -1160,12 +1252,69 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti text: nextText, ...(nextAttachments !== undefined ? { attachments: [...nextAttachments] } : {}), isStreaming: false, + ...(event.payload.source !== undefined + ? { source: event.payload.source } + : previousMessage?.source !== undefined + ? { source: previousMessage.source } + : {}), createdAt: previousMessage?.createdAt ?? event.payload.createdAt, updatedAt: event.payload.updatedAt, }); return; } + case "thread.messages-resynced": { + // Rebuild the transcript tail from an authoritative external source. + // Everything up to and including `afterMessageId` is known-good and is + // kept as-is; only what follows is replaced. + const existingRows = yield* projectionThreadMessageRepository.listByThreadId({ + threadId: event.payload.threadId, + }); + const anchorIndex = + event.payload.afterMessageId === null + ? -1 + : existingRows.findIndex((row) => row.messageId === event.payload.afterMessageId); + if (event.payload.afterMessageId !== null && anchorIndex === -1) { + // Anchor is gone (already reverted/pruned): applying the tail would + // graft it onto an unknown prefix, so leave the projection alone. + yield* Effect.logWarning( + "Skipping thread.messages-resynced: anchor message is not in the projection.", + { + threadId: event.payload.threadId, + afterMessageId: event.payload.afterMessageId, + reason: event.payload.reason, + }, + ); + return; + } + const keptRows = existingRows.slice(0, anchorIndex + 1); + const tailRows = event.payload.messages.map( + (message) => + ({ + messageId: message.id, + threadId: event.payload.threadId, + turnId: message.turnId, + role: message.role, + text: message.text, + ...(message.attachments !== undefined ? { attachments: message.attachments } : {}), + isStreaming: message.streaming, + createdAt: message.createdAt, + updatedAt: message.updatedAt, + }) satisfies ProjectionThreadMessage, + ); + yield* projectionThreadMessageRepository.deleteByThreadId({ + threadId: event.payload.threadId, + }); + yield* Effect.forEach( + [...keptRows, ...tailRows], + projectionThreadMessageRepository.upsert, + { + concurrency: 1, + }, + ).pipe(Effect.asVoid); + return; + } + case "thread.reverted": { const existingRows = yield* projectionThreadMessageRepository.listByThreadId({ threadId: event.payload.threadId, @@ -1192,9 +1341,17 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti yield* Effect.forEach(keptRows, projectionThreadMessageRepository.upsert, { concurrency: 1, }).pipe(Effect.asVoid); + // Queued messages survive a revert (they are not part of the + // timeline), so their attachment files must survive pruning too. + const queuedRows = yield* projectionQueuedMessageRepository.listByThreadId({ + threadId: event.payload.threadId, + }); attachmentSideEffects.prunedThreadRelativePaths.set( event.payload.threadId, - collectThreadAttachmentRelativePaths(event.payload.threadId, keptRows), + collectThreadAttachmentRelativePaths(event.payload.threadId, [ + ...keptRows, + ...queuedRows, + ]), ); return; } @@ -1204,6 +1361,67 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti } }); + const applyQueuedMessagesProjection: ProjectorDefinition["apply"] = Effect.fn( + "applyQueuedMessagesProjection", + )(function* (event, attachmentSideEffects) { + switch (event.type) { + case "thread.message-queued": + yield* projectionQueuedMessageRepository.upsert({ + messageId: event.payload.messageId, + threadId: event.payload.threadId, + text: event.payload.text, + attachments: event.payload.attachments, + modelSelection: event.payload.modelSelection ?? null, + sourceProposedPlanThreadId: event.payload.sourceProposedPlan?.threadId ?? null, + sourceProposedPlanId: event.payload.sourceProposedPlan?.planId ?? null, + queuedAt: event.payload.queuedAt, + }); + return; + + case "thread.queued-message-removed": { + // A user removal orphans the removed message's attachment files — + // prune to what the timeline and remaining queue still reference. + // Dispatch removals keep everything: the same attachments re-enter + // the timeline via the paired thread.message-sent. + const removedQueuedMessage = + event.payload.reason === "user" + ? (yield* projectionQueuedMessageRepository.listByThreadId({ + threadId: event.payload.threadId, + })).find((entry) => entry.messageId === event.payload.messageId) + : undefined; + yield* projectionQueuedMessageRepository.deleteByMessageId({ + threadId: event.payload.threadId, + messageId: event.payload.messageId, + }); + if (removedQueuedMessage && (removedQueuedMessage.attachments?.length ?? 0) > 0) { + const retainedMessageRows = yield* projectionThreadMessageRepository.listByThreadId({ + threadId: event.payload.threadId, + }); + const retainedQueuedRows = yield* projectionQueuedMessageRepository.listByThreadId({ + threadId: event.payload.threadId, + }); + attachmentSideEffects.prunedThreadRelativePaths.set( + event.payload.threadId, + collectThreadAttachmentRelativePaths(event.payload.threadId, [ + ...retainedMessageRows, + ...retainedQueuedRows, + ]), + ); + } + return; + } + + case "thread.deleted": + yield* projectionQueuedMessageRepository.deleteByThreadId({ + threadId: event.payload.threadId, + }); + return; + + default: + return; + } + }); + const applyThreadProposedPlansProjection: ProjectorDefinition["apply"] = Effect.fn( "applyThreadProposedPlansProjection", )(function* (event, _attachmentSideEffects) { @@ -1429,6 +1647,18 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti // settle still-running turns so their duration reflects the whole // turn rather than the last assistant message. const settledTurnState = settledTurnStateForSessionStatus(event.payload.session.status); + // Any settled status abandons an unadopted pending turn start — + // including "ready": a mid-turn steer re-arms the pending row + // without a fresh adoption, and a stale row would block queue + // drains (and re-arm the read model's pendingTurnStart flag on + // restart hydration). Ready-with-genuinely-pending starts never + // reach this projection: ingestion maps that shape to + // "starting" before dispatching the session set. + if (settledTurnState !== null) { + yield* projectionTurnRepository.deletePendingTurnStartByThreadId({ + threadId: event.payload.threadId, + }); + } if (settledTurnState === null) { return; } @@ -1912,6 +2142,14 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti name: ORCHESTRATION_PROJECTOR_NAMES.projects, apply: applyProjectsProjection, }, + // queuedMessages must bootstrap before threadMessages: the revert + // handler in threadMessages reads the queued-message projection to + // retain queued attachments, so on replay that table has to be + // populated first or the prune deletes files still referenced. + { + name: ORCHESTRATION_PROJECTOR_NAMES.queuedMessages, + apply: applyQueuedMessagesProjection, + }, { name: ORCHESTRATION_PROJECTOR_NAMES.threadMessages, apply: applyThreadMessagesProjection, @@ -2171,10 +2409,14 @@ export const OrchestrationProjectionPipelineLive = Layer.effect( Layer.provideMerge(ProjectionThreadRepositoryLive), Layer.provideMerge(ProjectionThreadMessageRepositoryLive), Layer.provideMerge(ProjectionThreadProposedPlanRepositoryLive), + Layer.provideMerge(ProjectionQueuedMessageRepositoryLive), Layer.provideMerge(ProjectionThreadPullRequests.layer), Layer.provideMerge(ProjectionThreadActivityRepositoryLive), Layer.provideMerge(ProjectionThreadSessionRepositoryLive), Layer.provideMerge(ProjectionTurnRepositoryLive), Layer.provideMerge(ProjectionPendingApprovalRepositoryLive), Layer.provideMerge(ProjectionStateRepositoryLive), + // Shared with GitManager via the same layer value at the server root + // (PrLookupFreezeLive). Tests that mount this layer alone provide their own. + Layer.provide(PrLookupFreeze.layer), ); diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts index 5849123c55d6..cdc02761aea1 100644 --- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts +++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts @@ -441,6 +441,8 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { updatedAt: "2026-02-24T00:00:05.000Z", }, ], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [ { id: "plan-1", @@ -463,6 +465,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { createdAt: "2026-02-24T00:00:06.000Z", }, ], + hasMoreActivities: false, checkpoints: [ { turnId: asTurnId("turn-1"), @@ -683,6 +686,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { assert.deepEqual(context.value, { id: ThreadId.make("thread-1"), title: "Thread 1", + interactionMode: snapshot.threads[0]?.interactionMode, session: snapshot.threads[0]?.session, }); } @@ -993,6 +997,245 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { }), ); + it.effect("resolves session stop context for archived threads but not deleted ones", () => + Effect.gen(function* () { + const snapshotQuery = yield* ProjectionSnapshotQuery; + const sql = yield* SqlClient.SqlClient; + + yield* sql`DELETE FROM projection_threads`; + yield* sql`DELETE FROM projection_thread_sessions`; + + yield* sql` + INSERT INTO projection_threads ( + thread_id, + project_id, + title, + model_selection_json, + runtime_mode, + interaction_mode, + branch, + worktree_path, + latest_turn_id, + latest_user_message_at, + pending_approval_count, + pending_user_input_count, + has_actionable_proposed_plan, + created_at, + updated_at, + archived_at, + deleted_at + ) + VALUES + ( + 'thread-archived-session', + 'project-stop-test', + 'Archived Thread', + '{"provider":"codex","model":"gpt-5-codex"}', + 'full-access', + 'default', + NULL, + NULL, + NULL, + NULL, + 0, + 0, + 0, + '2026-04-07T00:00:00.000Z', + '2026-04-07T00:00:01.000Z', + '2026-04-07T00:00:02.000Z', + NULL + ), + ( + 'thread-deleted-session', + 'project-stop-test', + 'Deleted Thread', + '{"provider":"codex","model":"gpt-5-codex"}', + 'full-access', + 'default', + NULL, + NULL, + NULL, + NULL, + 0, + 0, + 0, + '2026-04-07T00:00:00.000Z', + '2026-04-07T00:00:01.000Z', + NULL, + '2026-04-07T00:00:03.000Z' + ) + `; + + yield* sql` + INSERT INTO projection_thread_sessions ( + thread_id, + status, + provider_name, + provider_session_id, + provider_thread_id, + runtime_mode, + active_turn_id, + last_error, + updated_at + ) + VALUES ( + 'thread-archived-session', + 'running', + 'codex', + 'provider-session-stop', + 'provider-thread-stop', + 'full-access', + NULL, + NULL, + '2026-04-07T00:00:04.000Z' + ) + `; + + // The archived, nondeleted thread must resolve so the archive flow's + // session stop can still find it. + const archivedContext = yield* snapshotQuery.getSessionStopContextById( + ThreadId.make("thread-archived-session"), + ); + assert.isTrue(archivedContext._tag === "Some"); + if (archivedContext._tag === "Some") { + assert.equal(archivedContext.value.threadId, ThreadId.make("thread-archived-session")); + assert.equal(archivedContext.value.session?.status, "running"); + assert.equal(archivedContext.value.session?.providerName, "codex"); + } + + const deletedContext = yield* snapshotQuery.getSessionStopContextById( + ThreadId.make("thread-deleted-session"), + ); + assert.isTrue(deletedContext._tag === "None"); + + const archivedWithoutSession = yield* sql` + DELETE FROM projection_thread_sessions + `.pipe( + Effect.flatMap(() => + snapshotQuery.getSessionStopContextById(ThreadId.make("thread-archived-session")), + ), + ); + assert.isTrue( + archivedWithoutSession._tag === "Some" && archivedWithoutSession.value.session === null, + ); + }), + ); + + it.effect("reads thread lifecycle markers regardless of deleted/archived state", () => + Effect.gen(function* () { + const snapshotQuery = yield* ProjectionSnapshotQuery; + const sql = yield* SqlClient.SqlClient; + + yield* sql`DELETE FROM projection_threads`; + + yield* sql` + INSERT INTO projection_threads ( + thread_id, + project_id, + title, + model_selection_json, + runtime_mode, + interaction_mode, + branch, + worktree_path, + latest_turn_id, + latest_user_message_at, + pending_approval_count, + pending_user_input_count, + has_actionable_proposed_plan, + created_at, + updated_at, + archived_at, + deleted_at + ) + VALUES + ( + 'thread-lifecycle-active', + 'project-lifecycle-test', + 'Active Thread', + '{"provider":"codex","model":"gpt-5-codex"}', + 'full-access', + 'default', + NULL, + NULL, + NULL, + NULL, + 0, + 0, + 0, + '2026-04-06T00:00:02.000Z', + '2026-04-06T00:00:03.000Z', + NULL, + NULL + ), + ( + 'thread-lifecycle-archived', + 'project-lifecycle-test', + 'Archived Thread', + '{"provider":"codex","model":"gpt-5-codex"}', + 'full-access', + 'default', + NULL, + NULL, + NULL, + NULL, + 0, + 0, + 0, + '2026-04-06T00:00:04.000Z', + '2026-04-06T00:00:05.000Z', + '2026-04-06T00:00:06.000Z', + NULL + ), + ( + 'thread-lifecycle-deleted', + 'project-lifecycle-test', + 'Deleted Thread', + '{"provider":"codex","model":"gpt-5-codex"}', + 'full-access', + 'default', + NULL, + NULL, + NULL, + NULL, + 0, + 0, + 0, + '2026-04-06T00:00:07.000Z', + '2026-04-06T00:00:08.000Z', + NULL, + '2026-04-06T00:00:09.000Z' + ) + `; + + const active = yield* snapshotQuery.getThreadLifecycleById( + ThreadId.make("thread-lifecycle-active"), + ); + assert.deepEqual(active, Option.some({ deletedAt: null, archivedAt: null })); + + const archived = yield* snapshotQuery.getThreadLifecycleById( + ThreadId.make("thread-lifecycle-archived"), + ); + assert.deepEqual( + archived, + Option.some({ deletedAt: null, archivedAt: "2026-04-06T00:00:06.000Z" }), + ); + + const deleted = yield* snapshotQuery.getThreadLifecycleById( + ThreadId.make("thread-lifecycle-deleted"), + ); + assert.deepEqual( + deleted, + Option.some({ deletedAt: "2026-04-06T00:00:09.000Z", archivedAt: null }), + ); + + const missing = yield* snapshotQuery.getThreadLifecycleById( + ThreadId.make("thread-lifecycle-missing"), + ); + assert.deepEqual(missing, Option.none()); + }), + ); + it.effect("keeps settled threads in the shell snapshot with non-null settlement fields", () => Effect.gen(function* () { const snapshotQuery = yield* ProjectionSnapshotQuery; @@ -1560,6 +1803,8 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { assert.equal(threadDetail._tag, "Some"); if (threadDetail._tag === "Some") { assert.deepEqual(threadDetail.value.activities, snapshot.threads[0]?.activities ?? []); + // Well under the window — nothing older to lazy-load. + assert.equal(threadDetail.value.hasMoreActivities, false); } assert.deepEqual(snapshot.threads[0]?.activities ?? [], [ @@ -1739,6 +1984,254 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { }), ); + it.effect( + "windows thread-detail activities to the most recent 500 and pages older on demand", + () => + Effect.gen(function* () { + const snapshotQuery = yield* ProjectionSnapshotQuery; + const sql = yield* SqlClient.SqlClient; + + yield* sql`DELETE FROM projection_projects`; + yield* sql`DELETE FROM projection_threads`; + yield* sql`DELETE FROM projection_thread_activities`; + yield* sql`DELETE FROM projection_state`; + + yield* sql` + INSERT INTO projection_projects ( + project_id, title, workspace_root, default_model_selection_json, + scripts_json, created_at, updated_at, deleted_at + ) + VALUES ( + 'project-1', 'Project 1', '/tmp/project-1', + '{"provider":"codex","model":"gpt-5-codex"}', '[]', + '2026-04-01T00:00:00.000Z', '2026-04-01T00:00:01.000Z', NULL + ) + `; + + yield* sql` + INSERT INTO projection_threads ( + thread_id, project_id, title, model_selection_json, runtime_mode, + interaction_mode, branch, worktree_path, latest_turn_id, + latest_user_message_at, pending_approval_count, pending_user_input_count, + has_actionable_proposed_plan, created_at, updated_at, archived_at, deleted_at + ) + VALUES ( + 'thread-1', 'project-1', 'Thread 1', + '{"provider":"codex","model":"gpt-5-codex"}', 'full-access', 'default', + NULL, NULL, NULL, NULL, 0, 0, 0, + '2026-04-01T00:00:02.000Z', '2026-04-01T00:00:03.000Z', NULL, NULL + ) + `; + + // 600 activities (sequence 1..600); the detail load must return only the + // most recent 500 (sequence 101..600), re-sorted ascending for display. + const total = 600; + yield* Effect.forEach( + Array.from({ length: total }, (_unused, index) => index + 1), + (seq) => + sql` + INSERT INTO projection_thread_activities ( + activity_id, thread_id, turn_id, tone, kind, summary, payload_json, + sequence, created_at + ) + VALUES ( + ${`activity-${String(seq).padStart(4, "0")}`}, 'thread-1', NULL, + 'info', 'runtime.note', ${`act-${seq}`}, '{}', ${seq}, + '2026-04-01T00:01:00.000Z' + ) + `, + { discard: true }, + ); + + const threadDetail = yield* snapshotQuery.getThreadDetailById(ThreadId.make("thread-1")); + assert.equal(threadDetail._tag, "Some"); + if (threadDetail._tag === "Some") { + const activities = threadDetail.value.activities; + assert.equal(activities.length, 500); + assert.equal(activities[0]?.summary, "act-101"); + assert.equal(activities[0]?.sequence, 101); + assert.equal(activities.at(-1)?.summary, "act-600"); + // 600 > window, so the client is told older history can be lazy-loaded. + assert.equal(threadDetail.value.hasMoreActivities, true); + } + + // Lazy-load the page immediately older than the windowed view (cursor = + // oldest loaded sequence, 101): sequences 1..100, ascending, no more left. + const olderPage = yield* snapshotQuery.getThreadActivitiesPage({ + threadId: ThreadId.make("thread-1"), + beforeSequence: 101, + limit: 500, + }); + assert.equal(olderPage.activities.length, 100); + assert.equal(olderPage.activities[0]?.summary, "act-1"); + assert.equal(olderPage.activities.at(-1)?.summary, "act-100"); + assert.equal(olderPage.hasMore, false); + + // A bounded page returns the newest `limit` of the older set and reports + // that more remain (sequences 401..600, with 1..400 still older). + const boundedPage = yield* snapshotQuery.getThreadActivitiesPage({ + threadId: ThreadId.make("thread-1"), + beforeSequence: 601, + limit: 200, + }); + assert.equal(boundedPage.activities.length, 200); + assert.equal(boundedPage.activities[0]?.summary, "act-401"); + assert.equal(boundedPage.activities.at(-1)?.summary, "act-600"); + assert.equal(boundedPage.hasMore, true); + + yield* sql`DELETE FROM projection_thread_activities`; + + // Legacy rows may not have a sequence. They are still windowed in the + // detail load and must remain pageable by the deterministic created/id + // ordering used by the snapshot query. + yield* Effect.forEach( + Array.from({ length: total }, (_unused, index) => index + 1), + (seq) => + sql` + INSERT INTO projection_thread_activities ( + activity_id, thread_id, turn_id, tone, kind, summary, payload_json, + sequence, created_at + ) + VALUES ( + ${`unsequenced-${String(seq).padStart(4, "0")}`}, 'thread-1', NULL, + 'info', 'runtime.note', ${`legacy-act-${seq}`}, '{}', NULL, + '2026-04-01T00:01:00.000Z' + ) + `, + { discard: true }, + ); + + const legacyThreadDetail = yield* snapshotQuery.getThreadDetailById( + ThreadId.make("thread-1"), + ); + assert.equal(legacyThreadDetail._tag, "Some"); + if (legacyThreadDetail._tag === "Some") { + const activities = legacyThreadDetail.value.activities; + assert.equal(activities.length, 500); + assert.equal(activities[0]?.summary, "legacy-act-101"); + assert.equal(activities[0]?.sequence, undefined); + assert.equal(activities.at(-1)?.summary, "legacy-act-600"); + + const legacyOlderPage = yield* snapshotQuery.getThreadActivitiesPage({ + threadId: ThreadId.make("thread-1"), + beforeCreatedAt: activities[0]?.createdAt ?? "2026-04-01T00:01:00.000Z", + beforeActivityId: activities[0]?.id ?? asEventId("unsequenced-0101"), + limit: 500, + }); + assert.equal(legacyOlderPage.activities.length, 100); + assert.equal(legacyOlderPage.activities[0]?.summary, "legacy-act-1"); + assert.equal(legacyOlderPage.activities.at(-1)?.summary, "legacy-act-100"); + assert.equal(legacyOlderPage.hasMore, false); + } + + const legacyBoundedPage = yield* snapshotQuery.getThreadActivitiesPage({ + threadId: ThreadId.make("thread-1"), + beforeCreatedAt: "2026-04-01T00:01:00.000Z", + beforeActivityId: asEventId("unsequenced-0601"), + limit: 200, + }); + assert.equal(legacyBoundedPage.activities.length, 200); + assert.equal(legacyBoundedPage.activities[0]?.summary, "legacy-act-401"); + assert.equal(legacyBoundedPage.activities.at(-1)?.summary, "legacy-act-600"); + assert.equal(legacyBoundedPage.hasMore, true); + }), + ); + + it.effect("unsequenced cursor reaches all older rows without stranding sequenced ones", () => + // Regression for the "unsequenced cursor hides sequenced history" concern: + // sequenced rows always sort newer than NULL-sequence (legacy) rows, so when + // the oldest loaded row is unsequenced every sequenced row is already in the + // window — the `sequence IS NULL` cursor can't strand sequenced rows. + Effect.gen(function* () { + const snapshotQuery = yield* ProjectionSnapshotQuery; + const sql = yield* SqlClient.SqlClient; + yield* sql`DELETE FROM projection_projects`; + yield* sql`DELETE FROM projection_threads`; + yield* sql`DELETE FROM projection_thread_activities`; + yield* sql`DELETE FROM projection_state`; + yield* sql` + INSERT INTO projection_projects ( + project_id, title, workspace_root, default_model_selection_json, + scripts_json, created_at, updated_at, deleted_at + ) VALUES ( + 'project-1', 'Project 1', '/tmp/project-1', + '{"provider":"codex","model":"gpt-5-codex"}', '[]', + '2026-04-01T00:00:00.000Z', '2026-04-01T00:00:01.000Z', NULL + ) + `; + yield* sql` + INSERT INTO projection_threads ( + thread_id, project_id, title, model_selection_json, runtime_mode, + interaction_mode, branch, worktree_path, latest_turn_id, + latest_user_message_at, pending_approval_count, pending_user_input_count, + has_actionable_proposed_plan, created_at, updated_at, archived_at, deleted_at + ) VALUES ( + 'thread-1', 'project-1', 'Thread 1', + '{"provider":"codex","model":"gpt-5-codex"}', 'full-access', 'default', + NULL, NULL, NULL, NULL, 0, 0, 0, + '2026-04-01T00:00:02.000Z', '2026-04-01T00:00:03.000Z', NULL, NULL + ) + `; + // 600 legacy unsequenced rows (older) + 3 sequenced rows (newer). The + // window keeps the 3 sequenced + the most-recent 497 unsequenced, so the + // oldest loaded row is unsequenced and 103 older unsequenced remain. + yield* Effect.forEach( + Array.from({ length: 600 }, (_u, index) => index + 1), + (n) => + sql` + INSERT INTO projection_thread_activities ( + activity_id, thread_id, turn_id, tone, kind, summary, payload_json, + sequence, created_at + ) VALUES ( + ${`unseq-${String(n).padStart(4, "0")}`}, 'thread-1', NULL, + 'info', 'runtime.note', ${`unseq-${n}`}, '{}', NULL, + ${`2026-04-01T00:00:01.${String(n).padStart(3, "0")}Z`} + ) + `, + { discard: true }, + ); + yield* Effect.forEach( + [1, 2, 3], + (seq) => + sql` + INSERT INTO projection_thread_activities ( + activity_id, thread_id, turn_id, tone, kind, summary, payload_json, + sequence, created_at + ) VALUES ( + ${`seq-${seq}`}, 'thread-1', NULL, 'info', 'runtime.note', + ${`seq-${seq}`}, '{}', ${seq}, ${`2026-04-01T09:00:0${seq}.000Z`} + ) + `, + { discard: true }, + ); + + const detail = yield* snapshotQuery.getThreadDetailById(ThreadId.make("thread-1")); + assert.equal(detail._tag, "Some"); + if (detail._tag !== "Some") return; + const windowed = detail.value.activities; + assert.equal(windowed.length, 500); + // Sequenced rows are the newest (end of the ascending window); the oldest + // loaded row is unsequenced — exactly the case the concern is about. + assert.equal(windowed.at(-1)?.summary, "seq-3"); + assert.equal(windowed[0]?.sequence, undefined); + + // The client pages with the unsequenced cursor of the oldest loaded row. + const oldest = windowed[0]; + assert.ok(oldest); + const olderPage = yield* snapshotQuery.getThreadActivitiesPage({ + threadId: ThreadId.make("thread-1"), + beforeCreatedAt: oldest.createdAt, + beforeActivityId: oldest.id, + limit: 500, + }); + // The 103 older unsequenced rows come back, none are sequenced, and no + // sequenced row was stranded (all 3 are already in the window). + assert.equal(olderPage.activities.length, 103); + assert.equal(olderPage.hasMore, false); + assert.ok(olderPage.activities.every((a) => a.sequence === undefined)); + }), + ); + it.effect("uses projection_threads.latest_turn_id for bulk command and shell snapshots", () => Effect.gen(function* () { const snapshotQuery = yield* ProjectionSnapshotQuery; @@ -2092,6 +2585,25 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { NULL, NULL ), + ( + 'thread-split', + 'project-search', + 'Split answer thread', + '{"provider":"codex","model":"gpt-5-codex"}', + 'full-access', + 'default', + NULL, + NULL, + NULL, + NULL, + 0, + 0, + 0, + '2026-05-01T00:00:04.000Z', + '2026-05-01T00:00:05.000Z', + NULL, + NULL + ), ( 'thread-percent-decoy', 'project-search', @@ -2189,11 +2701,21 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { 'thread-active', 'turn-active', 'assistant', - 'Interim needle must not be searchable.', + 'Interim needle from an earlier segment of the same answer.', 0, '2026-05-01T00:00:14.000Z', '2026-05-01T00:00:14.000Z' ), + ( + 'message-split', + 'thread-split', + 'turn-split', + 'assistant', + 'Second half of a split answer mentioning halfmarker once.', + 0, + '2026-05-01T00:00:18.000Z', + '2026-05-01T00:00:18.000Z' + ), ( 'message-system', 'thread-active', @@ -2260,9 +2782,19 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { [[ThreadId.make("thread-active"), "user"]], ); + // An answer streamed as several assistant items is searchable in every + // part, not only the one the turn names as its terminal message. + const interim = yield* snapshotQuery.searchThreads({ query: "interim needle" }); assert.deepStrictEqual( - (yield* snapshotQuery.searchThreads({ query: "interim needle" })).matches, - [], + interim.matches.map((match) => [match.threadId, match.source]), + [[ThreadId.make("thread-active"), "assistant"]], + ); + + // A split answer whose matching half is not the turn's assistant_message_id. + const split = yield* snapshotQuery.searchThreads({ query: "halfmarker" }); + assert.deepStrictEqual( + split.matches.map((match) => [match.threadId, match.source]), + [[ThreadId.make("thread-split"), "assistant"]], ); assert.deepStrictEqual( (yield* snapshotQuery.searchThreads({ query: "system needle" })).matches, diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts index 066c60760ca5..c38ce91724f2 100644 --- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts +++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts @@ -3,6 +3,7 @@ import { ApprovalRequestId, ChatAttachment, CheckpointRef, + EventId, IsoDateTime, MessageId, NonNegativeInt, @@ -21,14 +22,17 @@ import { type OrchestrationMessage, type OrchestrationProjectShell, type OrchestrationProposedPlan, + type OrchestrationQueuedMessage, type OrchestrationProject, type OrchestrationSession, type OrchestrationThreadActivity, type OrchestrationThreadShell, ModelSelection, ProjectId, + SourceRef, ThreadLinkedPullRequest, ThreadId, + ThreadParticipantSummary, ThreadPullRequestSnapshot, ThreadPullRequestStack, type ThreadPullRequestLink, @@ -58,6 +62,7 @@ import { ProjectionState } from "../../persistence/Services/ProjectionState.ts"; import { ProjectionThreadActivity } from "../../persistence/Services/ProjectionThreadActivities.ts"; import { ProjectionThreadMessage } from "../../persistence/Services/ProjectionThreadMessages.ts"; import { ProjectionThreadProposedPlan } from "../../persistence/Services/ProjectionThreadProposedPlans.ts"; +import { ProjectionQueuedMessage } from "../../persistence/Services/ProjectionQueuedMessages.ts"; import { ProjectionThreadPullRequest } from "../../persistence/ProjectionThreadPullRequests.ts"; import { ProjectionThreadSession } from "../../persistence/Services/ProjectionThreadSessions.ts"; import { ProjectionThread } from "../../persistence/Services/ProjectionThreads.ts"; @@ -72,6 +77,7 @@ import { ProjectionSnapshotQuery, type ProjectionEventReplayStats, type ProjectionFullThreadDiffContext, + type ProjectionSessionStopContext, type ProjectionSnapshotCounts, type ProjectionThreadCheckpointContext, type ProjectionThreadDetailQuery, @@ -111,12 +117,19 @@ const ProjectionThreadMessageDbRowSchema = ProjectionThreadMessage.mapFields( Struct.assign({ isStreaming: Schema.Number, attachments: Schema.NullOr(Schema.fromJsonString(Schema.Array(ChatAttachment))), + source: Schema.NullOr(Schema.fromJsonString(Schema.NullOr(SourceRef))), }), ); const ProjectionTurnStartMessageDbRowSchema = ProjectionThreadMessageDbRowSchema.mapFields( Struct.assign({ hasOtherUserMessages: Schema.Number }), ); const ProjectionThreadProposedPlanDbRowSchema = ProjectionThreadProposedPlan; +const ProjectionQueuedMessageDbRowSchema = ProjectionQueuedMessage.mapFields( + Struct.assign({ + attachments: Schema.fromJsonString(Schema.Array(ChatAttachment)), + modelSelection: Schema.NullOr(Schema.fromJsonString(ModelSelection)), + }), +); const ProjectionThreadPullRequestDbRowSchema = ProjectionThreadPullRequest.mapFields( Struct.assign({ snapshot: Schema.NullOr(Schema.fromJsonString(ThreadPullRequestSnapshot)), @@ -126,6 +139,11 @@ const ProjectionThreadPullRequestDbRowSchema = ProjectionThreadPullRequest.mapFi const ProjectionThreadDbRowSchema = ProjectionThread.mapFields( Struct.assign({ modelSelection: Schema.fromJsonString(ModelSelection), + // JSON columns may be SQL NULL or the string "null" from JSON.stringify(null). + originSource: Schema.NullOr(Schema.fromJsonString(Schema.NullOr(SourceRef))), + participantSummaries: Schema.NullOr( + Schema.fromJsonString(Schema.NullOr(Schema.Array(ThreadParticipantSummary))), + ), linkedPullRequest: Schema.NullOr(Schema.fromJsonString(ThreadLinkedPullRequest)), branchPullRequest: Schema.NullOr(Schema.fromJsonString(ThreadLinkedPullRequest)), }), @@ -143,6 +161,7 @@ const ProjectionThreadSessionDbRowSchema = ProjectionThreadSession; const ProjectionThreadRuntimeContextDbRowSchema = Schema.Struct({ id: ThreadId, title: Schema.String, + interactionMode: ProjectionThread.fields.interactionMode, session: Schema.NullOr(ProjectionThreadSessionDbRowSchema), }); const ProjectionCheckpointDbRowSchema = ProjectionCheckpoint.mapFields( @@ -239,6 +258,33 @@ const ThreadTurnRangeLookupInput = Schema.Struct({ beforeAnchorAt: Schema.String, beforeTurnKey: Schema.String, }); +/** + * Maximum number of most-recent activities loaded into a thread-detail snapshot. + * Bounds peak memory when opening a long-lived thread; older activities are + * fetched on demand and live ones stream in via events. Retained for the + * getThreadActivities RPC, which deployed mobile clients still call; current + * clients use the windowed snapshot loader instead. + */ +const THREAD_DETAIL_ACTIVITY_WINDOW = 500; + +// `beforeSequence`/`limit` are NonNegativeInt (not bare Number) to match the +// contract: the WHERE clause `(sequence < beforeSequence OR sequence IS NULL)` +// is only equivalent to the old `COALESCE(sequence, -1) < beforeSequence` when +// `beforeSequence` is non-negative — a negative cursor would silently match no +// sequenced rows and return only unsequenced ones. Validating here (not just at +// the RPC boundary) keeps any future non-RPC caller honest. +const ThreadActivitiesBeforeSequenceInput = Schema.Struct({ + threadId: ThreadId, + beforeSequence: NonNegativeInt, + limit: NonNegativeInt, +}); +const ThreadActivitiesBeforeActivityInput = Schema.Struct({ + threadId: ThreadId, + beforeCreatedAt: IsoDateTime, + beforeActivityId: EventId, + limit: NonNegativeInt, +}); + const ProjectionProjectLookupRowSchema = ProjectionProjectDbRowSchema; const ProjectionThreadIdLookupRowSchema = Schema.Struct({ threadId: ThreadId, @@ -472,6 +518,26 @@ function mapThreadActivityRow( }; } +function mapQueuedMessageRow( + row: Schema.Schema.Type, +): OrchestrationQueuedMessage { + return { + messageId: row.messageId, + text: row.text, + attachments: row.attachments, + ...(row.modelSelection !== null ? { modelSelection: row.modelSelection } : {}), + ...(row.sourceProposedPlanThreadId !== null && row.sourceProposedPlanId !== null + ? { + sourceProposedPlan: { + threadId: row.sourceProposedPlanThreadId, + planId: row.sourceProposedPlanId, + }, + } + : {}), + queuedAt: row.queuedAt, + }; +} + function toPersistenceSqlOrDecodeError(sqlOperation: string, decodeOperation: string) { return (cause: unknown): ProjectionRepositoryError => Schema.isSchemaError(cause) @@ -574,7 +640,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { pending_approval_count AS "pendingApprovalCount", pending_user_input_count AS "pendingUserInputCount", has_actionable_proposed_plan AS "hasActionableProposedPlan", - deleted_at AS "deletedAt" + deleted_at AS "deletedAt", + origin_source_json AS "originSource", + participant_summaries_json AS "participantSummaries" FROM projection_threads ORDER BY created_at ASC, thread_id ASC `, @@ -614,7 +682,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { pending_approval_count AS "pendingApprovalCount", pending_user_input_count AS "pendingUserInputCount", has_actionable_proposed_plan AS "hasActionableProposedPlan", - deleted_at AS "deletedAt" + deleted_at AS "deletedAt", + origin_source_json AS "originSource", + participant_summaries_json AS "participantSummaries" FROM projection_threads WHERE deleted_at IS NULL AND archived_at IS NULL @@ -656,7 +726,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { pending_approval_count AS "pendingApprovalCount", pending_user_input_count AS "pendingUserInputCount", has_actionable_proposed_plan AS "hasActionableProposedPlan", - deleted_at AS "deletedAt" + deleted_at AS "deletedAt", + origin_source_json AS "originSource", + participant_summaries_json AS "participantSummaries" FROM projection_threads WHERE deleted_at IS NULL AND archived_at IS NOT NULL @@ -677,6 +749,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { text, attachments_json AS "attachments", is_streaming AS "isStreaming", + source_json AS "source", created_at AS "createdAt", updated_at AS "updatedAt" FROM projection_thread_messages @@ -703,6 +776,45 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + const listQueuedMessageRows = SqlSchema.findAll({ + Request: Schema.Void, + Result: ProjectionQueuedMessageDbRowSchema, + execute: () => + sql` + SELECT + message_id AS "messageId", + thread_id AS "threadId", + text, + attachments_json AS "attachments", + model_selection_json AS "modelSelection", + source_proposed_plan_thread_id AS "sourceProposedPlanThreadId", + source_proposed_plan_id AS "sourceProposedPlanId", + queued_at AS "queuedAt" + FROM projection_queued_messages + ORDER BY thread_id ASC, rowid ASC + `, + }); + + const listQueuedMessageRowsByThread = SqlSchema.findAll({ + Request: ThreadIdLookupInput, + Result: ProjectionQueuedMessageDbRowSchema, + execute: ({ threadId }) => + sql` + SELECT + message_id AS "messageId", + thread_id AS "threadId", + text, + attachments_json AS "attachments", + model_selection_json AS "modelSelection", + source_proposed_plan_thread_id AS "sourceProposedPlanThreadId", + source_proposed_plan_id AS "sourceProposedPlanId", + queued_at AS "queuedAt" + FROM projection_queued_messages + WHERE thread_id = ${threadId} + ORDER BY rowid ASC + `, + }); + const listThreadPullRequestRows = SqlSchema.findAll({ Request: Schema.Void, Result: ProjectionThreadPullRequestDbRowSchema, @@ -767,8 +879,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { ON threads.thread_id = links.thread_id WHERE threads.deleted_at IS NULL AND threads.archived_at IS NOT NULL - ORDER BY links.thread_id ASC, links.linked_at ASC, links.number ASC - `, + ORDER BY links.thread_id ASC, links.linked_at ASC, links.number ASC `, }); const listThreadActivityRows = SqlSchema.findAll({ @@ -910,6 +1021,50 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + const PendingTurnStartDbRowSchema = Schema.Struct({ + threadId: ThreadId, + messageId: MessageId, + requestedAt: IsoDateTime, + }); + + const getPendingTurnStartRowByThread = SqlSchema.findOneOption({ + Request: ThreadIdLookupInput, + Result: PendingTurnStartDbRowSchema, + execute: ({ threadId }) => + sql` + SELECT + thread_id AS "threadId", + pending_message_id AS "messageId", + requested_at AS "requestedAt" + FROM projection_turns + WHERE thread_id = ${threadId} + AND turn_id IS NULL + AND state = 'pending' + AND pending_message_id IS NOT NULL + AND checkpoint_turn_count IS NULL + ORDER BY requested_at DESC + LIMIT 1 + `, + }); + + const listPendingTurnStartRows = SqlSchema.findAll({ + Request: Schema.Void, + Result: PendingTurnStartDbRowSchema, + execute: () => + sql` + SELECT + thread_id AS "threadId", + pending_message_id AS "messageId", + requested_at AS "requestedAt" + FROM projection_turns + WHERE turn_id IS NULL + AND state = 'pending' + AND pending_message_id IS NOT NULL + AND checkpoint_turn_count IS NULL + ORDER BY thread_id ASC, requested_at DESC + `, + }); + const listActiveLatestTurnRows = SqlSchema.findAll({ Request: Schema.Void, Result: ProjectionLatestTurnDbRowSchema, @@ -1039,17 +1194,15 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { AND threads.archived_at IS NULL AND projects.deleted_at IS NULL AND messages.is_streaming = 0 - AND ( - messages.role = 'user' - OR ( - messages.role = 'assistant' - AND messages.message_id IN ( - SELECT turns.assistant_message_id - FROM projection_turns AS turns - WHERE turns.assistant_message_id IS NOT NULL - ) - ) - ) + -- Every settled message the user actually reads, not just the one + -- assistant row a turn happens to name as its terminal message. + -- Providers stream an answer as many assistant items (~10 per turn + -- and climbing), and only the last is linked as + -- turns.assistant_message_id, so restricting to that link made most + -- assistant text unsearchable. Tool calls are not messages at all -- + -- they live in projection_thread_activities -- so they stay out by + -- construction, and 'system' notices are excluded here. + AND messages.role IN ('user', 'assistant') AND messages.text LIKE ${pattern} ESCAPE '!' ) SELECT @@ -1181,6 +1334,20 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + const getNondeletedThreadIdRowById = SqlSchema.findOneOption({ + Request: ThreadIdLookupInput, + Result: ProjectionThreadIdLookupRowSchema, + execute: ({ threadId }) => + sql` + SELECT + thread_id AS "threadId" + FROM projection_threads + WHERE thread_id = ${threadId} + AND deleted_at IS NULL + LIMIT 1 + `, + }); + const getActiveThreadRowById = SqlSchema.findOneOption({ Request: ThreadIdLookupInput, Result: ProjectionThreadDbRowSchema, @@ -1215,7 +1382,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { pending_approval_count AS "pendingApprovalCount", pending_user_input_count AS "pendingUserInputCount", has_actionable_proposed_plan AS "hasActionableProposedPlan", - deleted_at AS "deletedAt" + deleted_at AS "deletedAt", + origin_source_json AS "originSource", + participant_summaries_json AS "participantSummaries" FROM projection_threads WHERE thread_id = ${threadId} AND deleted_at IS NULL @@ -1224,6 +1393,23 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + const getThreadLifecycleRowById = SqlSchema.findOneOption({ + Request: ThreadIdLookupInput, + Result: Schema.Struct({ + deletedAt: Schema.NullOr(IsoDateTime), + archivedAt: Schema.NullOr(IsoDateTime), + }), + execute: ({ threadId }) => + sql` + SELECT + deleted_at AS "deletedAt", + archived_at AS "archivedAt" + FROM projection_threads + WHERE thread_id = ${threadId} + LIMIT 1 + `, + }); + const getThreadRuntimeContextRow = SqlSchema.findOneOption({ Request: ThreadIdLookupInput, Result: ProjectionThreadRuntimeContextDbRowSchema, @@ -1232,6 +1418,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { SELECT threads.thread_id AS id, threads.title, + threads.interaction_mode AS "interactionMode", sessions.thread_id AS "threadId", sessions.status, sessions.provider_name AS "providerName", @@ -1252,6 +1439,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { rows.map((row) => ({ id: row.id, title: row.title, + interactionMode: row.interactionMode, session: row.threadId === null ? null : row, })), ), @@ -1270,6 +1458,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { text, attachments_json AS "attachments", is_streaming AS "isStreaming", + source_json AS "source", created_at AS "createdAt", updated_at AS "updatedAt", EXISTS ( @@ -1302,6 +1491,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { text, attachments_json AS "attachments", is_streaming AS "isStreaming", + source_json AS "source", created_at AS "createdAt", updated_at AS "updatedAt" FROM projection_thread_messages @@ -1351,6 +1541,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + // The thread-detail timeline loads only the most recent window of activities so a + // long-lived thread (tens of thousands of activities, hundreds of MB of payload) + // can't blow the server heap. New activities still stream in live via the event + // subscription; older history will be fetched on demand once lazy-load lands. + // Select the most recent N (sequence DESC) then re-sort ascending for display. const listThreadActivityRowsByThread = SqlSchema.findAll({ Request: ThreadIdLookupInput, Result: ProjectionThreadActivityDbRowSchema, @@ -1383,7 +1578,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { sequence DESC, created_at DESC, activity_id DESC - LIMIT ${THREAD_DETAIL_ACTIVITY_LIMIT} + -- One extra beyond the window so the caller can report hasMoreActivities. + LIMIT ${THREAD_DETAIL_ACTIVITY_WINDOW + 1} ) AS recent_activities ORDER BY sequence ASC, @@ -1392,6 +1588,81 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + // Older-than-cursor page for lazy-load. Returns rows newest-first (DESC) so a + // simple LIMIT yields the page adjacent to the cursor; the caller reverses to + // ascending. `sequence IS NULL` (legacy unsequenced) rows sort last under + // `sequence DESC` (SQLite orders NULLs last in DESC) — the very oldest — so + // paging eventually reaches them. `beforeSequence` is a NonNegativeInt, so + // `(sequence < beforeSequence OR sequence IS NULL)` is equivalent to the old + // `COALESCE(sequence, -1) < beforeSequence` but lets the + // (thread_id, sequence, created_at, activity_id) index satisfy the ORDER BY + // directly instead of forcing a filesort over the whole thread. + const listThreadActivityRowsBeforeSequence = SqlSchema.findAll({ + Request: ThreadActivitiesBeforeSequenceInput, + Result: ProjectionThreadActivityDbRowSchema, + execute: ({ threadId, beforeSequence, limit }) => + sql` + SELECT + activity_id AS "activityId", + thread_id AS "threadId", + turn_id AS "turnId", + tone, + kind, + summary, + payload_json AS "payload", + sequence, + created_at AS "createdAt" + FROM projection_thread_activities + WHERE thread_id = ${threadId} + AND (sequence < ${beforeSequence} OR sequence IS NULL) + ORDER BY + sequence DESC, + created_at DESC, + activity_id DESC + LIMIT ${limit} + `, + }); + + // Legacy unsequenced (sequence NULL) rows are paged by a (created_at, + // activity_id) cursor. created_at is compared lexicographically as TEXT, which + // equals chronological order only because timestamps are canonical ISO-8601 + // (always UTC `Z`, fixed millisecond precision) — the same invariant every + // `ORDER BY created_at` in this layer (including the detail window above) + // already relies on, so the cursor stays consistent with how rows are + // displayed. activity_id breaks created_at ties; its ordering is arbitrary but + // matches the window's `activity_id` tiebreak, so pages never skip or repeat. + const listUnsequencedThreadActivityRowsBeforeActivity = SqlSchema.findAll({ + Request: ThreadActivitiesBeforeActivityInput, + Result: ProjectionThreadActivityDbRowSchema, + execute: ({ threadId, beforeCreatedAt, beforeActivityId, limit }) => + sql` + SELECT + activity_id AS "activityId", + thread_id AS "threadId", + turn_id AS "turnId", + tone, + kind, + summary, + payload_json AS "payload", + sequence, + created_at AS "createdAt" + FROM projection_thread_activities + WHERE thread_id = ${threadId} + AND sequence IS NULL + AND ( + created_at < ${beforeCreatedAt} + OR ( + created_at = ${beforeCreatedAt} + AND activity_id < ${beforeActivityId} + ) + ) + ORDER BY + created_at DESC, + activity_id DESC + LIMIT ${limit} + `, + }); + const getUserInputActivityRow = SqlSchema.findOneOption({ Request: Schema.Struct({ threadId: ThreadId, requestId: ApprovalRequestId }), Result: ProjectionThreadActivityDbRowSchema, @@ -1438,7 +1709,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { sequence DESC, created_at DESC, activity_id DESC - LIMIT ${THREAD_DETAIL_ACTIVITY_LIMIT} + LIMIT ${THREAD_DETAIL_ACTIVITY_WINDOW + 1} `, }); @@ -1680,6 +1951,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { text, attachments_json AS "attachments", is_streaming AS "isStreaming", + source_json AS "source", created_at AS "createdAt", updated_at AS "updatedAt" FROM projection_thread_messages @@ -1995,6 +2267,22 @@ pending_approval_requests AS ( ), ), ), + listQueuedMessageRows(undefined).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getSnapshot:listQueuedMessages:query", + "ProjectionSnapshotQuery.getSnapshot:listQueuedMessages:decodeRows", + ), + ), + ), + listPendingTurnStartRows(undefined).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getSnapshot:listPendingTurnStarts:query", + "ProjectionSnapshotQuery.getSnapshot:listPendingTurnStarts:decodeRows", + ), + ), + ), listThreadPullRequestRows(undefined).pipe( Effect.mapError( toPersistenceSqlOrDecodeError( @@ -2052,6 +2340,8 @@ pending_approval_requests AS ( threadRows, messageRows, proposedPlanRows, + queuedMessageRows, + pendingTurnStartRows, pullRequestRows, activityRows, sessionRows, @@ -2061,6 +2351,20 @@ pending_approval_requests AS ( ]) => Effect.gen(function* () { const messagesByThread = new Map>(); + const queuedMessagesByThread = new Map>(); + // Rows are ordered requested_at DESC per thread; first wins. + const pendingTurnStartByThread = new Map< + string, + { messageId: MessageId; requestedAt: string } + >(); + for (const row of pendingTurnStartRows) { + if (!pendingTurnStartByThread.has(row.threadId)) { + pendingTurnStartByThread.set(row.threadId, { + messageId: row.messageId, + requestedAt: row.requestedAt, + }); + } + } const proposedPlansByThread = new Map>(); const pullRequestsByThread = groupPullRequestRowsByThread(pullRequestRows); const activitiesByThread = new Map>(); @@ -2090,6 +2394,9 @@ pending_approval_requests AS ( ...(row.attachments !== null ? { attachments: row.attachments } : {}), turnId: row.turnId, streaming: row.isStreaming === 1, + ...(row.source !== null && row.source !== undefined + ? { source: row.source } + : {}), createdAt: row.createdAt, updatedAt: row.updatedAt, }); @@ -2111,19 +2418,17 @@ pending_approval_requests AS ( proposedPlansByThread.set(row.threadId, threadProposedPlans); } + for (const row of queuedMessageRows) { + updatedAt = maxIso(updatedAt, row.queuedAt); + const threadQueuedMessages = queuedMessagesByThread.get(row.threadId) ?? []; + threadQueuedMessages.push(mapQueuedMessageRow(row)); + queuedMessagesByThread.set(row.threadId, threadQueuedMessages); + } + for (const row of activityRows) { updatedAt = maxIso(updatedAt, row.createdAt); const threadActivities = activitiesByThread.get(row.threadId) ?? []; - threadActivities.push({ - id: row.activityId, - tone: row.tone, - kind: row.kind, - summary: row.summary, - payload: row.payload, - turnId: row.turnId, - ...(row.sequence !== null ? { sequence: row.sequence } : {}), - createdAt: row.createdAt, - }); + threadActivities.push(mapThreadActivityRow(row)); activitiesByThread.set(row.threadId, threadActivities); } @@ -2245,10 +2550,20 @@ pending_approval_requests AS ( titleRegeneration: mapTitleRegeneration(row), deletedAt: row.deletedAt, messages: messagesByThread.get(row.threadId) ?? [], + queuedMessages: queuedMessagesByThread.get(row.threadId) ?? [], + pendingTurnStart: pendingTurnStartByThread.get(row.threadId) ?? null, proposedPlans: proposedPlansByThread.get(row.threadId) ?? [], activities: activitiesByThread.get(row.threadId) ?? [], + // The full snapshot is unwindowed, so there is never more to load. + hasMoreActivities: false, checkpoints: checkpointsByThread.get(row.threadId) ?? [], session: sessionsByThread.get(row.threadId) ?? null, + ...(row.originSource !== null && row.originSource !== undefined + ? { originSource: row.originSource } + : {}), + ...(row.participantSummaries !== null && row.participantSummaries !== undefined + ? { participantSummaries: row.participantSummaries } + : {}), })); const snapshot = { @@ -2301,6 +2616,22 @@ pending_approval_requests AS ( ), ), ), + listQueuedMessageRows(undefined).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getCommandReadModel:listQueuedMessages:query", + "ProjectionSnapshotQuery.getCommandReadModel:listQueuedMessages:decodeRows", + ), + ), + ), + listPendingTurnStartRows(undefined).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getCommandReadModel:listPendingTurnStarts:query", + "ProjectionSnapshotQuery.getCommandReadModel:listPendingTurnStarts:decodeRows", + ), + ), + ), listThreadPullRequestRows(undefined).pipe( Effect.mapError( toPersistenceSqlOrDecodeError( @@ -2341,6 +2672,8 @@ pending_approval_requests AS ( projectRows, threadRows, proposedPlanRows, + queuedMessageRows, + pendingTurnStartRows, pullRequestRows, sessionRows, latestTurnRows, @@ -2433,9 +2766,34 @@ pending_approval_requests AS ( latestTurnByThread.set(row.threadId, mapLatestTurn(row)); } const proposedPlansByThread = new Map>(); + const queuedMessagesByThread = new Map>(); + // Rows are ordered requested_at DESC per thread; first wins. + const pendingTurnStartByThread = new Map< + string, + { messageId: MessageId; requestedAt: string } + >(); + for (const row of pendingTurnStartRows) { + if (!pendingTurnStartByThread.has(row.threadId)) { + pendingTurnStartByThread.set(row.threadId, { + messageId: row.messageId, + requestedAt: row.requestedAt, + }); + } + } const pullRequestsByThread = groupPullRequestRowsByThread(pullRequestRows); const sessionByThread = new Map(); + for (let index = 0; index < queuedMessageRows.length; index += 1) { + const row = queuedMessageRows[index]; + if (!row) { + continue; + } + updatedAt = maxIso(updatedAt, row.queuedAt); + const threadQueuedMessages = queuedMessagesByThread.get(row.threadId) ?? []; + threadQueuedMessages.push(mapQueuedMessageRow(row)); + queuedMessagesByThread.set(row.threadId, threadQueuedMessages); + } + for (let index = 0; index < sessionRows.length; index += 1) { const row = sessionRows[index]; if (!row) { @@ -2489,6 +2847,8 @@ pending_approval_requests AS ( titleRegeneration: mapTitleRegeneration(row), deletedAt: row.deletedAt, messages: [], + queuedMessages: queuedMessagesByThread.get(row.threadId) ?? [], + pendingTurnStart: pendingTurnStartByThread.get(row.threadId) ?? null, proposedPlans: proposedPlansByThread.get(row.threadId) ?? [], activities: [], checkpoints: [], @@ -2629,6 +2989,13 @@ pending_approval_requests AS ( row.projectId, repositoryIdentities.get(row.projectId), ), + ...(row.originSource !== null && row.originSource !== undefined + ? { originSource: row.originSource } + : {}), + ...(row.participantSummaries !== null && + row.participantSummaries !== undefined + ? { participantSummaries: row.participantSummaries } + : {}), latestTurn: latestTurnByThread.get(row.threadId) ?? null, createdAt: row.createdAt, updatedAt: row.updatedAt, @@ -2791,6 +3158,12 @@ pending_approval_requests AS ( row.projectId, repositoryIdentities.get(row.projectId), ), + ...(row.originSource !== null && row.originSource !== undefined + ? { originSource: row.originSource } + : {}), + ...(row.participantSummaries !== null && row.participantSummaries !== undefined + ? { participantSummaries: row.participantSummaries } + : {}), latestTurn: latestTurnByThread.get(row.threadId) ?? null, createdAt: row.createdAt, updatedAt: row.updatedAt, @@ -3068,6 +3441,37 @@ pending_approval_requests AS ( }); }); + const getSessionStopContextById: ProjectionSnapshotQueryShape["getSessionStopContextById"] = ( + threadId, + ) => + Effect.gen(function* () { + const threadRow = yield* getNondeletedThreadIdRowById({ threadId }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getSessionStopContextById:getThread:query", + "ProjectionSnapshotQuery.getSessionStopContextById:getThread:decodeRow", + ), + ), + ); + if (Option.isNone(threadRow)) { + return Option.none(); + } + + const sessionRow = yield* getThreadSessionRowByThread({ threadId }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getSessionStopContextById:getSession:query", + "ProjectionSnapshotQuery.getSessionStopContextById:getSession:decodeRow", + ), + ), + ); + + return Option.some({ + threadId: threadRow.value.threadId, + session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null, + }); + }); + const getThreadShellById: ProjectionSnapshotQueryShape["getThreadShellById"] = (threadId) => Effect.gen(function* () { const [threadRow, latestTurnRow, sessionRow, pullRequestRows] = yield* Effect.all([ @@ -3145,6 +3549,13 @@ pending_approval_requests AS ( hasPendingApprovals: threadRow.value.pendingApprovalCount > 0, hasPendingUserInput: threadRow.value.pendingUserInputCount > 0, hasActionableProposedPlan: threadRow.value.hasActionableProposedPlan > 0, + ...(threadRow.value.originSource !== null && threadRow.value.originSource !== undefined + ? { originSource: threadRow.value.originSource } + : {}), + ...(threadRow.value.participantSummaries !== null && + threadRow.value.participantSummaries !== undefined + ? { participantSummaries: threadRow.value.participantSummaries } + : {}), backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness( threadRow.value.threadId, ), @@ -3165,6 +3576,7 @@ pending_approval_requests AS ( return Option.map(context, (row) => ({ id: row.id, title: row.title, + interactionMode: row.interactionMode, session: row.session === null ? null : mapSessionRow(row.session), })); }); @@ -3190,6 +3602,7 @@ pending_approval_requests AS ( createdAt: row.createdAt, updatedAt: row.updatedAt, ...(row.attachments !== null ? { attachments: row.attachments } : {}), + ...(row.source !== null && row.source !== undefined ? { source: row.source } : {}), }, hasOtherUserMessages: row.hasOtherUserMessages === 1, })); @@ -3238,9 +3651,19 @@ pending_approval_requests AS ( ), ), ]); + const hasMoreActivities = + bounds === undefined && activityIdRows.length > THREAD_DETAIL_ACTIVITY_WINDOW; + const windowedActivityIdRows = hasMoreActivities + ? activityIdRows.slice(0, THREAD_DETAIL_ACTIVITY_WINDOW) + : activityIdRows; const activityIds = [ - ...new Set([...activityIdRows, ...pinnedActivityIdRows].map(({ activityId }) => activityId)), + ...new Set( + [...windowedActivityIdRows, ...pinnedActivityIdRows].map(({ activityId }) => activityId), + ), ]; + if (activityIds.length === 0) { + return { activities: [], hasMoreActivities }; + } const activities: OrchestrationThreadActivity[] = []; for ( @@ -3265,12 +3688,15 @@ pending_approval_requests AS ( } } - return activities.toSorted( - (left, right) => - (left.sequence ?? -1) - (right.sequence ?? -1) || - left.createdAt.localeCompare(right.createdAt) || - left.id.localeCompare(right.id), - ); + return { + activities: activities.toSorted( + (left, right) => + (left.sequence ?? -1) - (right.sequence ?? -1) || + left.createdAt.localeCompare(right.createdAt) || + left.id.localeCompare(right.id), + ), + hasMoreActivities, + }; }); const getThreadDetailByIdBounded = ( @@ -3312,30 +3738,54 @@ pending_approval_requests AS ( ) : Effect.succeed([]), ]).pipe( - Effect.map(([activityRows, pinnedActivityRows]) => - [ - ...new Map( - [...activityRows, ...pinnedActivityRows].map( - (row) => [row.activityId, row] as const, - ), - ).values(), - ] - .toSorted( - (left, right) => - (left.sequence ?? -1) - (right.sequence ?? -1) || - left.createdAt.localeCompare(right.createdAt) || - left.activityId.localeCompare(right.activityId), - ) - .map(mapThreadActivityRow), - ), + Effect.map(([activityRows, pinnedActivityRows]) => { + // Legacy unbounded snapshots fetch WINDOW+1 ascending rows; if + // the extra one came back, older activities exist beyond the + // window — drop that oldest row and flag it so deployed clients + // can lazy-load older history via the compat activities-page + // RPC. Turn-windowed snapshots must not be trimmed here: rows + // dropped at this point would be unreachable, because loading + // earlier turns fetches earlier windows, never the middle of + // this one. (Their SQL still caps the read at + // THREAD_DETAIL_ACTIVITY_LIMIT for heap safety, upstream + // #6153; only the very oldest rows of a >500-row turn window + // fall out, and those stay reachable through the + // sequence-cursor activities page.) + const hasMoreActivities = + bounds === undefined && + activityRead.query?.activityKinds === undefined && + activityRows.length > THREAD_DETAIL_ACTIVITY_WINDOW; + const windowedActivityRows = hasMoreActivities + ? activityRows.slice(activityRows.length - THREAD_DETAIL_ACTIVITY_WINDOW) + : activityRows; + return { + activities: [ + ...new Map( + [...windowedActivityRows, ...pinnedActivityRows].map( + (row) => [row.activityId, row] as const, + ), + ).values(), + ] + .toSorted( + (left, right) => + (left.sequence ?? -1) - (right.sequence ?? -1) || + left.createdAt.localeCompare(right.createdAt) || + left.activityId.localeCompare(right.activityId), + ) + .map(mapThreadActivityRow), + hasMoreActivities, + }; + }), ); const [ threadRow, messageRows, proposedPlanRows, + queuedMessageRows, + pendingTurnStartRow, pullRequestRows, - activities, + { activities, hasMoreActivities }, checkpointRows, latestTurnRow, sessionRow, @@ -3367,6 +3817,22 @@ pending_approval_requests AS ( ), ), ), + listQueuedMessageRowsByThread({ threadId }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadDetailById:listQueuedMessages:query", + "ProjectionSnapshotQuery.getThreadDetailById:listQueuedMessages:decodeRows", + ), + ), + ), + getPendingTurnStartRowByThread({ threadId }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadDetailById:getPendingTurnStart:query", + "ProjectionSnapshotQuery.getThreadDetailById:getPendingTurnStart:decodeRow", + ), + ), + ), listThreadPullRequestRowsByThread({ threadId }).pipe( Effect.mapError( toPersistenceSqlOrDecodeError( @@ -3445,6 +3911,7 @@ pending_approval_requests AS ( text: row.text, turnId: row.turnId, streaming: row.isStreaming === 1, + ...(row.source !== null && row.source !== undefined ? { source: row.source } : {}), createdAt: row.createdAt, updatedAt: row.updatedAt, }; @@ -3453,8 +3920,16 @@ pending_approval_requests AS ( } return message; }), + queuedMessages: queuedMessageRows.map(mapQueuedMessageRow), + pendingTurnStart: Option.isSome(pendingTurnStartRow) + ? { + messageId: pendingTurnStartRow.value.messageId, + requestedAt: pendingTurnStartRow.value.requestedAt, + } + : null, proposedPlans: proposedPlanRows.map(mapProposedPlanRow), activities, + hasMoreActivities, checkpoints: checkpointRows.map((row) => ({ turnId: row.turnId, checkpointTurnCount: row.checkpointTurnCount, @@ -3465,6 +3940,13 @@ pending_approval_requests AS ( completedAt: row.completedAt, })), session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null, + ...(threadRow.value.originSource !== null && threadRow.value.originSource !== undefined + ? { originSource: threadRow.value.originSource } + : {}), + ...(threadRow.value.participantSummaries !== null && + threadRow.value.participantSummaries !== undefined + ? { participantSummaries: threadRow.value.participantSummaries } + : {}), }; return Option.some( @@ -3631,7 +4113,54 @@ pending_approval_requests AS ( ), ), ); + const getThreadActivitiesPage: ProjectionSnapshotQueryShape["getThreadActivitiesPage"] = ( + input, + ) => + Effect.gen(function* () { + const limit = Math.min( + Math.max(1, input.limit ?? THREAD_DETAIL_ACTIVITY_WINDOW), + THREAD_DETAIL_ACTIVITY_WINDOW, + ); + // Fetch one extra to detect whether older activities remain. + const rowsEffect = + "beforeSequence" in input + ? listThreadActivityRowsBeforeSequence({ + threadId: input.threadId, + beforeSequence: input.beforeSequence, + limit: limit + 1, + }) + : listUnsequencedThreadActivityRowsBeforeActivity({ + threadId: input.threadId, + beforeCreatedAt: input.beforeCreatedAt, + beforeActivityId: input.beforeActivityId, + limit: limit + 1, + }); + const rows = yield* rowsEffect.pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadActivitiesPage:query", + "ProjectionSnapshotQuery.getThreadActivitiesPage:decodeRows", + ), + ), + ); + const hasMore = rows.length > limit; + // Rows are newest-first; keep the page closest to the cursor, then reverse + // to ascending for display. + const page = (hasMore ? rows.slice(0, limit) : rows).map(mapThreadActivityRow).toReversed(); + return { activities: page, hasMore }; + }); + const getThreadLifecycleById: ProjectionSnapshotQueryShape["getThreadLifecycleById"] = ( + threadId, + ) => + getThreadLifecycleRowById({ threadId }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadLifecycleById:query", + "ProjectionSnapshotQuery.getThreadLifecycleById:decodeRow", + ), + ), + ); return { getCommandReadModel, getUserInputActivity, @@ -3648,11 +4177,14 @@ pending_approval_requests AS ( getImportedAgentSessionSources, getThreadCheckpointContext, getFullThreadDiffContext, + getSessionStopContextById, getThreadShellById, getThreadRuntimeContext, getTurnStartMessage, getThreadDetailById, + getThreadLifecycleById, getThreadDetailSnapshot, + getThreadActivitiesPage, } satisfies ProjectionSnapshotQueryShape; }); diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts index c927e72fe737..5f39ce6ce075 100644 --- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts +++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts @@ -73,6 +73,8 @@ import { ServerSettingsService } from "../../serverSettings.ts"; import { ServerActivation } from "../../serverActivation.ts"; import { VcsStatusBroadcaster } from "../../vcs/VcsStatusBroadcaster.ts"; import * as GitWorkflowService from "../../git/GitWorkflowService.ts"; +import * as IdentityService from "../../identity/IdentityService.ts"; +import type { IdentityMapPerson } from "@t3tools/shared/identityMap"; const asProjectId = (value: string): ProjectId => ProjectId.make(value); const asApprovalRequestId = (value: string): ApprovalRequestId => ApprovalRequestId.make(value); @@ -184,6 +186,7 @@ describe("ProviderCommandReactor", () => { session: ProviderSession, ) => Effect.Effect; readonly tryHandlePromptCommandEffect?: ProviderAuthService["Service"]["tryHandlePromptCommand"]; + readonly identityPeople?: ReadonlyArray; }) { const now = "2026-01-01T00:00:00.000Z"; const baseDir = @@ -356,6 +359,7 @@ describe("ProviderCommandReactor", () => { startSession: startSession as ProviderServiceShape["startSession"], sendTurn: sendTurn as ProviderServiceShape["sendTurn"], compactThread, + compactSession: () => unsupported(), interruptTurn: interruptTurn as ProviderServiceShape["interruptTurn"], respondToRequest: respondToRequest as ProviderServiceShape["respondToRequest"], respondToUserInput: respondToUserInput as ProviderServiceShape["respondToUserInput"], @@ -488,6 +492,7 @@ describe("ProviderCommandReactor", () => { }), ), Layer.provideMerge(ServerSettingsService.layerTest()), + Layer.provideMerge(IdentityService.layerWithPeople(input?.identityPeople ?? [])), Layer.provideMerge(SqlitePersistenceMemory), Layer.provideMerge(ServerConfig.layerTest(process.cwd(), baseDir)), Layer.provideMerge(NodeServices.layer), @@ -589,6 +594,49 @@ describe("ProviderCommandReactor", () => { ); const drain = () => Effect.runPromise(reactor.drain); + // Queue-by-default holds turn.start commands while the session is + // starting/running. The mock provider never emits runtime events, so + // tests that send a follow-up on an idle thread must settle the session + // back to ready first — in production, turn completion does this. + const harnessRuntime = runtime!; + let settleIndex = 0; + const settleSession = async (threadId: ThreadId = ThreadId.make("thread-1")) => { + settleIndex += 1; + const readModel = await harnessRuntime.runPromise(snapshotQuery.getSnapshot()); + const session = readModel.threads.find((entry) => entry.id === threadId)?.session; + if (!session) { + return; + } + await harnessRuntime.runPromise( + engine.dispatch({ + type: "thread.session.set", + commandId: CommandId.make(`cmd-session-run-${settleIndex}`), + threadId, + session: { + ...session, + status: "running", + activeTurnId: asTurnId(`turn-settle-${settleIndex}`), + updatedAt: now, + }, + createdAt: now, + }), + ); + await harnessRuntime.runPromise( + engine.dispatch({ + type: "thread.session.set", + commandId: CommandId.make(`cmd-session-settle-${settleIndex}`), + threadId, + session: { + ...session, + status: "ready", + activeTurnId: null, + updatedAt: now, + }, + createdAt: now, + }), + ); + }; + return { engine, snapshotQuery, @@ -605,6 +653,7 @@ describe("ProviderCommandReactor", () => { }), ), tryHandlePromptCommand, + settleSession, startSession, sendTurn, compactThread, @@ -2686,6 +2735,7 @@ describe("ProviderCommandReactor", () => { ); await waitFor(() => harness.sendTurn.mock.calls.length === 1); + await harness.settleSession(); await Effect.runPromise( harness.engine.dispatch({ @@ -2740,6 +2790,7 @@ describe("ProviderCommandReactor", () => { }); yield* Effect.promise(() => waitFor(() => harness.sendTurn.mock.calls.length === 1)); + yield* Effect.promise(() => harness.settleSession()); yield* harness.engine.dispatch({ type: "thread.turn.start", @@ -2860,6 +2911,7 @@ describe("ProviderCommandReactor", () => { await waitFor(() => harness.startSession.mock.calls.length === 1); await waitFor(() => harness.sendTurn.mock.calls.length === 1); + await harness.settleSession(); await Effect.runPromise( harness.engine.dispatch({ @@ -2909,6 +2961,7 @@ describe("ProviderCommandReactor", () => { ); await waitFor(() => harness.sendTurn.mock.calls.length === 1); + await harness.settleSession(); await Effect.runPromise( harness.engine.dispatch({ @@ -2973,6 +3026,7 @@ describe("ProviderCommandReactor", () => { await waitFor(() => harness.startSession.mock.calls.length === 1); await waitFor(() => harness.sendTurn.mock.calls.length === 1); + await harness.settleSession(); expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({ cwd: "/tmp/provider-project", }); @@ -3051,6 +3105,7 @@ describe("ProviderCommandReactor", () => { await waitFor(() => harness.startSession.mock.calls.length === 1); await waitFor(() => harness.sendTurn.mock.calls.length === 1); + await harness.settleSession(); await Effect.runPromise( harness.engine.dispatch({ @@ -3307,6 +3362,7 @@ describe("ProviderCommandReactor", () => { await waitFor(() => harness.startSession.mock.calls.length === 1); await waitFor(() => harness.sendTurn.mock.calls.length === 1); + await harness.settleSession(); await Effect.runPromise( harness.engine.dispatch({ diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts index 9b125922137c..6cdc70ebedc3 100644 --- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts +++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts @@ -29,9 +29,14 @@ import * as Schedule from "effect/Schedule"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker"; +import { makeKeyedDrainableWorker } from "@t3tools/shared/KeyedDrainableWorker"; import { resolveThreadWorkspaceCwd } from "../../checkpointing/Utils.ts"; -import { increment, orchestrationEventsProcessedTotal } from "../../observability/Metrics.ts"; +import { + increment, + orchestrationEventsProcessedTotal, + providerTurnRecoveriesTotal, +} from "../../observability/Metrics.ts"; import { ProviderAdapterRequestError, ProviderAdapterValidationError, @@ -42,6 +47,8 @@ import { TextGeneration } from "../../textGeneration/TextGeneration.ts"; import { ProviderAuthService } from "../../provider/Services/ProviderAuthService.ts"; import { ProviderService } from "../../provider/Services/ProviderService.ts"; import { ProviderRegistry } from "../../provider/Services/ProviderRegistry.ts"; +import { ProjectionTurnRepository } from "../../persistence/Services/ProjectionTurns.ts"; +import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts"; import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; import { @@ -56,6 +63,10 @@ import { } from "../../serverSettings.ts"; import { VcsStatusBroadcaster } from "../../vcs/VcsStatusBroadcaster.ts"; import { GitWorkflowService } from "../../git/GitWorkflowService.ts"; +import { IdentityService } from "../../identity/IdentityService.ts"; +import { withAgentIdentityAttribution } from "../../identity/agentAttribution.ts"; + +const PROVIDER_CONTROL_TIMEOUT = Duration.seconds(5); const isProviderAdapterRequestError = Schema.is(ProviderAdapterRequestError); const isProviderAdapterValidationError = Schema.is(ProviderAdapterValidationError); const isProviderWorkspaceMissingError = Schema.is(ProviderWorkspaceMissingError); @@ -69,6 +80,7 @@ type ProviderIntentEvent = Extract< | "thread.runtime-mode-set" | "thread.turn-start-requested" | "thread.turn-interrupt-requested" + | "thread.context-compact-requested" | "thread.approval-response-requested" | "thread.user-input-response-requested" | "thread.session-stop-requested" @@ -228,6 +240,7 @@ function formatThreadTitleContext(messages: ReadonlyArray): ], }; } +const STARTUP_RECOVERY_CONCURRENCY = 4; function providerErrorLabel(value: string | undefined): string { const normalized = value?.trim(); @@ -321,6 +334,7 @@ const make = Effect.gen(function* () { const crypto = yield* Crypto.Crypto; const orchestrationEngine = yield* OrchestrationEngineService; const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; + const projectionTurnRepository = yield* ProjectionTurnRepository; const providerAuthService = yield* ProviderAuthService; const providerService = yield* ProviderService; const providerRegistry = yield* ProviderRegistry; @@ -329,6 +343,7 @@ const make = Effect.gen(function* () { const vcsStatusBroadcaster = yield* VcsStatusBroadcaster; const textGeneration = yield* TextGeneration; const serverSettingsService = yield* ServerSettingsService; + const identityService = yield* IdentityService; const serverCommandId = (tag: string) => crypto.randomUUIDv4.pipe(Effect.map((uuid) => CommandId.make(`server:${tag}:${uuid}`))); const serverEventId = () => crypto.randomUUIDv4.pipe(Effect.map(EventId.make)); @@ -337,6 +352,7 @@ const make = Effect.gen(function* () { timeToLive: HANDLED_TURN_START_KEY_TTL, lookup: () => Effect.succeed(true), }); + const startupReconciliationDone = yield* Deferred.make(); const hasHandledTurnStartRecently = (key: string) => Cache.getOption(handledTurnStartKeys, key).pipe( @@ -366,7 +382,9 @@ const make = Effect.gen(function* () { readonly threadId: ThreadId; readonly kind: | "provider.turn.start.failed" + | "provider.turn.recovery.failed" | "provider.turn.interrupt.failed" + | "provider.context.compact.failed" | "provider.approval.respond.failed" | "provider.user-input.respond.failed" | "provider.session.stop.failed"; @@ -526,6 +544,87 @@ const make = Effect.gen(function* () { }); }); + /** + * Abandon a pending turn start that can never adopt (missing user message, + * missing persisted event, etc.). Without this, the SQL pending-start row + + * in-memory `pendingTurnStart` flag stay forever, so every follow-up is + * `message-queued` and the queue never drains (Discord stuck on Working…). + * + * `thread.session.set` with a settled status clears the pending-start flag + * in the event-sourced read model and deletes the pending SQL placeholder + * (see ProjectionPipeline session-set handling). We then attempt a queue + * drain so any messages that piled up while stuck can run. + */ + const abandonUnadoptablePendingTurnStart = Effect.fnUntraced(function* (input: { + readonly threadId: ThreadId; + readonly createdAt: string; + readonly reason: string; + }) { + // Shell has modelSelection/runtimeMode for a missing-session fallback. + // Stop-context is archived-inclusive, so pending-start recovery can still + // settle archived threads that getThreadShellById omits. + const shell = yield* resolveThreadShell(input.threadId); + const thread = shell ?? (yield* resolveThread(input.threadId)); + if (!thread) { + return; + } + const session = thread.session; + // Prefer ready over error: this is an orchestration glitch, not a live + // provider failure. Keep stopped sessions stopped. + const nextStatus = session?.status === "stopped" ? "stopped" : "ready"; + const sessionBase = + session ?? + (shell + ? { + threadId: input.threadId, + providerName: null, + providerInstanceId: shell.modelSelection.instanceId, + runtimeMode: shell.runtimeMode, + } + : null); + if (sessionBase) { + yield* setThreadSession({ + threadId: input.threadId, + session: { + ...sessionBase, + status: nextStatus, + activeTurnId: null, + // Do not sticky-page this internal failure via lastError forever. + lastError: nextStatus === "stopped" ? (session?.lastError ?? null) : null, + updatedAt: input.createdAt, + }, + createdAt: input.createdAt, + }); + } + // Belt-and-suspenders if session was already ready (session-set may no-op + // some paths) — always clear the pending SQL placeholder. + yield* projectionTurnRepository + .deletePendingTurnStartByThreadId({ + threadId: input.threadId, + }) + .pipe(Effect.catch(() => Effect.void)); + + yield* Effect.logWarning("Abandoned unadoptable pending turn start", { + threadId: input.threadId, + reason: input.reason, + }); + + // Drain any follow-ups that queued while the ghost pending start blocked. + // May no-op (empty queue / already busy); next natural completion retries. + yield* serverCommandId("queue-drain-after-abandon").pipe( + Effect.flatMap((commandId) => + orchestrationEngine + .dispatch({ + type: "thread.queue.drain", + commandId, + threadId: input.threadId, + createdAt: input.createdAt, + }) + .pipe(Effect.catchTag("OrchestrationCommandInvariantError", () => Effect.void)), + ), + ); + }); + const restoreCompaction = Effect.fnUntraced(function* (threadId: ThreadId, fromRunning = false) { if (stoppingThreadIds.has(threadId)) { compactingThreadIds.delete(threadId); @@ -615,6 +714,14 @@ const make = Effect.gen(function* () { .pipe(Effect.map(Option.getOrUndefined)); }); + // Archived threads must still be stoppable. Session-stop lookups include + // archived/deleted shells that getThreadShellById omits. + const resolveThread = Effect.fnUntraced(function* (threadId: ThreadId) { + return yield* projectionSnapshotQuery + .getSessionStopContextById(threadId) + .pipe(Effect.map(Option.getOrUndefined)); + }); + const resolveThreadDetail = Effect.fnUntraced(function* (threadId: ThreadId) { return yield* projectionSnapshotQuery .getThreadDetailById(threadId, { activityKinds: [] }) @@ -863,6 +970,22 @@ const make = Effect.gen(function* () { requestedModelSelection !== undefined && !Equal.equals(previousModelSelection, requestedModelSelection); + if ( + cwdChanged && + activeSession?.provider === "opencode" && + activeSession.resumeCursor !== undefined + ) { + return yield* new ProviderAdapterRequestError({ + provider: activeSession.provider, + method: "thread.turn.start", + detail: [ + `OpenCode session for thread '${threadId}' is bound to '${activeSession.cwd ?? "unknown"}' but the thread workspace is '${effectiveCwd ?? "unknown"}'.`, + "Refusing to resume or replace it silently because that would either run in the wrong directory or lose conversation history.", + "Stop this provider session and start a fresh thread/session for the selected worktree.", + ].join(" "), + }); + } + if ( !runtimeModeChanged && !cwdChanged && @@ -1102,7 +1225,14 @@ const make = Effect.gen(function* () { return { _tag: "Superseded" } as const; } - const { message, attachments } = formatThreadTitleContext(thread.messages); + const { message, attachments } = formatThreadTitleContext([ + ...thread.messages, + ...thread.queuedMessages.map((queued) => ({ + role: "user" as const, + text: queued.text, + attachments: queued.attachments, + })), + ]); if (message.length === 0) { return { _tag: "Completed", title: undefined } as const; } @@ -1154,6 +1284,7 @@ const make = Effect.gen(function* () { threadId: input.threadId, requestId: input.requestId, ...(input.title !== undefined ? { title: input.title } : {}), + createdAt: yield* DateTime.now.pipe(Effect.map(DateTime.formatIso)), }); }); const findInterruptedThreadTitleRegenerations = Effect.fn( @@ -1279,15 +1410,23 @@ const make = Effect.gen(function* () { messageId: event.payload.messageId, }); if (Option.isNone(turnStart) || turnStart.value.message.role !== "user") { + const detail = `User message '${event.payload.messageId}' was not found for turn start request.`; yield* appendProviderFailureActivity({ threadId: event.payload.threadId, kind: "provider.turn.start.failed", summary: "Provider turn start failed", - detail: `User message '${event.payload.messageId}' was not found for turn start request.`, + detail, turnId: null, createdAt: event.payload.createdAt, requestId: event.payload.messageId, }); + // Without abandon, the pending-start placeholder remains forever and + // every Discord follow-up is queued with no drain path (Working… forever). + yield* abandonUnadoptablePendingTurnStart({ + threadId: event.payload.threadId, + createdAt: event.payload.createdAt, + reason: detail, + }); return; } const { message, hasOtherUserMessages } = turnStart.value; @@ -1529,9 +1668,17 @@ const make = Effect.gen(function* () { turnsAfterCompaction.set(event.payload.threadId, queued); return; } + + const identityPeople = yield* identityService.listMapPeople(); + const attributedMessageText = withAgentIdentityAttribution({ + message: message.text, + source: message.source, + additionalSources: [thread.originSource], + people: identityPeople, + }); const sendTurnRequest = yield* buildSendTurnRequestForThread({ threadId: event.payload.threadId, - messageText: message.text, + messageText: attributedMessageText, ...(message.attachments !== undefined ? { attachments: message.attachments } : {}), ...(event.payload.modelSelection !== undefined ? { modelSelection: event.payload.modelSelection } @@ -1593,7 +1740,7 @@ const make = Effect.gen(function* () { if ( !latestSession || latestSession.status === "stopped" || - latestSession.status === "ready" || + (latestSession.status === "ready" && latestSession.updatedAt > event.payload.createdAt) || (event.payload.turnId !== undefined && latestSession.activeTurnId !== null && latestSession.activeTurnId !== event.payload.turnId) @@ -1621,7 +1768,8 @@ const make = Effect.gen(function* () { if ( !stoppedSession || stoppedSession.status === "stopped" || - stoppedSession.status === "ready" || + (stoppedSession.status === "ready" && + stoppedSession.updatedAt > event.payload.createdAt) || (event.payload.turnId !== undefined && stoppedSession.activeTurnId !== null && stoppedSession.activeTurnId !== event.payload.turnId) @@ -1652,9 +1800,81 @@ const make = Effect.gen(function* () { }; // Orchestration turn ids are not provider turn ids, so interrupt by session. - yield* providerService + // Clear the projection before touching the provider. This state transition + // is authoritative and must not depend on a cooperative protocol peer. + yield* setThreadSession({ + threadId: event.payload.threadId, + session: { + ...session, + status: "ready", + activeTurnId: null, + updatedAt: event.payload.createdAt, + }, + createdAt: event.payload.createdAt, + }); + + // Provider cancellation is best-effort and bounded. Some protocol peers + // never answer cancellation; an interruptible timeout releases this + // thread's command lane even in that case. Failures recover by stopping + // the session; a hang times out after the projection is already ready. + const interruptResult = yield* providerService .interruptTurn({ threadId: event.payload.threadId }) - .pipe(Effect.catchCause(recoverInterruptFailure)); + .pipe( + Effect.interruptible, + Effect.timeoutOption(PROVIDER_CONTROL_TIMEOUT), + Effect.catchCause((cause) => + recoverInterruptFailure(cause).pipe(Effect.as(Option.some(undefined))), + ), + ); + if (Option.isNone(interruptResult)) { + yield* Effect.logWarning("provider turn interrupt timed out", { + threadId: event.payload.threadId, + timeout: Duration.format(PROVIDER_CONTROL_TIMEOUT), + }); + yield* setThreadSession({ + threadId: event.payload.threadId, + session: { + ...session, + status: "ready", + activeTurnId: null, + updatedAt: event.payload.createdAt, + }, + createdAt: event.payload.createdAt, + }); + } + }); + + const processContextCompactRequested = Effect.fn("processContextCompactRequested")(function* ( + event: Extract, + ) { + const thread = yield* resolveThread(event.payload.threadId); + if (!thread) { + return; + } + const hasSession = thread.session && thread.session.status !== "stopped"; + if (!hasSession) { + return yield* appendProviderFailureActivity({ + threadId: event.payload.threadId, + kind: "provider.context.compact.failed", + summary: "Context compact failed", + detail: "No active provider session is bound to this thread.", + turnId: null, + createdAt: event.payload.createdAt, + }); + } + + yield* providerService.compactSession({ threadId: event.payload.threadId }).pipe( + Effect.catchCause((cause) => + appendProviderFailureActivity({ + threadId: event.payload.threadId, + kind: "provider.context.compact.failed", + summary: "Context compact failed", + detail: Cause.pretty(cause), + turnId: null, + createdAt: event.payload.createdAt, + }), + ), + ); }); const processApprovalResponseRequested = Effect.fn("processApprovalResponseRequested")(function* ( @@ -1751,23 +1971,31 @@ const make = Effect.gen(function* () { const processSessionStopRequested = Effect.fn("processSessionStopRequested")(function* ( event: Extract, ) { - const thread = yield* resolveThreadShell(event.payload.threadId); - if (!thread) { + // Session stops are resolved through an archived-inclusive context query: + // the archive flow dispatches the stop after the thread disappears from + // the active-only shell/detail queries, so resolving through those would + // silently leak the provider session. + const context = yield* projectionSnapshotQuery + .getSessionStopContextById(event.payload.threadId) + .pipe(Effect.map(Option.getOrUndefined)); + if (!context) { return; } const now = event.payload.createdAt; - const wasCompacting = compactingThreadIds.has(thread.id); - stoppingThreadIds.add(thread.id); - const clearStopping = Effect.sync(() => void stoppingThreadIds.delete(thread.id)); + const wasCompacting = compactingThreadIds.has(context.threadId); + stoppingThreadIds.add(context.threadId); + const clearStopping = Effect.sync(() => void stoppingThreadIds.delete(context.threadId)); yield* cancelTurnsAfterCompaction( - thread.id, + context.threadId, "The session was stopped during context compaction. Send this message again to continue.", ).pipe( Effect.andThen( - thread.session && thread.session.status !== "stopped" - ? providerService.stopSession({ threadId: thread.id }) - : Effect.void, + context.session && context.session.status !== "stopped" + ? providerService + .stopSession({ threadId: context.threadId }) + .pipe(Effect.interruptible, Effect.timeoutOption(PROVIDER_CONTROL_TIMEOUT)) + : Effect.succeed(Option.some(undefined)), ), Effect.matchCauseEffect({ onFailure: (cause) => { @@ -1776,15 +2004,15 @@ const make = Effect.gen(function* () { } const detail = formatFailureDetail(cause); return Effect.sync(() => { - stoppingThreadIds.delete(thread.id); - return wasCompacting && !compactingThreadIds.has(thread.id); + stoppingThreadIds.delete(context.threadId); + return wasCompacting && !compactingThreadIds.has(context.threadId); }).pipe( Effect.flatMap((compactionSettled) => - compactionSettled ? restoreCompaction(thread.id) : Effect.void, + compactionSettled ? restoreCompaction(context.threadId) : Effect.void, ), Effect.andThen( appendProviderFailureActivity({ - threadId: thread.id, + threadId: context.threadId, kind: "provider.session.stop.failed", summary: "Provider session stop failed", detail, @@ -1794,23 +2022,49 @@ const make = Effect.gen(function* () { ), ); }, - onSuccess: () => - setThreadSession({ - threadId: thread.id, + onSuccess: (stopResult) => { + if (Option.isNone(stopResult)) { + return Effect.logWarning("provider session stop timed out", { + threadId: context.threadId, + timeout: Duration.format(PROVIDER_CONTROL_TIMEOUT), + }).pipe( + Effect.andThen( + setThreadSession({ + threadId: context.threadId, + session: { + threadId: context.threadId, + status: "stopped", + providerName: context.session?.providerName ?? null, + ...(context.session?.providerInstanceId !== undefined + ? { providerInstanceId: context.session.providerInstanceId } + : {}), + runtimeMode: context.session?.runtimeMode ?? DEFAULT_RUNTIME_MODE, + activeTurnId: null, + lastError: context.session?.lastError ?? null, + updatedAt: now, + }, + createdAt: now, + }), + ), + ); + } + return setThreadSession({ + threadId: context.threadId, session: { - threadId: thread.id, + threadId: context.threadId, status: "stopped", - providerName: thread.session?.providerName ?? null, - ...(thread.session?.providerInstanceId !== undefined - ? { providerInstanceId: thread.session.providerInstanceId } + providerName: context.session?.providerName ?? null, + ...(context.session?.providerInstanceId !== undefined + ? { providerInstanceId: context.session.providerInstanceId } : {}), - runtimeMode: thread.session?.runtimeMode ?? DEFAULT_RUNTIME_MODE, + runtimeMode: context.session?.runtimeMode ?? DEFAULT_RUNTIME_MODE, activeTurnId: null, - lastError: thread.session?.lastError ?? null, + lastError: context.session?.lastError ?? null, updatedAt: now, }, createdAt: now, - }), + }); + }, }), Effect.ensuring(clearStopping), ); @@ -1850,6 +2104,9 @@ const make = Effect.gen(function* () { case "thread.turn-interrupt-requested": yield* processTurnInterruptRequested(event); return; + case "thread.context-compact-requested": + yield* processContextCompactRequested(event); + return; case "thread.approval-response-requested": yield* processApprovalResponseRequested(event); return; @@ -1901,7 +2158,116 @@ const make = Effect.gen(function* () { }), ); - const worker = yield* makeDrainableWorker(processDomainEventSafely); + const worker = yield* makeKeyedDrainableWorker({ + key: (event: ProviderIntentEvent) => event.payload.threadId, + process: processDomainEventSafely, + }); + + const reconcileStartup = Effect.fn("reconcileStartup")(function* () { + const pendingTurnStarts = yield* projectionTurnRepository.listPendingTurnStarts().pipe( + Effect.catchCause((cause) => + Effect.logWarning("provider startup reconciliation failed to list pending turn starts", { + cause: Cause.pretty(cause), + }).pipe(Effect.as([])), + ), + ); + + yield* Effect.logInfo("provider startup reconciliation candidates loaded", { + pendingTurnStartCandidates: pendingTurnStarts.length, + }); + if (pendingTurnStarts.length === 0) { + return; + } + + const persistedEvents = yield* Stream.runCollect( + orchestrationEngine.readEvents(0, Number.MAX_SAFE_INTEGER), + ).pipe( + Effect.map((events) => Array.from(events)), + Effect.catchCause((cause) => + Effect.logWarning("provider startup reconciliation failed to read persisted turn starts", { + cause: Cause.pretty(cause), + }).pipe(Effect.as([] as ReadonlyArray)), + ), + ); + const turnStartEventsByPendingKey = new Map< + string, + Extract + >(); + for (const event of persistedEvents) { + if (event.type !== "thread.turn-start-requested") continue; + turnStartEventsByPendingKey.set( + `${event.payload.threadId}\u0000${event.payload.messageId}\u0000${event.payload.createdAt}`, + event, + ); + } + + yield* Effect.forEach( + pendingTurnStarts, + (pending) => + Effect.gen(function* () { + const thread = yield* resolveThread(pending.threadId); + if (!thread) { + yield* Effect.logInfo("pending provider turn start reconciliation skipped", { + threadId: pending.threadId, + messageId: pending.messageId, + reason: "thread-missing-archived-or-deleted", + }); + yield* increment(providerTurnRecoveriesTotal, { + outcome: "skipped", + recoveryKind: "pending-start", + reason: "inactive-thread", + }); + return; + } + const event = turnStartEventsByPendingKey.get( + `${pending.threadId}\u0000${pending.messageId}\u0000${pending.requestedAt}`, + ); + if (event === undefined) { + const createdAt = DateTime.formatIso(yield* DateTime.now); + const detail = `Persisted turn start event for user message '${pending.messageId}' could not be found.`; + yield* appendProviderFailureActivity({ + threadId: pending.threadId, + kind: "provider.turn.start.failed", + summary: "Provider turn start recovery failed", + detail, + turnId: null, + createdAt, + }); + yield* abandonUnadoptablePendingTurnStart({ + threadId: pending.threadId, + createdAt, + reason: detail, + }); + yield* increment(providerTurnRecoveriesTotal, { + outcome: "failed", + recoveryKind: "pending-start", + reason: "event-missing", + }); + return; + } + + yield* worker.enqueue(event); + yield* Effect.logInfo("pending provider turn start replay enqueued", { + threadId: pending.threadId, + messageId: pending.messageId, + eventId: event.eventId, + }); + yield* increment(providerTurnRecoveriesTotal, { + outcome: "replayed", + recoveryKind: "pending-start", + }); + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("pending provider turn start reconciliation failed", { + threadId: pending.threadId, + messageId: pending.messageId, + cause: Cause.pretty(cause), + }), + ), + ), + { concurrency: STARTUP_RECOVERY_CONCURRENCY, discard: true }, + ); + }); const start: ProviderCommandReactorShape["start"] = Effect.fn("start")(function* () { const interruptedTitleRegenerations = yield* findInterruptedThreadTitleRegenerations().pipe( @@ -1916,11 +2282,15 @@ const make = Effect.gen(function* () { }), ); const processEvent = Effect.fn("processEvent")(function* (event: OrchestrationEvent) { + if (event.type === "thread.deleted") { + return yield* worker.cancelKey(event.payload.threadId); + } if ( (event.type === "thread.meta-updated" && event.payload.regenerateTitle === true) || event.type === "thread.runtime-mode-set" || event.type === "thread.turn-start-requested" || event.type === "thread.turn-interrupt-requested" || + event.type === "thread.context-compact-requested" || event.type === "thread.approval-response-requested" || event.type === "thread.user-input-response-requested" || event.type === "thread.session-stop-requested" || @@ -1958,15 +2328,27 @@ const make = Effect.gen(function* () { } else { yield* forkParked(clearInterrupted); } + + yield* reconcileStartup().pipe( + Effect.catchCause((cause) => + Effect.logWarning("provider startup reconciliation failed", { + cause: Cause.pretty(cause), + }), + ), + Effect.ensuring(Deferred.succeed(startupReconciliationDone, undefined).pipe(Effect.ignore)), + ); }); return { start, drain: Effect.gen(function* () { + yield* Deferred.await(startupReconciliationDone); yield* worker.drain; yield* threadTitleRegenerationWorker.drain; }), } satisfies ProviderCommandReactorShape; }); -export const ProviderCommandReactorLive = Layer.effect(ProviderCommandReactor, make); +export const ProviderCommandReactorLive = Layer.effect(ProviderCommandReactor, make).pipe( + Layer.provide(ProjectionTurnRepositoryLive), +); diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.grokSegments.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.grokSegments.test.ts new file mode 100644 index 000000000000..60ebf4485379 --- /dev/null +++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.grokSegments.test.ts @@ -0,0 +1,682 @@ +// @effect-diagnostics nodeBuiltinImport:off +/* oxlint-disable t3code/no-manual-effect-runtime-in-tests -- Legacy regression harness uses a manually controlled runtime. */ +/** + * Regression: Grok multi-segment ACP turns must not mint duplicate assistant + * bubbles with the same text. + * + * Grok emits one agent_message_chunk per status line, then tools, then the next + * status. T3 closes the assistant segment on each tool call. The projected + * transcript must contain each status text exactly once (not A, tools, A, B…). + */ +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { + CommandId, + DEFAULT_PROVIDER_INTERACTION_MODE, + EventId, + MessageId, + ProjectId, + ProviderDriverKind, + ProviderInstanceId, + RuntimeItemId, + type ProviderRuntimeEvent, + type ProviderSession, + type ServerSettings, + ThreadId, + TurnId, +} from "@t3tools/contracts"; +import * as Clock from "effect/Clock"; +import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Layer from "effect/Layer"; +import * as ManagedRuntime from "effect/ManagedRuntime"; +import * as PubSub from "effect/PubSub"; +import * as Scope from "effect/Scope"; +import * as Stream from "effect/Stream"; +import { afterEach, describe, expect, it } from "vite-plus/test"; +import * as NodeServices from "@effect/platform-node/NodeServices"; + +import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts"; +import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts"; +import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts"; +import { + ProviderService, + type ProviderServiceShape, +} from "../../provider/Services/ProviderService.ts"; +import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts"; +import { OrchestrationEngineLive } from "./OrchestrationEngine.ts"; +import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts"; +import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import { ProviderRuntimeIngestionLive } from "./ProviderRuntimeIngestion.ts"; +import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; +import { ProviderRuntimeIngestionService } from "../Services/ProviderRuntimeIngestion.ts"; +import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; +import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts"; +import * as VcsDriverRegistry from "../../vcs/VcsDriverRegistry.ts"; +import * as VcsProcess from "../../vcs/VcsProcess.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; +import { ServerConfig } from "../../config.ts"; +import { ServerSettingsService } from "../../serverSettings.ts"; +import { assistantItemId } from "../../provider/acp/AcpSessionRuntime.ts"; + +const asProjectId = (value: string): ProjectId => ProjectId.make(value); +const asItemId = (value: string): RuntimeItemId => RuntimeItemId.make(value); +const asEventId = (value: string): EventId => EventId.make(value); +const asThreadId = (value: string): ThreadId => ThreadId.make(value); +const asTurnId = (value: string): TurnId => TurnId.make(value); + +function makeTestServerSettingsLayer(overrides: Partial = {}) { + return ServerSettingsService.layerTest(overrides); +} + +function createProviderServiceHarness() { + const runtimeEventPubSub = Effect.runSync(PubSub.unbounded()); + const runtimeSessions: ProviderSession[] = []; + const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never; + const service: ProviderServiceShape = { + startSession: () => unsupported(), + sendTurn: () => unsupported(), + compactThread: () => unsupported(), + interruptTurn: () => unsupported(), + compactSession: () => unsupported(), + respondToRequest: () => unsupported(), + respondToUserInput: () => unsupported(), + stopSession: () => unsupported(), + listSessions: () => Effect.succeed([...runtimeSessions]), + getCapabilities: () => Effect.succeed({ sessionModelSwitch: "in-session" }), + assertConversationRollbackSupported: () => unsupported(), + getInstanceInfo: (instanceId) => { + const driverKind = ProviderDriverKind.make(String(instanceId)); + return Effect.succeed({ + instanceId, + driverKind, + displayName: undefined, + enabled: true, + continuationIdentity: { + driverKind, + continuationKey: `${driverKind}:instance:${instanceId}`, + }, + }); + }, + rollbackConversation: () => unsupported(), + uploadFeedback: () => unsupported(), + get streamEvents() { + return Stream.fromPubSub(runtimeEventPubSub); + }, + }; + + const setSession = (session: ProviderSession): void => { + const existingIndex = runtimeSessions.findIndex((entry) => entry.threadId === session.threadId); + if (existingIndex >= 0) { + runtimeSessions[existingIndex] = session; + return; + } + runtimeSessions.push(session); + }; + + return { + service, + setSession, + emit: (event: ProviderRuntimeEvent): void => { + Effect.runSync(PubSub.publish(runtimeEventPubSub, event)); + }, + }; +} + +type TestThread = { + readonly id: ThreadId; + readonly messages: ReadonlyArray<{ + readonly id: string; + readonly role: string; + readonly text: string; + readonly turnId: string | null; + readonly streaming: boolean; + }>; + readonly session?: { readonly status?: string; readonly activeTurnId?: string | null } | null; +}; + +async function waitForThread( + readModel: () => Promise<{ threads: ReadonlyArray }>, + predicate: (thread: TestThread) => boolean, + timeoutMs = 3000, + threadId: ThreadId = asThreadId("thread-1"), +): Promise { + const deadline = (await Effect.runPromise(Clock.currentTimeMillis)) + timeoutMs; + const poll = async (): Promise => { + const snapshot = await readModel(); + const thread = snapshot.threads.find((entry) => entry.id === threadId); + if (thread && predicate(thread)) { + return thread; + } + if ((await Effect.runPromise(Clock.currentTimeMillis)) >= deadline) { + const latest = snapshot.threads.find((entry) => entry.id === threadId); + throw new Error( + `Timed out waiting for thread state. messages=${JSON.stringify(latest?.messages ?? [], null, 2)}`, + ); + } + await Effect.runPromise(Effect.yieldNow); + return poll(); + }; + return poll(); +} + +/** + * Emit the runtime-event shape GrokAdapter produces for one assistant segment + * (item.started → content.delta → item.completed) using AcpSessionRuntime item ids. + */ +function emitGrokAssistantSegment(input: { + readonly emit: (event: ProviderRuntimeEvent) => void; + readonly turnId: TurnId; + readonly sessionId: string; + readonly runId: string; + readonly segmentIndex: number; + readonly text: string; + readonly createdAt: string; + readonly eventPrefix: string; + readonly streaming: boolean; +}) { + const itemId = assistantItemId(input.sessionId, input.runId, input.segmentIndex); + const provider = ProviderDriverKind.make("grok"); + const threadId = asThreadId("thread-1"); + + input.emit({ + type: "item.started", + eventId: asEventId(`${input.eventPrefix}-started`), + provider, + createdAt: input.createdAt, + threadId, + turnId: input.turnId, + itemId: asItemId(itemId), + payload: { + itemType: "assistant_message", + status: "inProgress", + }, + }); + input.emit({ + type: "content.delta", + eventId: asEventId(`${input.eventPrefix}-delta`), + provider, + createdAt: input.createdAt, + threadId, + turnId: input.turnId, + itemId: asItemId(itemId), + payload: { + streamKind: "assistant_text", + delta: input.text, + }, + }); + input.emit({ + type: "item.completed", + eventId: asEventId(`${input.eventPrefix}-completed`), + provider, + createdAt: input.createdAt, + threadId, + turnId: input.turnId, + itemId: asItemId(itemId), + payload: { + itemType: "assistant_message", + status: "completed", + }, + }); + void input.streaming; +} + +function emitGrokTool(input: { + readonly emit: (event: ProviderRuntimeEvent) => void; + readonly turnId: TurnId; + readonly toolCallId: string; + readonly title: string; + readonly createdAt: string; + readonly eventPrefix: string; +}) { + const provider = ProviderDriverKind.make("grok"); + const threadId = asThreadId("thread-1"); + const itemId = asItemId(input.toolCallId); + + input.emit({ + type: "item.updated", + eventId: asEventId(`${input.eventPrefix}-updated`), + provider, + createdAt: input.createdAt, + threadId, + turnId: input.turnId, + itemId, + payload: { + itemType: "command_execution", + status: "inProgress", + title: input.title, + detail: input.title, + }, + }); + input.emit({ + type: "item.completed", + eventId: asEventId(`${input.eventPrefix}-completed`), + provider, + createdAt: input.createdAt, + threadId, + turnId: input.turnId, + itemId, + payload: { + itemType: "command_execution", + status: "completed", + title: input.title, + detail: input.title, + }, + }); +} + +describe("ProviderRuntimeIngestion Grok multi-segment assistant bubbles", () => { + let runtime: ManagedRuntime.ManagedRuntime< + OrchestrationEngineService | ProviderRuntimeIngestionService | ProjectionSnapshotQuery, + unknown + > | null = null; + let scope: Scope.Closeable | null = null; + const tempDirs: string[] = []; + + function makeTempDir(prefix: string): string { + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), prefix)); + tempDirs.push(dir); + return dir; + } + + afterEach(async () => { + if (scope) { + await Effect.runPromise(Scope.close(scope, Exit.void)); + } + scope = null; + if (runtime) { + await runtime.dispose(); + } + runtime = null; + for (const dir of tempDirs.splice(0)) { + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }); + + async function createHarness(options?: { serverSettings?: Partial }) { + const workspaceRoot = makeTempDir("t3-grok-segments-"); + NodeFS.mkdirSync(NodePath.join(workspaceRoot, ".git")); + const provider = createProviderServiceHarness(); + const orchestrationLayer = OrchestrationEngineLive.pipe( + Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(OrchestrationProjectionPipelineLive), + Layer.provide(OrchestrationEventStoreLive), + Layer.provide(OrchestrationCommandReceiptRepositoryLive), + Layer.provide(RepositoryIdentityResolver.layer), + Layer.provide(SqlitePersistenceMemory), + ); + const projectionSnapshotLayer = OrchestrationProjectionSnapshotQueryLive.pipe( + Layer.provide(RepositoryIdentityResolver.layer), + Layer.provide(SqlitePersistenceMemory), + ); + const layer = ProviderRuntimeIngestionLive.pipe( + Layer.provideMerge(orchestrationLayer), + Layer.provideMerge(projectionSnapshotLayer), + // Single shared liveness instance across ingestion (writer), the + // engine, and the snapshot query (reader). + Layer.provideMerge(ThreadBackgroundLiveness.layer), + Layer.provideMerge(ThreadPlanProgress.layer), + Layer.provideMerge(SqlitePersistenceMemory), + Layer.provideMerge(Layer.succeed(ProviderService, provider.service)), + Layer.provideMerge(makeTestServerSettingsLayer(options?.serverSettings)), + Layer.provideMerge(CheckpointStore.layer.pipe(Layer.provide(VcsDriverRegistry.layer))), + Layer.provideMerge(VcsProcess.layer), + Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())), + Layer.provideMerge(NodeServices.layer), + ); + runtime = ManagedRuntime.make(layer); + const engine = await runtime.runPromise(Effect.service(OrchestrationEngineService)); + const snapshotQuery = await runtime.runPromise(Effect.service(ProjectionSnapshotQuery)); + const ingestion = await runtime.runPromise(Effect.service(ProviderRuntimeIngestionService)); + scope = await Effect.runPromise(Scope.make("sequential")); + await Effect.runPromise(ingestion.start().pipe(Scope.provide(scope))); + + const createdAt = "2026-07-21T00:00:00.000Z"; + await Effect.runPromise( + engine.dispatch({ + type: "project.create", + commandId: CommandId.make("cmd-grok-segments-project"), + projectId: asProjectId("project-1"), + title: "Grok Segments", + workspaceRoot, + defaultModelSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + createdAt, + }), + ); + await Effect.runPromise( + engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-grok-segments-thread"), + threadId: ThreadId.make("thread-1"), + projectId: asProjectId("project-1"), + title: "Thread", + modelSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "full-access", + branch: null, + worktreePath: null, + createdAt, + }), + ); + await Effect.runPromise( + engine.dispatch({ + type: "thread.session.set", + commandId: CommandId.make("cmd-grok-segments-session"), + threadId: ThreadId.make("thread-1"), + session: { + threadId: ThreadId.make("thread-1"), + status: "ready", + providerName: "grok", + runtimeMode: "full-access", + activeTurnId: null, + updatedAt: createdAt, + lastError: null, + }, + createdAt, + }), + ); + provider.setSession({ + provider: ProviderDriverKind.make("grok"), + status: "ready", + runtimeMode: "full-access", + threadId: ThreadId.make("thread-1"), + createdAt, + updatedAt: createdAt, + }); + + return { + emit: provider.emit, + drain: () => Effect.runPromise(ingestion.drain), + readModel: () => Effect.runPromise(snapshotQuery.getSnapshot()), + engine, + }; + } + + async function runGrokStatusSandwichTurn(options: { readonly streaming: boolean }) { + const harness = await createHarness({ + serverSettings: { enableLegacyTokenStreaming: options.streaming }, + }); + const turnId = asTurnId("turn-grok-sandwich"); + const sessionId = "019f8373-fa8d-7982-a0d7-caf8b866b523"; + const runId = "run-1"; + const provider = ProviderDriverKind.make("grok"); + const threadId = asThreadId("thread-1"); + + const statuses = [ + "Aligning Bauhaus with Standard: skip label creation when nothing is still initial, so packed-order reprint goes straight to print.", + "Validation passed. Booting an isolated Mako stack and running the pack-reprint e2e.", + "E2E green. Committing, rebasing onto main, and opening the PR.", + ] as const; + + harness.emit({ + type: "turn.started", + eventId: asEventId("evt-turn-started-grok-sandwich"), + provider, + createdAt: "2026-07-21T00:00:00.000Z", + threadId, + turnId, + payload: {}, + }); + await waitForThread( + harness.readModel, + (thread) => + thread.session?.status === "running" && thread.session?.activeTurnId === String(turnId), + ); + + // Simulate Grok: status → tools → status → tools → status → tools + for (let index = 0; index < statuses.length; index += 1) { + const text = statuses[index]!; + const at = `2026-07-21T00:0${index}:00.000Z`; + emitGrokAssistantSegment({ + emit: harness.emit, + turnId, + sessionId, + runId, + segmentIndex: index, + text, + createdAt: at, + eventPrefix: `evt-seg-${index}`, + streaming: options.streaming, + }); + emitGrokTool({ + emit: harness.emit, + turnId, + toolCallId: `tool-${index}`, + title: `command ${index}`, + createdAt: `2026-07-21T00:0${index}:30.000Z`, + eventPrefix: `evt-tool-${index}`, + }); + } + + harness.emit({ + type: "turn.completed", + eventId: asEventId("evt-turn-completed-grok-sandwich"), + provider, + createdAt: "2026-07-21T00:10:00.000Z", + threadId, + turnId, + payload: { state: "completed" }, + }); + + await harness.drain(); + + const thread = await waitForThread(harness.readModel, (entry) => { + const assistants = entry.messages.filter((message) => message.role === "assistant"); + return ( + assistants.length >= statuses.length && + assistants.every((message) => !message.streaming) && + statuses.every((status) => assistants.some((message) => message.text === status)) + ); + }); + + const assistantTexts = thread.messages + .filter((message) => message.role === "assistant") + .map((message) => message.text); + + return { assistantTexts, messages: thread.messages }; + } + + it("projects each Grok status line once in buffered mode (no A/tool/A sandwich)", async () => { + const { assistantTexts } = await runGrokStatusSandwichTurn({ streaming: false }); + + expect(assistantTexts).toEqual([ + "Aligning Bauhaus with Standard: skip label creation when nothing is still initial, so packed-order reprint goes straight to print.", + "Validation passed. Booting an isolated Mako stack and running the pack-reprint e2e.", + "E2E green. Committing, rebasing onto main, and opening the PR.", + ]); + // Explicit uniqueness guard — the UI bug is consecutive identical bubbles. + expect(new Set(assistantTexts).size).toBe(assistantTexts.length); + }); + + it("projects each Grok status line once in streaming mode (no A/tool/A sandwich)", async () => { + const { assistantTexts } = await runGrokStatusSandwichTurn({ streaming: true }); + + expect(assistantTexts).toEqual([ + "Aligning Bauhaus with Standard: skip label creation when nothing is still initial, so packed-order reprint goes straight to print.", + "Validation passed. Booting an isolated Mako stack and running the pack-reprint e2e.", + "E2E green. Committing, rebasing onto main, and opening the PR.", + ]); + expect(new Set(assistantTexts).size).toBe(assistantTexts.length); + }); + + it("does not re-mint the same status when assistant item.completed uses Acp item ids", async () => { + // Grok AcpSessionRuntime item ids already start with `assistant:…`. Ingestion + // must not create a second message row from the completion fallback id path. + const harness = await createHarness({ + serverSettings: { enableLegacyTokenStreaming: true }, + }); + const turnId = asTurnId("turn-id-prefix"); + const sessionId = "sess-1"; + const runId = "run-1"; + const itemId = assistantItemId(sessionId, runId, 0); + const provider = ProviderDriverKind.make("grok"); + const threadId = asThreadId("thread-1"); + const text = "status once only"; + + harness.emit({ + type: "turn.started", + eventId: asEventId("evt-turn-started-id-prefix"), + provider, + createdAt: "2026-07-21T00:00:00.000Z", + threadId, + turnId, + payload: {}, + }); + + // Stream without item.started first (content.delta alone), then complete with + // the same Acp item id — matches live GrokAdapter ordering in some paths. + harness.emit({ + type: "content.delta", + eventId: asEventId("evt-delta-id-prefix"), + provider, + createdAt: "2026-07-21T00:00:01.000Z", + threadId, + turnId, + itemId: asItemId(itemId), + payload: { streamKind: "assistant_text", delta: text }, + }); + harness.emit({ + type: "item.completed", + eventId: asEventId("evt-complete-id-prefix"), + provider, + createdAt: "2026-07-21T00:00:02.000Z", + threadId, + turnId, + itemId: asItemId(itemId), + payload: { itemType: "assistant_message", status: "completed" }, + }); + // Second completion with active already cleared — must not mint a twin. + harness.emit({ + type: "item.completed", + eventId: asEventId("evt-complete-id-prefix-again"), + provider, + createdAt: "2026-07-21T00:00:03.000Z", + threadId, + turnId, + itemId: asItemId(itemId), + payload: { itemType: "assistant_message", status: "completed" }, + }); + harness.emit({ + type: "turn.completed", + eventId: asEventId("evt-turn-completed-id-prefix"), + provider, + createdAt: "2026-07-21T00:00:04.000Z", + threadId, + turnId, + payload: { state: "completed" }, + }); + + await harness.drain(); + + const thread = await waitForThread(harness.readModel, (entry) => + entry.messages.some((message) => message.role === "assistant" && message.text === text), + ); + const assistants = thread.messages.filter((message) => message.role === "assistant"); + expect(assistants.map((message) => message.text)).toEqual([text]); + // ACP item ids already start with `assistant:` — do not double-prefix. + const ids = assistants.map((message) => message.id); + expect(ids).toHaveLength(1); + expect(ids[0]).toBe(MessageId.make(itemId)); + }); + + it("drops a buffered assistant segment that repeats the previous status text", async () => { + const harness = await createHarness({ + serverSettings: { enableLegacyTokenStreaming: false }, + }); + const turnId = asTurnId("turn-dup-status"); + const sessionId = "sess-dup"; + const runId = "run-dup"; + const provider = ProviderDriverKind.make("grok"); + const threadId = asThreadId("thread-1"); + const status = + "Aligning Bauhaus with Standard: skip label creation when nothing is still initial."; + + harness.emit({ + type: "turn.started", + eventId: asEventId("evt-turn-started-dup-status"), + provider, + createdAt: "2026-07-21T00:00:00.000Z", + threadId, + turnId, + payload: {}, + }); + await waitForThread( + harness.readModel, + (thread) => + thread.session?.status === "running" && thread.session?.activeTurnId === String(turnId), + ); + + // First status + emitGrokAssistantSegment({ + emit: harness.emit, + turnId, + sessionId, + runId, + segmentIndex: 0, + text: status, + createdAt: "2026-07-21T00:00:01.000Z", + eventPrefix: "evt-dup-a", + streaming: false, + }); + emitGrokTool({ + emit: harness.emit, + turnId, + toolCallId: "tool-dup-1", + title: "validate", + createdAt: "2026-07-21T00:00:02.000Z", + eventPrefix: "evt-dup-tool", + }); + // Twin status (same text, new segment) — must not project a second bubble. + emitGrokAssistantSegment({ + emit: harness.emit, + turnId, + sessionId, + runId, + segmentIndex: 1, + text: status, + createdAt: "2026-07-21T00:00:03.000Z", + eventPrefix: "evt-dup-b", + streaming: false, + }); + emitGrokAssistantSegment({ + emit: harness.emit, + turnId, + sessionId, + runId, + segmentIndex: 2, + text: "Validation passed. Booting e2e.", + createdAt: "2026-07-21T00:00:04.000Z", + eventPrefix: "evt-dup-c", + streaming: false, + }); + harness.emit({ + type: "turn.completed", + eventId: asEventId("evt-turn-completed-dup-status"), + provider, + createdAt: "2026-07-21T00:00:05.000Z", + threadId, + turnId, + payload: { state: "completed" }, + }); + await harness.drain(); + + const thread = await waitForThread(harness.readModel, (entry) => + entry.messages.some( + (message) => message.role === "assistant" && message.text.includes("Validation passed"), + ), + ); + const assistantTexts = thread.messages + .filter((message) => message.role === "assistant") + .map((message) => message.text); + expect(assistantTexts).toEqual([status, "Validation passed. Booting e2e."]); + }); +}); diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts index 1094ab48b7ac..b6928f351ffc 100644 --- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts +++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts @@ -121,6 +121,7 @@ function createProviderServiceHarness() { sendTurn: () => unsupported(), compactThread: () => unsupported(), interruptTurn: () => unsupported(), + compactSession: () => unsupported(), respondToRequest: () => unsupported(), respondToUserInput: () => unsupported(), stopSession: () => unsupported(), @@ -538,6 +539,16 @@ describe("ProviderRuntimeIngestion", () => { runtimeMode: "approval-required", createdAt: base.createdAt, }); + // Fork queues a follow-up while a turn is running. Steer it so the new + // turn is pending, matching providers that open a new turn without + // completing the superseded one. + await harness.dispatch({ + type: "thread.queue.steer", + commandId: CommandId.make("steer-new-while-old-finishes"), + threadId, + messageId: asMessageId("new-turn-prompt"), + createdAt: base.createdAt, + }); harness.setProviderSession({ provider: base.provider, status: "running", @@ -2000,22 +2011,35 @@ describe("ProviderRuntimeIngestion", () => { threadId, ); - // The steer: a user-requested turn start while the old turn still runs. + // The steer: a follow-up sent mid-turn queues by default, then the + // explicit queue.steer command dispatches it into the running turn. await Effect.runPromise( - harness.engine.dispatch({ - type: "thread.turn.start", - commandId: CommandId.make("cmd-turn-start-steer"), - threadId, - message: { - messageId: asMessageId("msg-steer"), - role: "user", - text: "actually, do 15 instead", - attachments: [], - }, - interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, - runtimeMode: "approval-required", - createdAt, - }), + harness.engine + .dispatch({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-turn-start-steer"), + threadId, + message: { + messageId: asMessageId("msg-steer"), + role: "user", + text: "actually, do 15 instead", + attachments: [], + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + createdAt, + }) + .pipe( + Effect.andThen( + harness.engine.dispatch({ + type: "thread.queue.steer", + commandId: CommandId.make("cmd-queue-steer"), + threadId, + messageId: asMessageId("msg-steer"), + createdAt, + }), + ), + ), ); // The provider session tracks the new turn before emitting turn.started @@ -3693,6 +3717,218 @@ describe("ProviderRuntimeIngestion", () => { expect(checkpoint?.checkpointRef).toBe("provider-diff:evt-turn-diff-updated"); }); + effectIt.effect("applies provider thread.metadata.updated when thread title is the default", () => + Effect.gen(function* () { + const harness = yield* Effect.promise(() => createHarness()); + const now = "2026-01-01T00:00:00.000Z"; + + yield* harness.engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-thread-create-default"), + threadId: ThreadId.make("thread-default"), + projectId: asProjectId("project-1"), + title: "New thread", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: null, + worktreePath: null, + createdAt: now, + }); + + harness.emit({ + type: "thread.metadata.updated", + eventId: asEventId("evt-thread-metadata-default"), + provider: ProviderDriverKind.make("codex"), + createdAt: now, + threadId: asThreadId("thread-default"), + payload: { + name: "Provider default title", + metadata: { source: "provider" }, + }, + }); + + yield* Effect.promise(() => harness.drain()); + + const thread = yield* Effect.promise(() => + waitForThread( + harness.readModel, + (entry) => entry.title === "Provider default title", + 2000, + asThreadId("thread-default"), + ), + ); + + expect(thread.title).toBe("Provider default title"); + }), + ); + + effectIt.effect( + "rejects provider thread.metadata.updated when thread title is already customized", + () => + Effect.gen(function* () { + const harness = yield* Effect.promise(() => createHarness()); + const now = "2026-01-01T00:00:00.000Z"; + + yield* harness.engine.dispatch({ + type: "thread.meta.update", + commandId: CommandId.make("cmd-thread-custom-title"), + threadId: ThreadId.make("thread-1"), + title: "My custom title", + }); + + harness.emit({ + type: "thread.metadata.updated", + eventId: asEventId("evt-thread-metadata-custom"), + provider: ProviderDriverKind.make("codex"), + createdAt: now, + threadId: asThreadId("thread-1"), + payload: { + name: "Provider override attempt", + metadata: { source: "provider" }, + }, + }); + + yield* Effect.promise(() => harness.drain()); + + yield* Effect.promise(() => + waitForThread( + harness.readModel, + (entry) => entry.id === "thread-1" && entry.title === "My custom title", + ), + ); + + const readModel = yield* Effect.promise(() => harness.readModel()); + const thread = readModel.threads.find((entry) => entry.id === "thread-1"); + expect(thread?.title).toBe("My custom title"); + }), + ); + + effectIt.effect("skips provider thread.metadata.updated when payload.name is missing", () => + Effect.gen(function* () { + const harness = yield* Effect.promise(() => createHarness()); + const now = "2026-01-01T00:00:00.000Z"; + + yield* harness.engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-thread-create-no-name"), + threadId: ThreadId.make("thread-no-name"), + projectId: asProjectId("project-1"), + title: "New thread", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: null, + worktreePath: null, + createdAt: now, + }); + + harness.emit({ + type: "thread.metadata.updated", + eventId: asEventId("evt-thread-metadata-no-name"), + provider: ProviderDriverKind.make("codex"), + createdAt: now, + threadId: asThreadId("thread-no-name"), + payload: {}, + }); + + yield* Effect.promise(() => harness.drain()); + + const readModel = yield* Effect.promise(() => harness.readModel()); + const thread = readModel.threads.find((entry) => entry.id === "thread-no-name"); + expect(thread?.title).toBe("New thread"); + }), + ); + + effectIt.effect("skips provider thread.metadata.updated when payload.name is empty string", () => + Effect.gen(function* () { + const harness = yield* Effect.promise(() => createHarness()); + const now = "2026-01-01T00:00:00.000Z"; + + yield* harness.engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-thread-create-empty"), + threadId: ThreadId.make("thread-empty-name"), + projectId: asProjectId("project-1"), + title: "New thread", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: null, + worktreePath: null, + createdAt: now, + }); + + harness.emit({ + type: "thread.metadata.updated", + eventId: asEventId("evt-thread-metadata-empty"), + provider: ProviderDriverKind.make("codex"), + createdAt: now, + threadId: asThreadId("thread-empty-name"), + payload: { + name: "", + }, + }); + + yield* Effect.promise(() => harness.drain()); + + const readModel = yield* Effect.promise(() => harness.readModel()); + const thread = readModel.threads.find((entry) => entry.id === "thread-empty-name"); + expect(thread?.title).toBe("New thread"); + }), + ); + + effectIt.effect( + "skips provider thread.metadata.updated when payload.name sanitizes to empty", + () => + Effect.gen(function* () { + const harness = yield* Effect.promise(() => createHarness()); + const now = "2026-01-01T00:00:00.000Z"; + + yield* harness.engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-thread-create-whitespace"), + threadId: ThreadId.make("thread-whitespace-name"), + projectId: asProjectId("project-1"), + title: "New thread", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: null, + worktreePath: null, + createdAt: now, + }); + + harness.emit({ + type: "thread.metadata.updated", + eventId: asEventId("evt-thread-metadata-whitespace"), + provider: ProviderDriverKind.make("codex"), + createdAt: now, + threadId: asThreadId("thread-whitespace-name"), + payload: { + name: " ", + }, + }); + + yield* Effect.promise(() => harness.drain()); + + const readModel = yield* Effect.promise(() => harness.readModel()); + const thread = readModel.threads.find((entry) => entry.id === "thread-whitespace-name"); + expect(thread?.title).toBe("New thread"); + }), + ); it("mirrors a provider title only while the thread still has the default title", async () => { const harness = await createHarness({ threadTitle: DEFAULT_THREAD_TITLE }); const now = "2026-01-01T00:00:00.000Z"; diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts index 8d34fee4f981..d8531443ae64 100644 --- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts +++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts @@ -4,6 +4,7 @@ import { CommandId, MessageId, type OrchestrationEvent, + type OrchestrationMessage, OrchestrationProposedPlanId, CheckpointRef, classifyTaskAgentKind, @@ -28,11 +29,14 @@ import * as Option from "effect/Option"; import * as Predicate from "effect/Predicate"; import * as Stream from "effect/Stream"; import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker"; +import { sanitizeTitle } from "@t3tools/shared/threadTitle"; import { formatTokens } from "@t3tools/shared/usageFormat"; import { ProviderService } from "../../provider/Services/ProviderService.ts"; import { ProjectionTurnRepository } from "../../persistence/Services/ProjectionTurns.ts"; import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts"; +import { ProjectionQueuedMessageRepository } from "../../persistence/Services/ProjectionQueuedMessages.ts"; +import { ProjectionQueuedMessageRepositoryLive } from "../../persistence/Layers/ProjectionQueuedMessages.ts"; import { ProjectionThreadActivityRepository } from "../../persistence/Services/ProjectionThreadActivities.ts"; import { ProjectionThreadActivityRepositoryLive } from "../../persistence/Layers/ProjectionThreadActivities.ts"; import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts"; @@ -198,11 +202,46 @@ function assistantSegmentBaseKeyFromEvent(event: ProviderRuntimeEvent): string { return String(event.itemId ?? event.turnId ?? event.eventId); } +/** + * Mint a stable assistant message id for an ACP/provider segment. + * + * ACP adapters (Grok/Cursor) already use item ids of the form + * `assistant:::segment:`. Prefix only when the base key is not + * already an assistant id so delta + completion paths stay aligned and we never + * fork `assistant:assistant:…` twins for the same segment. + */ function assistantSegmentMessageId(baseKey: string, segmentIndex: number): MessageId { + const normalizedBase = baseKey.startsWith("assistant:") ? baseKey : `assistant:${baseKey}`; return MessageId.make( - segmentIndex === 0 ? `assistant:${baseKey}` : `assistant:${baseKey}:segment:${segmentIndex}`, + segmentIndex === 0 ? normalizedBase : `${normalizedBase}:segment:${segmentIndex}`, ); } + +function assistantCompletionMessageId(event: ProviderRuntimeEvent): MessageId { + return assistantSegmentMessageId(assistantSegmentBaseKeyFromEvent(event), 0); +} + +function normalizeAssistantText(text: string): string { + return text.replace(/\s+/g, " ").trim(); +} + +function findLastAssistantMessageForTurn( + messages: ReadonlyArray, + turnId: TurnId, + excludeMessageId?: MessageId, +): OrchestrationMessage | undefined { + for (let index = messages.length - 1; index >= 0; index -= 1) { + const message = messages[index]; + if (!message || message.role !== "assistant" || message.turnId !== turnId) { + continue; + } + if (excludeMessageId !== undefined && message.id === excludeMessageId) { + continue; + } + return message; + } + return undefined; +} function buildContextWindowActivityPayload( event: ProviderRuntimeEvent, ): ThreadTokenUsageSnapshot | undefined { @@ -907,6 +946,7 @@ const make = Effect.gen(function* () { const projectionThreadMessages = yield* ProjectionThreadMessageRepository; const projectionThreadProposedPlans = yield* ProjectionThreadProposedPlanRepository; const projectionTurnRepository = yield* ProjectionTurnRepository; + const projectionQueuedMessageRepository = yield* ProjectionQueuedMessageRepository; const projectionThreadActivityRepository = yield* ProjectionThreadActivityRepository; const serverSettingsService = yield* ServerSettingsService; const checkpointStore = yield* CheckpointStore.CheckpointStore; @@ -963,6 +1003,29 @@ const make = Effect.gen(function* () { ), ); + const dispatchQueueDrain = Effect.fn("dispatchQueueDrain")(function* ( + threadId: ThreadId, + event: ProviderRuntimeEvent, + now: string, + ) { + const queuedMessages = yield* projectionQueuedMessageRepository.listByThreadId({ threadId }); + if (queuedMessages.length === 0) { + return; + } + yield* orchestrationEngine + .dispatch({ + type: "thread.queue.drain", + commandId: yield* providerCommandId(event, "queue-drain"), + threadId, + createdAt: now, + }) + .pipe( + // A drain losing the race to a fresh user turn (or an already-empty + // queue) is expected; the next natural completion re-attempts. + Effect.catchTag("OrchestrationCommandInvariantError", () => Effect.void), + ); + }); + const resolveThreadRuntimeContext = Effect.fn("resolveThreadRuntimeContext")(function* ( threadId: ThreadId, ) { @@ -1221,6 +1284,13 @@ const make = Effect.gen(function* () { finalDeltaCommandTag: string; fallbackText?: string; hasProjectedMessage?: boolean; + /** Already-projected text for this message id (streaming path). */ + projectedText?: string; + /** + * Prior assistant messages for this turn (excluding `messageId`). Used to + * drop consecutive identical Grok-style status segments. + */ + previousAssistantMessages?: ReadonlyArray; }) => Effect.gen(function* () { const bufferedText = yield* takeBufferedAssistantText(input.messageId); @@ -1229,10 +1299,56 @@ const make = Effect.gen(function* () { ? bufferedText : (input.fallbackText?.trim().length ?? 0) > 0 ? input.fallbackText! - : ""; + : (input.projectedText ?? ""); const hasRenderableText = hasRenderableAssistantText(text); - if (hasRenderableText) { + // Drop consecutive identical assistant segments in a turn (Grok multi-step + // ACP can re-open a bubble with the same status text after tools). + if (hasRenderableText && input.previousAssistantMessages) { + const previous = input.previousAssistantMessages.at(-1); + if ( + previous && + previous.role === "assistant" && + !previous.streaming && + normalizeAssistantText(previous.text) === normalizeAssistantText(text) + ) { + yield* clearAssistantMessageState(input.messageId); + if (input.turnId) { + yield* forgetAssistantMessageId(input.threadId, input.turnId, input.messageId); + } + // Twin was already streamed into the projection under a new id — still + // complete it so the row settles, then the timeline collapses identical + // consecutive assistants. For buffered twins we never projected. + if (input.hasProjectedMessage) { + yield* orchestrationEngine.dispatch({ + type: "thread.message.assistant.complete", + commandId: yield* providerCommandId(input.event, input.commandTag), + threadId: input.threadId, + messageId: input.messageId, + ...(input.turnId ? { turnId: input.turnId } : {}), + createdAt: input.createdAt, + }); + } + return; + } + } + + if (hasRenderableText && bufferedText.length > 0) { + yield* orchestrationEngine.dispatch({ + type: "thread.message.assistant.delta", + commandId: yield* providerCommandId(input.event, input.finalDeltaCommandTag), + threadId: input.threadId, + messageId: input.messageId, + delta: text, + ...(input.turnId ? { turnId: input.turnId } : {}), + createdAt: input.createdAt, + }); + } else if ( + hasRenderableText && + bufferedText.length === 0 && + (input.projectedText?.length ?? 0) === 0 && + (input.fallbackText?.trim().length ?? 0) > 0 + ) { yield* orchestrationEngine.dispatch({ type: "thread.message.assistant.delta", commandId: yield* providerCommandId(input.event, input.finalDeltaCommandTag), @@ -1503,6 +1619,7 @@ const make = Effect.gen(function* () { : Option.none(); const hasPendingTurnStart = Option.isSome(pendingTurnStart) && thread.session?.status === "starting"; + let drainQueueAfterTurnFinalize = false; const conflictsWithActiveTurn = activeTurnId !== null && eventTurnId !== undefined && !sameId(activeTurnId, eventTurnId); @@ -1645,6 +1762,15 @@ const make = Effect.gen(function* () { }, createdAt: now, }); + + // Auto-drain queued follow-ups only on natural completion — + // never after an interrupt (the user stopped the agent to take + // control) or a failure. The dispatch happens after the + // assistant-finalization block below so the drained user message + // sequences after the assistant text it follows up on. + drainQueueAfterTurnFinalize = + event.type === "turn.completed" && + normalizeRuntimeTurnState(event.payload.state) === "completed"; } } @@ -1750,9 +1876,7 @@ const make = Effect.gen(function* () { const assistantCompletion = event.type === "item.completed" && event.payload.itemType === "assistant_message" ? { - messageId: MessageId.make( - `assistant:${event.itemId ?? event.turnId ?? event.eventId}`, - ), + messageId: assistantCompletionMessageId(event), fallbackText: event.payload.detail, } : undefined; @@ -1787,17 +1911,50 @@ const make = Effect.gen(function* () { const shouldApplyFallbackCompletionText = !existingAssistantMessage || existingAssistantMessage.text.length === 0; - const shouldSkipRedundantCompletion = - Option.isNone(activeAssistantMessageId) && + // Queue-drain race: after turn.completed finalizes a segment under turn A, + // the next provider session can re-emit assistant.complete for the same + // message id with turn B. Re-dispatching rebinds turnId in the projector + // and orphans the final from turn A (Discord loses it under Working). + const alreadyBoundToOtherTurn = + existingAssistantMessage !== undefined && + existingAssistantMessage.role === "assistant" && + existingAssistantMessage.turnId !== null && turnId !== undefined && - hasAssistantMessagesForTurn && - (assistantCompletion.fallbackText?.trim().length ?? 0) === 0; + !sameId(existingAssistantMessage.turnId, turnId); + + const shouldSkipRedundantCompletion = + alreadyBoundToOtherTurn || + (Option.isNone(activeAssistantMessageId) && + turnId !== undefined && + hasAssistantMessagesForTurn && + (assistantCompletion.fallbackText?.trim().length ?? 0) === 0); if (!shouldSkipRedundantCompletion) { if (turnId && Option.isNone(activeAssistantMessageId)) { yield* rememberAssistantMessageId(thread.id, turnId, assistantMessageId); } + const previousAssistantMessages = turnId + ? (yield* projectionThreadMessages.listByThreadId({ threadId: thread.id })) + .filter( + (message) => + message.role === "assistant" && + message.turnId === turnId && + message.messageId !== assistantMessageId, + ) + .map((message): OrchestrationMessage => ({ + id: message.messageId, + role: message.role, + text: message.text, + attachments: message.attachments, + turnId: message.turnId, + streaming: message.isStreaming, + source: message.source, + createdAt: message.createdAt, + updatedAt: message.updatedAt, + })) + : []; + yield* finalizeAssistantMessage({ event, threadId: thread.id, @@ -1807,6 +1964,10 @@ const make = Effect.gen(function* () { commandTag: "assistant-complete", finalDeltaCommandTag: "assistant-delta-finalize", hasProjectedMessage: existingAssistantMessage !== undefined, + previousAssistantMessages, + ...(existingAssistantMessage?.text + ? { projectedText: existingAssistantMessage.text } + : {}), ...(assistantCompletion.fallbackText !== undefined && shouldApplyFallbackCompletionText ? { fallbackText: assistantCompletion.fallbackText } : {}), @@ -1908,6 +2069,10 @@ const make = Effect.gen(function* () { updatedAt: now, }); } + + if (drainQueueAfterTurnFinalize) { + yield* dispatchQueueDrain(thread.id, event, now); + } } if (event.type === "session.exited") { @@ -1944,16 +2109,37 @@ const make = Effect.gen(function* () { } if (event.type === "thread.metadata.updated" && event.payload.name) { + // Upstream's guard (it also allows replacing a title that still equals + // the seed), with the fork's sanitisation kept: a provider-supplied name + // can carry control characters and arbitrary length. if (canReplaceThreadTitle(thread.title)) { - yield* orchestrationEngine.dispatch({ - type: "thread.meta.update", - commandId: yield* providerCommandId(event, "thread-meta-update"), - threadId: thread.id, - title: event.payload.name, - }); + const sanitized = sanitizeTitle(event.payload.name); + if (sanitized.length > 0) { + yield* orchestrationEngine.dispatch({ + type: "thread.meta.update", + commandId: yield* providerCommandId(event, "thread-meta-update"), + threadId: thread.id, + title: sanitized, + }); + } } } + // Provider-initiated mode changes (e.g. Grok entering plan mode via + // enter_plan_mode / session mode update) sync the thread interaction mode. + if ( + event.type === "session.mode.changed" && + thread.interactionMode !== event.payload.interactionMode + ) { + yield* orchestrationEngine.dispatch({ + type: "thread.interaction-mode.set", + commandId: yield* providerCommandId(event, "interaction-mode-set"), + threadId: thread.id, + interactionMode: event.payload.interactionMode, + createdAt: now, + }); + } + if (event.type === "turn.diff.updated") { const turnId = toTurnId(event.turnId); const checkpointContext = turnId @@ -2191,6 +2377,7 @@ export const ProviderRuntimeIngestionLive = Layer.effect( ProviderRuntimeIngestionService, make, ).pipe( + Layer.provide(ProjectionQueuedMessageRepositoryLive), Layer.provide(ProjectionThreadActivityRepositoryLive), Layer.provide(ProjectionThreadMessageRepositoryLive), Layer.provide(ProjectionThreadProposedPlanRepositoryLive), diff --git a/apps/server/src/orchestration/Layers/WorktreeLifecycle.test.ts b/apps/server/src/orchestration/Layers/WorktreeLifecycle.test.ts new file mode 100644 index 000000000000..0d62ee2d6ebb --- /dev/null +++ b/apps/server/src/orchestration/Layers/WorktreeLifecycle.test.ts @@ -0,0 +1,683 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, it } from "@effect/vitest"; +import { + DEFAULT_PROVIDER_INTERACTION_MODE, + ProjectId, + ProviderInstanceId, + ThreadId, + WorktreeLifecycleError, + type ModelSelection, +} from "@t3tools/contracts"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; +import type * as Scope from "effect/Scope"; + +import { ServerConfig } from "../../config.ts"; +import { GitWorkflowService } from "../../git/GitWorkflowService.ts"; +import { ProjectionThreadRepositoryLive } from "../../persistence/Layers/ProjectionThreads.ts"; +import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts"; +import { + ProjectionThreadRepository, + type ProjectionThread, +} from "../../persistence/Services/ProjectionThreads.ts"; +import { ProjectSetupScriptRunner } from "../../project/ProjectSetupScriptRunner.ts"; +import { ProviderService } from "../../provider/Services/ProviderService.ts"; +import * as TerminalManager from "../../terminal/Manager.ts"; +import * as GitVcsDriver from "../../vcs/GitVcsDriver.ts"; +import { VcsStatusBroadcaster } from "../../vcs/VcsStatusBroadcaster.ts"; +import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; +import { WorktreeLifecycle } from "../Services/WorktreeLifecycle.ts"; +import { WorktreeLifecycleLive } from "./WorktreeLifecycle.ts"; + +const isWorktreeLifecycleError = Schema.is(WorktreeLifecycleError); + +const now = "2026-03-01T00:00:00.000Z"; +const projectId = ProjectId.make("project-1"); +const modelSelection: ModelSelection = { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", +}; + +interface HarnessRefs { + workspaceRoot: string; + readonly stopSessionCalls: Array; + readonly terminalCloseCalls: Array; + readonly setupScriptCalls: Array<{ readonly threadId: string; readonly worktreePath: string }>; + removeWorktreeStarted: Deferred.Deferred | null; + removeWorktreeRelease: Deferred.Deferred | null; +} + +const makeRefs = (): HarnessRefs => ({ + workspaceRoot: "", + stopSessionCalls: [], + terminalCloseCalls: [], + setupScriptCalls: [], + removeWorktreeStarted: null, + removeWorktreeRelease: null, +}); + +const emptyVcsStatus = { + isRepo: true, + hasPrimaryRemote: false, + isDefaultRef: false, + refName: null, + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: false, + aheadCount: 0, + behindCount: 0, + pr: null, +}; + +const gitWorkflowFromDriver = (refs: HarnessRefs) => + Layer.unwrap( + Effect.gen(function* () { + const driver = yield* GitVcsDriver.GitVcsDriver; + return Layer.mock(GitWorkflowService)({ + createWorktree: (input) => driver.createWorktree(input), + removeWorktree: (input) => + Effect.gen(function* () { + if (refs.removeWorktreeStarted) { + yield* Deferred.succeed(refs.removeWorktreeStarted, undefined); + } + if (refs.removeWorktreeRelease) { + yield* Deferred.await(refs.removeWorktreeRelease); + } + yield* driver.removeWorktree(input); + }), + }); + }), + ); + +const makeTestLayer = (refs: HarnessRefs) => + WorktreeLifecycleLive.pipe( + Layer.provideMerge(ProjectionThreadRepositoryLive), + Layer.provideMerge( + Layer.mock(ProjectionSnapshotQuery)({ + getProjectShellById: (id) => + Effect.sync(() => + id === projectId && refs.workspaceRoot.length > 0 + ? Option.some({ + id: projectId, + title: "Project 1", + workspaceRoot: refs.workspaceRoot, + repositoryIdentity: null, + defaultModelSelection: modelSelection, + scripts: [], + createdAt: now, + updatedAt: now, + }) + : Option.none(), + ), + }), + ), + Layer.provideMerge( + Layer.mock(ProviderService)({ + stopSession: ({ threadId }) => + Effect.sync(() => { + refs.stopSessionCalls.push(threadId); + }), + }), + ), + Layer.provideMerge( + Layer.mock(TerminalManager.TerminalManager)({ + close: (input) => + Effect.sync(() => { + refs.terminalCloseCalls.push(input.threadId); + }), + }), + ), + Layer.provideMerge( + Layer.mock(VcsStatusBroadcaster)({ + refreshStatus: () => Effect.succeed(emptyVcsStatus), + }), + ), + Layer.provideMerge( + Layer.mock(ProjectSetupScriptRunner)({ + runForThread: (input) => + Effect.sync(() => { + refs.setupScriptCalls.push({ + threadId: input.threadId, + worktreePath: input.worktreePath, + }); + return { status: "no-script" } as const; + }), + }), + ), + Layer.provideMerge(gitWorkflowFromDriver(refs)), + Layer.provideMerge( + GitVcsDriver.layer.pipe( + Layer.provide( + ServerConfig.layerTest(process.cwd(), { prefix: "t3-worktree-lifecycle-config-" }), + ), + ), + ), + Layer.provideMerge(SqlitePersistenceMemory), + Layer.provideMerge(NodeServices.layer), + ); + +const git = (cwd: string, args: ReadonlyArray) => + Effect.gen(function* () { + const driver = yield* GitVcsDriver.GitVcsDriver; + const result = yield* driver.execute({ + operation: "WorktreeLifecycle.test.git", + cwd, + args, + timeoutMs: 10_000, + }); + return result.stdout.trim(); + }); + +/** Creates a real repo with an initial commit plus a feature-branch worktree. */ +const setupRepoWithWorktree = Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const driver = yield* GitVcsDriver.GitVcsDriver; + + const repoDir = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-worktree-lifecycle-repo-", + }); + yield* driver.initRepo({ cwd: repoDir }); + yield* git(repoDir, ["config", "user.email", "test@test.com"]); + yield* git(repoDir, ["config", "user.name", "Test"]); + yield* fileSystem.writeFileString(pathService.join(repoDir, "README.md"), "# test\n"); + yield* git(repoDir, ["add", "."]); + yield* git(repoDir, ["-c", "commit.gpgsign=false", "commit", "-m", "initial commit"]); + const initialBranch = yield* git(repoDir, ["branch", "--show-current"]); + + const worktreesDir = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-worktree-lifecycle-wt-", + }); + const worktreePath = pathService.join(worktreesDir, "feature-1"); + yield* driver.createWorktree({ + cwd: repoDir, + refName: initialBranch, + newRefName: "feature-1", + path: worktreePath, + }); + + return { repoDir, worktreePath, initialBranch, branch: "feature-1" }; +}); + +const makeThreadRow = (input: { + readonly threadId: string; + readonly branch: string | null; + readonly worktreePath: string | null; + readonly archivedAt?: string | null; + readonly deletedAt?: string | null; +}): ProjectionThread => ({ + threadId: ThreadId.make(input.threadId), + projectId, + title: `Thread ${input.threadId}`, + modelSelection, + runtimeMode: "full-access", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + branch: input.branch, + worktreePath: input.worktreePath, + latestTurnId: null, + createdAt: now, + updatedAt: now, + archivedAt: input.archivedAt ?? null, + settledOverride: null, + settledAt: null, + unsettledAt: null, + snoozedUntil: null, + pinnedAt: null, + snoozedAt: null, + latestUserMessageAt: null, + pendingApprovalCount: 0, + pendingUserInputCount: 0, + hasActionableProposedPlan: 0, + deletedAt: input.deletedAt ?? null, +}); + +const seedThreads = (rows: ReadonlyArray) => + Effect.gen(function* () { + const repository = yield* ProjectionThreadRepository; + yield* Effect.forEach(rows, (row) => repository.upsert(row), { discard: true }); + }); + +const runWithHarness = ( + refs: HarnessRefs, + body: Effect.Effect< + A, + E, + | WorktreeLifecycle + | ProjectionThreadRepository + | GitVcsDriver.GitVcsDriver + | FileSystem.FileSystem + | Path.Path + | Scope.Scope + >, +) => Effect.scoped(body).pipe(Effect.provide(makeTestLayer(refs))); + +it.effect("preview returns a candidate for the only active worktree thread", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ threadId: "t1", branch: repo.branch, worktreePath: repo.worktreePath }), + ]); + + const preview = yield* lifecycle.previewCleanup({ threadId: ThreadId.make("t1") }); + assert.deepStrictEqual(preview.candidate, { + worktreePath: repo.worktreePath, + branch: repo.branch, + }); + }), + ); +}); + +it.effect("preview returns no candidate when another active thread shares the path", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ threadId: "t1", branch: repo.branch, worktreePath: repo.worktreePath }), + makeThreadRow({ threadId: "t2", branch: repo.branch, worktreePath: repo.worktreePath }), + ]); + + const preview = yield* lifecycle.previewCleanup({ threadId: ThreadId.make("t1") }); + assert.isNull(preview.candidate); + }), + ); +}); + +it.effect("archived and deleted siblings do not prevent a candidate", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ threadId: "t1", branch: repo.branch, worktreePath: repo.worktreePath }), + makeThreadRow({ + threadId: "t2", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }), + makeThreadRow({ + threadId: "t3", + branch: repo.branch, + worktreePath: repo.worktreePath, + deletedAt: now, + }), + ]); + + const preview = yield* lifecycle.previewCleanup({ threadId: ThreadId.make("t1") }); + assert.deepStrictEqual(preview.candidate, { + worktreePath: repo.worktreePath, + branch: repo.branch, + }); + }), + ); +}); + +it.effect("preview treats different normalized spellings of the path as one worktree", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ threadId: "t1", branch: repo.branch, worktreePath: repo.worktreePath }), + // Same worktree spelled with a trailing separator. + makeThreadRow({ + threadId: "t2", + branch: repo.branch, + worktreePath: `${repo.worktreePath}/`, + }), + ]); + + const preview = yield* lifecycle.previewCleanup({ threadId: ThreadId.make("t1") }); + assert.isNull(preview.candidate); + }), + ); +}); + +it.effect("preview returns no candidate without a retained branch", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ threadId: "t1", branch: null, worktreePath: repo.worktreePath }), + ]); + + const preview = yield* lifecycle.previewCleanup({ threadId: ThreadId.make("t1") }); + assert.isNull(preview.candidate); + }), + ); +}); + +it.effect( + "cleanup force-removes a dirty worktree, preserves the branch, and stops archived runtimes", + () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }), + makeThreadRow({ + threadId: "t2", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }), + ]); + // Make the worktree dirty so a non-forced removal would fail. + yield* fileSystem.writeFileString( + pathService.join(repo.worktreePath, "dirty.txt"), + "uncommitted\n", + ); + + const result = yield* lifecycle.cleanupThreadWorktree({ threadId: ThreadId.make("t1") }); + assert.strictEqual(result.status, "removed"); + assert.strictEqual(yield* fileSystem.exists(repo.worktreePath), false); + // The branch survives removal so the worktree stays restorable. + const branches = yield* git(repo.repoDir, ["branch", "--list", repo.branch]); + assert.include(branches, repo.branch); + // Every archived reference had its runtime stopped. + assert.sameMembers(refs.stopSessionCalls, ["t1", "t2"]); + assert.sameMembers(refs.terminalCloseCalls, ["t1", "t2"]); + }), + ); + }, +); + +it.effect("cleanup is retained when a reference becomes active after preview", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }), + // Unarchived (active) sibling appeared between preview and cleanup. + makeThreadRow({ threadId: "t2", branch: repo.branch, worktreePath: repo.worktreePath }), + ]); + + const result = yield* lifecycle.cleanupThreadWorktree({ threadId: ThreadId.make("t1") }); + assert.strictEqual(result.status, "retained-active"); + assert.strictEqual(yield* fileSystem.exists(repo.worktreePath), true); + assert.lengthOf(refs.stopSessionCalls, 0); + }), + ); +}); + +it.effect("cleanup is retained when the target thread itself became active again", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ threadId: "t1", branch: repo.branch, worktreePath: repo.worktreePath }), + ]); + + const result = yield* lifecycle.cleanupThreadWorktree({ threadId: ThreadId.make("t1") }); + assert.strictEqual(result.status, "retained-active"); + assert.strictEqual(yield* fileSystem.exists(repo.worktreePath), true); + }), + ); +}); + +it.effect("cleanup reports an already-missing path without failing", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + yield* seedThreads([ + makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }), + ]); + yield* fileSystem.remove(repo.worktreePath, { recursive: true }); + + const result = yield* lifecycle.cleanupThreadWorktree({ threadId: ThreadId.make("t1") }); + assert.strictEqual(result.status, "already-missing"); + }), + ); +}); + +it.effect("cleanup failures surface as a typed WorktreeLifecycleError", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + // Points at an existing directory that is not a registered worktree, so + // `git worktree remove` fails. + const bogusPath = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-worktree-lifecycle-bogus-", + }); + yield* seedThreads([ + makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: bogusPath, + archivedAt: now, + }), + ]); + + const result = yield* Effect.flip( + lifecycle.cleanupThreadWorktree({ threadId: ThreadId.make("t1") }), + ); + assert.isTrue(isWorktreeLifecycleError(result)); + assert.strictEqual(result.operation, "cleanup"); + }), + ); +}); + +it.effect("unarchive restoration recreates a missing worktree and runs the setup script", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const driver = yield* GitVcsDriver.GitVcsDriver; + const repository = yield* ProjectionThreadRepository; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + const row = makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }); + yield* seedThreads([row]); + yield* driver.removeWorktree({ cwd: repo.repoDir, path: repo.worktreePath, force: true }); + assert.strictEqual(yield* fileSystem.exists(repo.worktreePath), false); + + let committed = false; + const commit = repository.upsert({ ...row, archivedAt: null }).pipe( + Effect.tap(() => + Effect.sync(() => { + committed = true; + }), + ), + Effect.as({ sequence: 1 }), + ); + const result = yield* lifecycle.restoreThreadWorktree({ threadId: row.threadId }, commit); + assert.deepStrictEqual(result, { sequence: 1 }); + assert.isTrue(committed); + assert.strictEqual(yield* fileSystem.exists(repo.worktreePath), true); + const worktrees = yield* git(repo.repoDir, ["worktree", "list", "--porcelain"]); + assert.include(worktrees, repo.worktreePath); + const branchInWorktree = yield* git(repo.worktreePath, ["branch", "--show-current"]); + assert.strictEqual(branchInWorktree, repo.branch); + assert.deepStrictEqual(refs.setupScriptCalls, [ + { threadId: "t1", worktreePath: repo.worktreePath }, + ]); + }), + ); +}); + +it.effect("unarchive restoration is a no-op when the worktree still exists", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + const row = makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }); + yield* seedThreads([row]); + + let committed = false; + const commit = Effect.sync(() => { + committed = true; + return { sequence: 1 }; + }); + yield* lifecycle.restoreThreadWorktree({ threadId: row.threadId }, commit); + assert.isTrue(committed); + assert.lengthOf(refs.setupScriptCalls, 0); + }), + ); +}); + +it.effect("failed recreation leaves the thread archived and never commits", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const driver = yield* GitVcsDriver.GitVcsDriver; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + const row = makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }); + yield* seedThreads([row]); + yield* driver.removeWorktree({ cwd: repo.repoDir, path: repo.worktreePath, force: true }); + // Delete the branch so recreation cannot succeed. + yield* git(repo.repoDir, ["branch", "-D", repo.branch]); + + let committed = false; + const commit = Effect.sync(() => { + committed = true; + return { sequence: 1 }; + }); + const error = yield* Effect.flip( + lifecycle.restoreThreadWorktree({ threadId: row.threadId }, commit), + ); + assert.isTrue(isWorktreeLifecycleError(error)); + assert.strictEqual((error as WorktreeLifecycleError).operation, "restore"); + assert.isFalse(committed); + assert.lengthOf(refs.setupScriptCalls, 0); + }), + ); +}); + +it.effect("concurrent cleanup and unarchive restoration serialize on the worktree lock", () => { + const refs = makeRefs(); + return runWithHarness( + refs, + Effect.gen(function* () { + const lifecycle = yield* WorktreeLifecycle; + const fileSystem = yield* FileSystem.FileSystem; + const repository = yield* ProjectionThreadRepository; + const repo = yield* setupRepoWithWorktree; + refs.workspaceRoot = repo.repoDir; + const row = makeThreadRow({ + threadId: "t1", + branch: repo.branch, + worktreePath: repo.worktreePath, + archivedAt: now, + }); + yield* seedThreads([row]); + + refs.removeWorktreeStarted = yield* Deferred.make(); + refs.removeWorktreeRelease = yield* Deferred.make(); + + const cleanupFiber = yield* lifecycle + .cleanupThreadWorktree({ threadId: row.threadId }) + .pipe(Effect.forkScoped); + // Cleanup holds the per-path lock and is mid-removal. + yield* Deferred.await(refs.removeWorktreeStarted); + + const commit = repository.upsert({ ...row, archivedAt: null }).pipe(Effect.asVoid); + const restoreFiber = yield* lifecycle + .restoreThreadWorktree({ threadId: row.threadId }, commit) + .pipe(Effect.forkScoped); + yield* Deferred.succeed(refs.removeWorktreeRelease, undefined); + + const cleanupResult = yield* Fiber.join(cleanupFiber); + yield* Fiber.join(restoreFiber); + + // Restoration only ran after the removal finished: it saw the missing + // path and recreated the worktree instead of skipping restoration + // against a doomed checkout. + assert.strictEqual(cleanupResult.status, "removed"); + assert.strictEqual(yield* fileSystem.exists(repo.worktreePath), true); + const restored = yield* repository.getById({ threadId: row.threadId }); + assert.isTrue(Option.isSome(restored) && restored.value.archivedAt === null); + assert.deepStrictEqual(refs.setupScriptCalls, [ + { threadId: "t1", worktreePath: repo.worktreePath }, + ]); + }), + ); +}); diff --git a/apps/server/src/orchestration/Layers/WorktreeLifecycle.ts b/apps/server/src/orchestration/Layers/WorktreeLifecycle.ts new file mode 100644 index 000000000000..046d64b1da12 --- /dev/null +++ b/apps/server/src/orchestration/Layers/WorktreeLifecycle.ts @@ -0,0 +1,395 @@ +import { WorktreeLifecycleError, type ThreadId } from "@t3tools/contracts"; +import { normalizeProjectPathForComparison } from "@t3tools/shared/path"; +import * as Cause from "effect/Cause"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Semaphore from "effect/Semaphore"; +import * as SynchronizedRef from "effect/SynchronizedRef"; + +import { GitWorkflowService } from "../../git/GitWorkflowService.ts"; +import { + ProjectionThreadRepository, + type ProjectionThread, + type ProjectionThreadWorktreeReference, +} from "../../persistence/Services/ProjectionThreads.ts"; +import { ProjectSetupScriptRunner } from "../../project/ProjectSetupScriptRunner.ts"; +import { ProviderService } from "../../provider/Services/ProviderService.ts"; +import * as TerminalManager from "../../terminal/Manager.ts"; +import { VcsStatusBroadcaster } from "../../vcs/VcsStatusBroadcaster.ts"; +import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; +import { WorktreeLifecycle, type WorktreeLifecycleShape } from "../Services/WorktreeLifecycle.ts"; + +// Best-effort cleanup steps must not surface their own error types through +// the lifecycle API: swallow and log everything except interruption. +const swallowCauseUnlessInterrupted = (input: { + readonly effect: Effect.Effect; + readonly message: string; + readonly threadId: ThreadId; +}): Effect.Effect => + input.effect.pipe( + Effect.asVoid, + Effect.catchCause((cause) => { + if (Cause.hasInterruptsOnly(cause)) { + return Effect.failCause(cause as Cause.Cause); + } + return Effect.logDebug(input.message, { + threadId: input.threadId, + cause: Cause.pretty(cause), + }); + }), + ); + +function nonEmptyOrNull(value: string | null): string | null { + const trimmed = value?.trim(); + return trimmed && trimmed.length > 0 ? trimmed : null; +} + +const make = Effect.gen(function* () { + const threadRepository = yield* ProjectionThreadRepository; + const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; + const gitWorkflow = yield* GitWorkflowService; + const providerService = yield* ProviderService; + const terminalManager = yield* TerminalManager.TerminalManager; + const vcsStatusBroadcaster = yield* VcsStatusBroadcaster; + const setupScriptRunner = yield* ProjectSetupScriptRunner; + const fileSystem = yield* FileSystem.FileSystem; + + // Conditional removal and unarchive restoration serialize on the same + // per-normalized-path lock so a cleanup can never interleave with a + // restoration of the same worktree. + const pathLocksRef = yield* SynchronizedRef.make(new Map()); + const getPathSemaphore = (pathKey: string) => + SynchronizedRef.modifyEffect(pathLocksRef, (current) => { + const existing: Option.Option = Option.fromNullishOr( + current.get(pathKey), + ); + return Option.match(existing, { + onNone: () => + Semaphore.make(1).pipe( + Effect.map((semaphore) => { + const next = new Map(current); + next.set(pathKey, semaphore); + return [semaphore, next] as const; + }), + ), + onSome: (semaphore) => Effect.succeed([semaphore, current] as const), + }); + }); + const withWorktreePathLock = (pathKey: string, effect: Effect.Effect) => + Effect.flatMap(getPathSemaphore(pathKey), (semaphore) => semaphore.withPermit(effect)); + + const lifecycleError = (input: { + readonly operation: string; + readonly threadId: ThreadId; + readonly detail: string; + readonly cause?: unknown; + }) => + new WorktreeLifecycleError({ + operation: input.operation, + threadId: input.threadId, + detail: input.detail, + ...(input.cause !== undefined ? { cause: input.cause } : {}), + }); + + const loadNondeletedThreadRow = (operation: string, threadId: ThreadId) => + threadRepository.getById({ threadId }).pipe( + Effect.mapError((cause) => + lifecycleError({ operation, threadId, detail: "Failed to load thread state.", cause }), + ), + Effect.map(Option.filter((row: ProjectionThread) => row.deletedAt === null)), + ); + + const listWorktreeReferences = (operation: string, threadId: ThreadId) => + threadRepository.listWorktreeReferences().pipe( + Effect.mapError((cause) => + lifecycleError({ + operation, + threadId, + detail: "Failed to load worktree references.", + cause, + }), + ), + ); + + const referencesForPath = ( + references: ReadonlyArray, + normalizedPath: string, + ) => + references.filter( + (reference) => normalizeProjectPathForComparison(reference.worktreePath) === normalizedPath, + ); + + const requireProjectWorkspaceRoot = (input: { + readonly operation: string; + readonly thread: ProjectionThread; + }) => + projectionSnapshotQuery.getProjectShellById(input.thread.projectId).pipe( + Effect.mapError((cause) => + lifecycleError({ + operation: input.operation, + threadId: input.thread.threadId, + detail: "Failed to load the thread's project.", + cause, + }), + ), + Effect.flatMap( + Option.match({ + onNone: () => + Effect.fail( + lifecycleError({ + operation: input.operation, + threadId: input.thread.threadId, + detail: "The thread's project was not found.", + }), + ), + onSome: (project) => Effect.succeed(project.workspaceRoot), + }), + ), + ); + + const stopThreadRuntime = (threadId: ThreadId) => + swallowCauseUnlessInterrupted({ + effect: providerService.stopSession({ threadId }), + message: "worktree cleanup skipped provider session stop", + threadId, + }).pipe( + Effect.andThen( + swallowCauseUnlessInterrupted({ + effect: terminalManager.close({ threadId }), + message: "worktree cleanup skipped terminal close", + threadId, + }), + ), + ); + + const refreshVcsStatus = (workspaceRoot: string) => + vcsStatusBroadcaster + .refreshStatus(workspaceRoot) + .pipe(Effect.ignoreCause({ log: true }), Effect.forkDetach, Effect.asVoid); + + const worktreePathExists = (input: { + readonly operation: string; + readonly threadId: ThreadId; + readonly worktreePath: string; + }) => + fileSystem.exists(input.worktreePath).pipe( + Effect.mapError((cause) => + lifecycleError({ + operation: input.operation, + threadId: input.threadId, + detail: `Failed to inspect the worktree path ${input.worktreePath}.`, + cause, + }), + ), + ); + + const previewCleanup: WorktreeLifecycleShape["previewCleanup"] = Effect.fn( + "WorktreeLifecycle.previewCleanup", + )(function* ({ threadId }) { + const operation = "cleanup preview"; + const threadRow = yield* loadNondeletedThreadRow(operation, threadId); + if (Option.isNone(threadRow)) { + return { candidate: null }; + } + const thread = threadRow.value; + const worktreePath = nonEmptyOrNull(thread.worktreePath); + const branch = nonEmptyOrNull(thread.branch); + // Only an active thread with a restorable worktree (path + retained + // branch) can produce a candidate. + if (thread.archivedAt !== null || worktreePath === null || branch === null) { + return { candidate: null }; + } + + const normalizedPath = normalizeProjectPathForComparison(worktreePath); + const references = yield* listWorktreeReferences(operation, threadId); + const sharedWithActiveThread = referencesForPath(references, normalizedPath).some( + (reference) => reference.threadId !== threadId && reference.archivedAt === null, + ); + + return { + candidate: sharedWithActiveThread ? null : { worktreePath, branch }, + }; + }); + + const cleanupThreadWorktree: WorktreeLifecycleShape["cleanupThreadWorktree"] = Effect.fn( + "WorktreeLifecycle.cleanupThreadWorktree", + )(function* ({ threadId }) { + const operation = "cleanup"; + const threadRow = yield* loadNondeletedThreadRow(operation, threadId); + if (Option.isNone(threadRow)) { + return yield* lifecycleError({ operation, threadId, detail: "The thread was not found." }); + } + const thread = threadRow.value; + const worktreePath = nonEmptyOrNull(thread.worktreePath); + if (worktreePath === null) { + return yield* lifecycleError({ + operation, + threadId, + detail: "The thread has no worktree path recorded.", + }); + } + // A thread that was unarchived between confirmation and cleanup is an + // active reference again, not an error. + if (thread.archivedAt === null) { + return { status: "retained-active", worktreePath } as const; + } + + const workspaceRoot = yield* requireProjectWorkspaceRoot({ operation, thread }); + const normalizedPath = normalizeProjectPathForComparison(worktreePath); + + return yield* withWorktreePathLock( + normalizedPath, + Effect.gen(function* () { + // Mandatory recheck under the lock: another client may have + // unarchived or attached a thread since the preview. + const references = referencesForPath( + yield* listWorktreeReferences(operation, threadId), + normalizedPath, + ); + if (references.some((reference) => reference.archivedAt === null)) { + return { status: "retained-active", worktreePath } as const; + } + + // Every remaining reference is archived; make sure none of them + // still runs a provider session or terminal inside the worktree. + const threadIdsToStop = new Set([ + threadId, + ...references.map((reference) => reference.threadId), + ]); + yield* Effect.forEach(threadIdsToStop, stopThreadRuntime, { discard: true }); + + const exists = yield* worktreePathExists({ operation, threadId, worktreePath }); + if (!exists) { + return { status: "already-missing", worktreePath } as const; + } + + yield* gitWorkflow + .removeWorktree({ cwd: workspaceRoot, path: worktreePath, force: true }) + .pipe( + Effect.mapError((cause) => + lifecycleError({ + operation, + threadId, + detail: `Failed to remove the worktree at ${worktreePath}: ${cause.detail}`, + cause, + }), + ), + ); + + // Compensate for unavoidable external races: if an active reference + // appeared while the removal ran, recreate the worktree from the + // retained branch at the original path. + const postRemovalReferences = referencesForPath( + yield* listWorktreeReferences(operation, threadId), + normalizedPath, + ); + if (postRemovalReferences.some((reference) => reference.archivedAt === null)) { + const branch = nonEmptyOrNull(thread.branch); + if (branch === null) { + return yield* lifecycleError({ + operation, + threadId, + detail: `The worktree at ${worktreePath} was removed while another thread became active, and no branch is recorded to recreate it.`, + }); + } + yield* gitWorkflow + .createWorktree({ cwd: workspaceRoot, refName: branch, path: worktreePath }) + .pipe( + Effect.mapError((cause) => + lifecycleError({ + operation, + threadId, + detail: `Failed to recreate the worktree at ${worktreePath} after another thread became active.`, + cause, + }), + ), + ); + yield* refreshVcsStatus(workspaceRoot); + return { status: "retained-active", worktreePath } as const; + } + + yield* refreshVcsStatus(workspaceRoot); + return { status: "removed", worktreePath } as const; + }), + ); + }); + + const restoreThreadWorktree: WorktreeLifecycleShape["restoreThreadWorktree"] = ( + { threadId }: { readonly threadId: ThreadId }, + commitUnarchive: Effect.Effect, + ): Effect.Effect => + Effect.gen(function* () { + const operation = "restore"; + const threadRow = yield* loadNondeletedThreadRow(operation, threadId); + if (Option.isNone(threadRow)) { + // Let the dispatch path produce its canonical "unknown thread" error. + return yield* commitUnarchive; + } + const thread = threadRow.value; + const worktreePath = nonEmptyOrNull(thread.worktreePath); + if (worktreePath === null) { + return yield* commitUnarchive; + } + + const normalizedPath = normalizeProjectPathForComparison(worktreePath); + return yield* withWorktreePathLock( + normalizedPath, + Effect.gen(function* () { + const exists = yield* worktreePathExists({ operation, threadId, worktreePath }); + if (exists) { + return yield* commitUnarchive; + } + + const branch = nonEmptyOrNull(thread.branch); + if (branch === null) { + return yield* lifecycleError({ + operation, + threadId, + detail: `The worktree at ${worktreePath} is missing and no branch is recorded to recreate it. The thread stays archived.`, + }); + } + + const workspaceRoot = yield* requireProjectWorkspaceRoot({ operation, thread }); + yield* gitWorkflow + .createWorktree({ cwd: workspaceRoot, refName: branch, path: worktreePath }) + .pipe( + Effect.mapError((cause) => + lifecycleError({ + operation, + threadId, + detail: `Failed to recreate the worktree at ${worktreePath} from branch '${branch}': ${cause.detail}. The thread stays archived.`, + cause, + }), + ), + ); + yield* refreshVcsStatus(workspaceRoot); + + const result = yield* commitUnarchive; + + // The checkout was recreated from scratch, so dependencies and + // generated files are gone: run the worktree setup script again. + yield* swallowCauseUnlessInterrupted({ + effect: setupScriptRunner.runForThread({ + threadId, + projectId: thread.projectId, + worktreePath, + }), + message: "worktree restoration could not start the setup script", + threadId, + }); + + return result; + }), + ); + }); + + return { + previewCleanup, + cleanupThreadWorktree, + restoreThreadWorktree, + } satisfies WorktreeLifecycleShape; +}); + +export const WorktreeLifecycleLive = Layer.effect(WorktreeLifecycle, make); diff --git a/apps/server/src/orchestration/Schemas.ts b/apps/server/src/orchestration/Schemas.ts index 29468dc3f84e..e2e165325b3a 100644 --- a/apps/server/src/orchestration/Schemas.ts +++ b/apps/server/src/orchestration/Schemas.ts @@ -20,6 +20,8 @@ import { ThreadPullRequestUnlinkedPayload as ContractsThreadPullRequestUnlinkedPayloadSchema, ThreadPullRequestSyncedPayload as ContractsThreadPullRequestSyncedPayloadSchema, ThreadMessageSentPayload as ContractsThreadMessageSentPayloadSchema, + ThreadMessageQueuedPayload as ContractsThreadMessageQueuedPayloadSchema, + ThreadQueuedMessageRemovedPayload as ContractsThreadQueuedMessageRemovedPayloadSchema, ThreadProposedPlanUpsertedPayload as ContractsThreadProposedPlanUpsertedPayloadSchema, ThreadSessionSetPayload as ContractsThreadSessionSetPayloadSchema, ThreadTurnDiffCompletedPayload as ContractsThreadTurnDiffCompletedPayloadSchema, @@ -56,6 +58,8 @@ export const ThreadPullRequestUnlinkedPayload = ContractsThreadPullRequestUnlink export const ThreadPullRequestSyncedPayload = ContractsThreadPullRequestSyncedPayloadSchema; export const MessageSentPayloadSchema = ContractsThreadMessageSentPayloadSchema; +export const ThreadMessageQueuedPayload = ContractsThreadMessageQueuedPayloadSchema; +export const ThreadQueuedMessageRemovedPayload = ContractsThreadQueuedMessageRemovedPayloadSchema; export const ThreadProposedPlanUpsertedPayload = ContractsThreadProposedPlanUpsertedPayloadSchema; export const ThreadSessionSetPayload = ContractsThreadSessionSetPayloadSchema; export const ThreadTurnDiffCompletedPayload = ContractsThreadTurnDiffCompletedPayloadSchema; diff --git a/apps/server/src/orchestration/Services/OrchestrationEngine.ts b/apps/server/src/orchestration/Services/OrchestrationEngine.ts index cf2ef2a40354..910bad0d9cfe 100644 --- a/apps/server/src/orchestration/Services/OrchestrationEngine.ts +++ b/apps/server/src/orchestration/Services/OrchestrationEngine.ts @@ -41,7 +41,9 @@ export interface OrchestrationEngineShape { * @param fromSequenceExclusive - Sequence cursor (exclusive). * @param limit - Maximum number of events to read. Defaults to the event * store's page-bounded default; pass a higher value when the caller must - * read a wider global range. Thread subscriptions use readThreadEvents. + * read a wider global range. Callers must keep this bounded; use a + * projection snapshot instead of replaying an arbitrarily stale cursor. + * Thread subscriptions use readThreadEvents. * @returns Stream containing ordered events. */ readonly readEvents: ( diff --git a/apps/server/src/orchestration/Services/OrphanSessionRecovery.ts b/apps/server/src/orchestration/Services/OrphanSessionRecovery.ts new file mode 100644 index 000000000000..60d9aa0d76b9 --- /dev/null +++ b/apps/server/src/orchestration/Services/OrphanSessionRecovery.ts @@ -0,0 +1,66 @@ +/** + * Durable recovery for provider sessions that claim to be live but are not. + * + * After process death / server restarts the projection can stay `running` with + * an `activeTurnId` while no provider process exists. Reapers that skip active + * turns and resync that refuses `running` runtimes then deadlock the thread. + */ +import type { OrchestrationSession, ThreadId } from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import type * as Effect from "effect/Effect"; + +export type OrphanSessionRecoveryReason = + | "server_restart" + | "reaper_orphan_active_turn" + | "reaper_inactivity" + | "resync_zombie_running" + | "manual"; + +export interface OrphanSessionRecoveryShape { + /** + * Whether a provider adapter currently holds a live process for this thread. + */ + readonly hasLiveProcess: (threadId: ThreadId) => Effect.Effect; + + /** + * Force-settle orchestration session + provider runtime for one thread. + * Always clears `activeTurnId` and marks the session interrupted/stopped so + * turns project as terminal and resync can run. + */ + readonly settleThread: (input: { + readonly threadId: ThreadId; + readonly reason: OrphanSessionRecoveryReason; + /** + * Preferred terminal status when work was in progress. + * Zombie live sessions with no active turn always settle to `ready` + * (never Wake Required) regardless of this preference. + */ + readonly status?: Extract; + }) => Effect.Effect; + + /** + * Settle the thread only when it looks orphaned (claims running / has an + * active turn / runtime running) and no live provider process exists. + * + * @returns true when a settle was performed + */ + readonly settleIfOrphan: ( + threadId: ThreadId, + reason?: OrphanSessionRecoveryReason, + ) => Effect.Effect; + + /** + * Startup audit: settle every shell session still starting/running and every + * persisted runtime still marked running (no process can have survived a + * process restart). + */ + readonly settleAllAfterServerRestart: () => Effect.Effect<{ + readonly settledSessions: number; + readonly settledRuntimes: number; + }>; +} + +export class OrphanSessionRecovery extends Context.Service< + OrphanSessionRecovery, + OrphanSessionRecoveryShape +>()("t3/orchestration/Services/OrphanSessionRecovery") {} diff --git a/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts index 35d5bacc239c..e0a1b86c6dbe 100644 --- a/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts +++ b/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts @@ -12,12 +12,15 @@ import type { CheckpointRef, MessageId, OrchestrationCheckpointSummary, + OrchestrationGetThreadActivitiesInput, + OrchestrationGetThreadActivitiesResult, OrchestrationMessage, OrchestrationProject, OrchestrationProjectShell, OrchestrationReadModel, OrchestrationSearchThreadsInput, OrchestrationSearchThreadsResult, + OrchestrationSession, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadActivity, @@ -55,6 +58,11 @@ export interface ProjectionThreadCheckpointContext { readonly checkpoints: ReadonlyArray; } +export interface ProjectionSessionStopContext { + readonly threadId: ThreadId; + readonly session: OrchestrationSession | null; +} + export interface ProjectionFullThreadDiffContext { readonly threadId: ThreadId; readonly projectId: ProjectId; @@ -198,6 +206,18 @@ export interface ProjectionSnapshotQueryShape { toTurnCount: number, ) => Effect.Effect, ProjectionRepositoryError>; + /** + * Read the narrow context needed to stop a thread's provider session. + * + * Unlike the shell/detail queries this includes archived, nondeleted + * threads: session-stop commands dispatched as part of archiving must + * still resolve the thread after `archivedAt` is set, or the provider + * session would never be stopped. + */ + readonly getSessionStopContextById: ( + threadId: ThreadId, + ) => Effect.Effect, ProjectionRepositoryError>; + /** * Read a single active thread shell row by id. */ @@ -209,7 +229,7 @@ export interface ProjectionSnapshotQueryShape { readonly getThreadRuntimeContext: ( threadId: ThreadId, ) => Effect.Effect< - Option.Option>, + Option.Option>, ProjectionRepositoryError >; @@ -256,6 +276,29 @@ export interface ProjectionSnapshotQueryShape { threadId: ThreadId, window?: OrchestrationThreadDetailWindow, ) => Effect.Effect, ProjectionRepositoryError>; + + /** + * Cursor-paginated load of a thread's older activities (lazy-load / infinite + * scroll). Returns the page of activities immediately older than the provided + * sequence or unsequenced activity cursor, ascending, plus whether older ones + * remain. + */ + readonly getThreadActivitiesPage: ( + input: OrchestrationGetThreadActivitiesInput, + ) => Effect.Effect; + + /** + * Read a thread's lifecycle markers regardless of its deleted/archived + * state. Lets callers that got no active row distinguish a thread that was + * deleted or archived (permanent) from one whose projection row does not + * exist (possibly not projected yet). + */ + readonly getThreadLifecycleById: ( + threadId: ThreadId, + ) => Effect.Effect< + Option.Option<{ readonly deletedAt: string | null; readonly archivedAt: string | null }>, + ProjectionRepositoryError + >; } /** diff --git a/apps/server/src/orchestration/Services/WorktreeLifecycle.ts b/apps/server/src/orchestration/Services/WorktreeLifecycle.ts new file mode 100644 index 000000000000..79037509b601 --- /dev/null +++ b/apps/server/src/orchestration/Services/WorktreeLifecycle.ts @@ -0,0 +1,73 @@ +/** + * WorktreeLifecycle - Server-authoritative worktree cleanup and restoration. + * + * Owns the archive-time cleanup decision (preview + conditional removal) and + * the unarchive-time restoration of a missing worktree. All operations are + * keyed by thread id so clients never make the final safety decision about + * which path is removed or recreated. + * + * @module WorktreeLifecycle + */ +import type { + ThreadId, + WorktreeCleanupPreviewResult, + WorktreeCleanupResult, + WorktreeLifecycleError, +} from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import type * as Effect from "effect/Effect"; + +export interface WorktreeCleanupThreadInput { + readonly threadId: ThreadId; +} + +/** + * WorktreeLifecycleShape - Service API for thread worktree lifecycle. + */ +export interface WorktreeLifecycleShape { + /** + * Decide whether archiving this thread would orphan its worktree. + * + * Returns a candidate only when the thread is active, has both a branch + * and a worktree path (so removal stays restorable), and no other active + * nondeleted thread references the same normalized path. Clients use this + * only to decide whether to show the confirmation prompt. + */ + readonly previewCleanup: ( + input: WorktreeCleanupThreadInput, + ) => Effect.Effect; + + /** + * Force-remove the archived thread's worktree if it is still orphaned. + * + * Re-reads all nondeleted references under a per-path lock before + * removing, stops provider sessions and closes terminals that could still + * use the path, keeps the branch, and refreshes VCS status. Returns a + * structured status instead of failing when the worktree is retained or + * already missing. + */ + readonly cleanupThreadWorktree: ( + input: WorktreeCleanupThreadInput, + ) => Effect.Effect; + + /** + * Recreate a missing worktree before committing a thread unarchive. + * + * Runs `commitUnarchive` unchanged when no restoration is needed. When the + * recorded worktree path is missing, the worktree is recreated from the + * retained branch at the original path while holding the same per-path + * lock used by cleanup, and the commit is dispatched under that lock. If + * recreation fails the commit never runs, so the thread stays archived. + */ + readonly restoreThreadWorktree: ( + input: WorktreeCleanupThreadInput, + commitUnarchive: Effect.Effect, + ) => Effect.Effect; +} + +/** + * WorktreeLifecycle - Service tag for thread worktree lifecycle operations. + */ +export class WorktreeLifecycle extends Context.Service()( + "t3/orchestration/Services/WorktreeLifecycle", +) {} diff --git a/apps/server/src/orchestration/commandInvariants.test.ts b/apps/server/src/orchestration/commandInvariants.test.ts index a3db108f2020..24792f96d69f 100644 --- a/apps/server/src/orchestration/commandInvariants.test.ts +++ b/apps/server/src/orchestration/commandInvariants.test.ts @@ -10,12 +10,19 @@ import { ProviderInstanceId, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; -import { listThreadsByProjectId, requireThread, requireThreadAbsent } from "./commandInvariants.ts"; +import { fromWireReadModel, type CommandReadModel } from "./commandReadModel.ts"; +import { + findThreadById, + listThreadsByProjectId, + requireThread, + requireThreadAbsent, +} from "./commandInvariants.ts"; const now = "2026-01-01T00:00:00.000Z"; -const readModel: OrchestrationReadModel = { +const wireReadModel: OrchestrationReadModel = { snapshotSequence: 2, updatedAt: now, projects: [ @@ -67,6 +74,8 @@ const readModel: OrchestrationReadModel = { settledAt: null, latestTurn: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, session: null, activities: [], proposedPlans: [], @@ -93,6 +102,8 @@ const readModel: OrchestrationReadModel = { settledAt: null, latestTurn: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, session: null, activities: [], proposedPlans: [], @@ -102,6 +113,8 @@ const readModel: OrchestrationReadModel = { ], }; +const readModel = fromWireReadModel(wireReadModel, { dropDeletedThreads: false }); + const messageSendCommand: OrchestrationCommand = { type: "thread.turn.start", commandId: CommandId.make("cmd-1"), @@ -197,12 +210,14 @@ describe("commandInvariants", () => { it("lets a draft retry re-create a thread id after its first attempt was deleted", async () => { const threadId = ThreadId.make("thread-1"); - const firstAttempt = readModel.threads.find((thread) => thread.id === threadId)!; - const afterRollback: OrchestrationReadModel = { + const firstAttempt = findThreadById(readModel, threadId)!; + const afterRollback: CommandReadModel = { ...readModel, - threads: readModel.threads.map((thread) => - thread.id === threadId ? { ...thread, deletedAt: now, updatedAt: now } : thread, - ), + threads: HashMap.set(readModel.threads, threadId, { + ...firstAttempt, + deletedAt: now, + updatedAt: now, + }), }; const retry: OrchestrationCommand = { type: "thread.create", diff --git a/apps/server/src/orchestration/commandInvariants.ts b/apps/server/src/orchestration/commandInvariants.ts index 873eab007bea..bebb56ebbdf3 100644 --- a/apps/server/src/orchestration/commandInvariants.ts +++ b/apps/server/src/orchestration/commandInvariants.ts @@ -1,16 +1,24 @@ import type { OrchestrationCommand, OrchestrationProject, - OrchestrationReadModel, OrchestrationThread, ProjectId, ThreadId, } from "@t3tools/contracts"; import { normalizeProjectPathForComparison } from "@t3tools/shared/path"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; +import { + findProjectById, + findThreadById, + listThreadsByProjectId, + type CommandReadModel, +} from "./commandReadModel.ts"; import { OrchestrationCommandInvariantError } from "./Errors.ts"; +export { findProjectById, findThreadById, listThreadsByProjectId }; + function invariantError(commandType: string, detail: string): OrchestrationCommandInvariantError { return new OrchestrationCommandInvariantError({ commandType, @@ -18,29 +26,8 @@ function invariantError(commandType: string, detail: string): OrchestrationComma }); } -function findThreadById( - readModel: OrchestrationReadModel, - threadId: ThreadId, -): OrchestrationThread | undefined { - return readModel.threads.find((thread) => thread.id === threadId); -} - -function findProjectById( - readModel: OrchestrationReadModel, - projectId: ProjectId, -): OrchestrationProject | undefined { - return readModel.projects.find((project) => project.id === projectId); -} - -export function listThreadsByProjectId( - readModel: OrchestrationReadModel, - projectId: ProjectId, -): ReadonlyArray { - return readModel.threads.filter((thread) => thread.projectId === projectId); -} - export function requireProject(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly projectId: ProjectId; }): Effect.Effect { @@ -57,7 +44,7 @@ export function requireProject(input: { } export function requireProjectAbsent(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly projectId: ProjectId; }): Effect.Effect { @@ -73,18 +60,23 @@ export function requireProjectAbsent(input: { } export function requireActiveProjectWorkspaceRootAbsent(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly workspaceRoot: string; readonly exceptProjectId?: ProjectId; }): Effect.Effect { const normalizedWorkspaceRoot = normalizeProjectPathForComparison(input.workspaceRoot); - const existingProject = input.readModel.projects.find( - (project) => + let existingProject: OrchestrationProject | undefined; + for (const project of HashMap.values(input.readModel.projects)) { + if ( project.deletedAt === null && normalizeProjectPathForComparison(project.workspaceRoot) === normalizedWorkspaceRoot && - project.id !== input.exceptProjectId, - ); + project.id !== input.exceptProjectId + ) { + existingProject = project; + break; + } + } if (existingProject === undefined) { return Effect.void; } @@ -97,7 +89,7 @@ export function requireActiveProjectWorkspaceRootAbsent(input: { } export function requireThread(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly threadId: ThreadId; }): Effect.Effect { @@ -114,7 +106,7 @@ export function requireThread(input: { } export function requireThreadArchived(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly threadId: ThreadId; }): Effect.Effect { @@ -133,7 +125,7 @@ export function requireThreadArchived(input: { } export function requireThreadNotArchived(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly threadId: ThreadId; }): Effect.Effect { @@ -152,13 +144,14 @@ export function requireThreadNotArchived(input: { } export function requireThreadAbsent(input: { - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly command: OrchestrationCommand; readonly threadId: ThreadId; }): Effect.Effect { - // Thread deletion is a soft delete and a draft keeps its client-minted id - // across retries, so only a live row blocks creation. Projectors reset the - // thread's rows when the id is created again. + // Deleted threads are evicted from `threads` (ids may remain in + // `deletedThreadIds`). A draft keeps its client-minted id across retries, so + // only a live row blocks creation. Projectors reset the thread's rows when + // the id is created again. const existing = findThreadById(input.readModel, input.threadId); if (existing === undefined || existing.deletedAt !== null) { return Effect.void; diff --git a/apps/server/src/orchestration/commandReadModel.test.ts b/apps/server/src/orchestration/commandReadModel.test.ts new file mode 100644 index 000000000000..ae840154be01 --- /dev/null +++ b/apps/server/src/orchestration/commandReadModel.test.ts @@ -0,0 +1,138 @@ +import { + DEFAULT_PROVIDER_INTERACTION_MODE, + ProjectId, + ProviderInstanceId, + ThreadId, + type OrchestrationReadModel, + type OrchestrationThread, +} from "@t3tools/contracts"; +import * as HashMap from "effect/HashMap"; +import { describe, expect, it } from "vite-plus/test"; + +import { + createEmptyCommandReadModel, + findProjectById, + findThreadById, + fromWireReadModel, + isThreadDeleted, + listThreadsByProjectId, +} from "./commandReadModel.ts"; + +const now = "2026-01-01T00:00:00.000Z"; + +function makeThread( + id: string, + projectId: string, + overrides?: Partial, +): OrchestrationThread { + return { + id: ThreadId.make(id), + projectId: ProjectId.make(projectId), + title: id, + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "full-access", + branch: null, + worktreePath: null, + pullRequests: [], + createdAt: now, + updatedAt: now, + archivedAt: null, + settledOverride: null, + settledAt: null, + snoozedUntil: null, + snoozedAt: null, + hasMoreActivities: false, + latestTurn: null, + messages: [], + queuedMessages: [], + pendingTurnStart: null, + session: null, + activities: [], + proposedPlans: [], + checkpoints: [], + deletedAt: null, + ...overrides, + }; +} + +const wireReadModel: OrchestrationReadModel = { + snapshotSequence: 5, + updatedAt: now, + projects: [ + { + id: ProjectId.make("project-a"), + title: "Project A", + workspaceRoot: "/tmp/project-a", + defaultModelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + scripts: [], + createdAt: now, + updatedAt: now, + deletedAt: null, + }, + ], + threads: [ + makeThread("thread-live", "project-a"), + makeThread("thread-archived", "project-a", { archivedAt: now }), + makeThread("thread-deleted", "project-a", { deletedAt: now }), + makeThread("thread-other", "project-b"), + ], +}; + +describe("commandReadModel", () => { + it("creates an empty model", () => { + const model = createEmptyCommandReadModel(now); + expect(model.snapshotSequence).toBe(0); + expect(HashMap.size(model.threads)).toBe(0); + expect(HashMap.size(model.projects)).toBe(0); + expect(model.updatedAt).toBe(now); + }); + + it("seeds from the wire model and drops deleted threads by default", () => { + const model = fromWireReadModel(wireReadModel); + expect(model.snapshotSequence).toBe(5); + // deleted thread is evicted; archived + live + other retained + expect(HashMap.size(model.threads)).toBe(3); + expect(HashMap.has(model.threads, ThreadId.make("thread-deleted"))).toBe(false); + expect(HashMap.has(model.threads, ThreadId.make("thread-archived"))).toBe(true); + expect(HashMap.has(model.threads, ThreadId.make("thread-live"))).toBe(true); + expect(HashMap.size(model.projects)).toBe(1); + // The evicted deleted thread's id is retained so the create-twice invariant + // survives a restart. + expect(isThreadDeleted(model, ThreadId.make("thread-deleted"))).toBe(true); + expect(isThreadDeleted(model, ThreadId.make("thread-live"))).toBe(false); + expect(isThreadDeleted(model, ThreadId.make("thread-archived"))).toBe(false); + }); + + it("retains deleted threads when dropDeletedThreads is false", () => { + const model = fromWireReadModel(wireReadModel, { dropDeletedThreads: false }); + expect(HashMap.size(model.threads)).toBe(4); + expect(HashMap.has(model.threads, ThreadId.make("thread-deleted"))).toBe(true); + }); + + it("finds threads and projects by id with O(1) lookups", () => { + const model = fromWireReadModel(wireReadModel); + expect(findThreadById(model, ThreadId.make("thread-live"))?.projectId).toBe("project-a"); + expect(findThreadById(model, ThreadId.make("thread-deleted"))).toBeUndefined(); + expect(findThreadById(model, ThreadId.make("missing"))).toBeUndefined(); + expect(findProjectById(model, ProjectId.make("project-a"))?.title).toBe("Project A"); + expect(findProjectById(model, ProjectId.make("missing"))).toBeUndefined(); + }); + + it("lists threads by project id", () => { + const model = fromWireReadModel(wireReadModel); + const ids = listThreadsByProjectId(model, ProjectId.make("project-a")) + .map((thread) => thread.id) + .toSorted(); + expect(ids).toEqual([ThreadId.make("thread-archived"), ThreadId.make("thread-live")]); + expect(listThreadsByProjectId(model, ProjectId.make("project-b")).map((t) => t.id)).toEqual([ + ThreadId.make("thread-other"), + ]); + }); +}); diff --git a/apps/server/src/orchestration/commandReadModel.ts b/apps/server/src/orchestration/commandReadModel.ts new file mode 100644 index 000000000000..dce19fc2842f --- /dev/null +++ b/apps/server/src/orchestration/commandReadModel.ts @@ -0,0 +1,119 @@ +import type { + OrchestrationProject, + OrchestrationReadModel, + OrchestrationThread, + ProjectId, + ThreadId, +} from "@t3tools/contracts"; +import * as HashMap from "effect/HashMap"; +import * as HashSet from "effect/HashSet"; +import * as Option from "effect/Option"; + +/** + * Server-internal representation of the orchestration read model. + * + * Unlike the wire {@link OrchestrationReadModel} (which uses arrays and is + * produced by the DB-backed `ProjectionSnapshotQuery`), this model is only ever + * touched by the single serial command-worker fiber in `OrchestrationEngine`. + * It uses persistent `HashMap`s keyed by id so the projector and command + * invariants get O(1)-ish lookups and single-key updates instead of O(N) + * array scans and full-array copies on every event. + * + * The model is never serialized or sent over the wire, so its shape can evolve + * independently of the contract. + */ +export interface CommandReadModel { + readonly snapshotSequence: number; + readonly projects: HashMap.HashMap; + readonly threads: HashMap.HashMap; + /** + * Ids of threads that have been deleted. Deleted threads are evicted from + * `threads` (freeing their message/activity/checkpoint arrays), but their id + * is retained here so `requireThreadAbsent` still rejects re-creating a + * thread with a previously-used id — the "cannot be created twice" invariant + * the DB projection also upholds (its tombstone row is never removed). + */ + readonly deletedThreadIds: HashSet.HashSet; + readonly updatedAt: string; +} + +export function createEmptyCommandReadModel(nowIso: string): CommandReadModel { + return { + snapshotSequence: 0, + projects: HashMap.empty(), + threads: HashMap.empty(), + deletedThreadIds: HashSet.empty(), + updatedAt: nowIso, + }; +} + +/** + * Whether a thread id has been used and deleted. Used by `requireThreadAbsent` + * so an evicted (deleted) thread's id cannot be re-created. + */ +export function isThreadDeleted(model: CommandReadModel, threadId: ThreadId): boolean { + return HashSet.has(model.deletedThreadIds, threadId); +} + +/** + * Seed a {@link CommandReadModel} from the array-based wire read model produced + * by `ProjectionSnapshotQuery.getCommandReadModel()` at engine boot. + * + * Deleted threads are dropped so the in-memory model starts consistent with the + * projector's eviction policy (deleted threads are removed, archived threads are + * retained). The DB projection remains the source of truth for deleted rows. + */ +export function fromWireReadModel( + model: OrchestrationReadModel, + options?: { readonly dropDeletedThreads?: boolean }, +): CommandReadModel { + const dropDeletedThreads = options?.dropDeletedThreads ?? true; + const threads = dropDeletedThreads + ? model.threads.filter((thread) => thread.deletedAt === null) + : model.threads; + // Retain the ids of deleted threads so the create-twice invariant survives + // a restart even though the (evicted) thread bodies are not loaded. + const deletedThreadIds = HashSet.fromIterable( + model.threads.filter((thread) => thread.deletedAt !== null).map((thread) => thread.id), + ); + return { + snapshotSequence: model.snapshotSequence, + updatedAt: model.updatedAt, + projects: HashMap.fromIterable(model.projects.map((project) => [project.id, project] as const)), + threads: HashMap.fromIterable(threads.map((thread) => [thread.id, thread] as const)), + deletedThreadIds, + }; +} + +export function findThreadById( + model: CommandReadModel, + threadId: ThreadId, +): OrchestrationThread | undefined { + return Option.getOrUndefined(HashMap.get(model.threads, threadId)); +} + +export function findProjectById( + model: CommandReadModel, + projectId: ProjectId, +): OrchestrationProject | undefined { + return Option.getOrUndefined(HashMap.get(model.projects, projectId)); +} + +export function listThreadsByProjectId( + model: CommandReadModel, + projectId: ProjectId, +): ReadonlyArray { + const result: OrchestrationThread[] = []; + for (const thread of HashMap.values(model.threads)) { + if (thread.projectId === projectId) { + result.push(thread); + } + } + // HashMap iteration order is not insertion order; sort by creation time (then + // id) so callers observe a stable, deterministic order — matching the prior + // array-backed behavior. Only used by the rare `project.delete` fan-out. + return result.toSorted( + (left, right) => + left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id), + ); +} diff --git a/apps/server/src/orchestration/decider.active-order.test.ts b/apps/server/src/orchestration/decider.active-order.test.ts index 39bccba11460..dca38844dcc0 100644 --- a/apps/server/src/orchestration/decider.active-order.test.ts +++ b/apps/server/src/orchestration/decider.active-order.test.ts @@ -4,13 +4,13 @@ import { ProviderInstanceId, ThreadId, type OrchestrationCommand, - type OrchestrationReadModel, type OrchestrationThread, } from "@t3tools/contracts"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import { findThreadById, fromWireReadModel, type CommandReadModel } from "./commandReadModel.ts"; import { decideOrchestrationCommand } from "./decider.ts"; import { projectEvent } from "./projector.ts"; @@ -21,8 +21,8 @@ const SNOOZED_AT = "1969-12-31T00:00:00.000Z"; const FUTURE_WAKE = "1970-01-02T00:00:00.000Z"; const THREAD_ID = ThreadId.make("thread-1"); -function makeReadModel(overrides: Partial = {}): OrchestrationReadModel { - return { +function makeReadModel(overrides: Partial = {}): CommandReadModel { + return fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -50,6 +50,8 @@ function makeReadModel(overrides: Partial = {}): Orchestrat pinOrderKey: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -58,7 +60,7 @@ function makeReadModel(overrides: Partial = {}): Orchestrat }, ], updatedAt: NOW, - }; + }); } const reorderCommand = { @@ -89,7 +91,7 @@ it.layer(NodeServices.layer)("active thread ordering", (it) => { sequence: readModel.snapshotSequence + 1, }); } - expect(readModel.threads[0]).toMatchObject({ + expect(findThreadById(readModel, THREAD_ID)).toMatchObject({ activeOrderKey: orderKey, updatedAt: NOW, createdAt: NOW, @@ -134,7 +136,10 @@ it.layer(NodeServices.layer)("active thread ordering", (it) => { expect(events).toHaveLength(1); for (const event of events) { const projected = yield* projectEvent(readModel, { ...event, sequence: 1 }); - expect(projected.threads[0]).toEqual({ ...readModel.threads[0], activeOrderKey: "m" }); + expect(findThreadById(projected, THREAD_ID)).toEqual({ + ...findThreadById(readModel, THREAD_ID), + activeOrderKey: "m", + }); } }), ); @@ -154,7 +159,10 @@ it.layer(NodeServices.layer)("active thread ordering", (it) => { expect(events).toHaveLength(1); for (const event of events) { const projected = yield* projectEvent(readModel, { ...event, sequence: 1 }); - expect(projected.threads[0]).toEqual({ ...readModel.threads[0], activeOrderKey: "m" }); + expect(findThreadById(projected, THREAD_ID)).toEqual({ + ...findThreadById(readModel, THREAD_ID), + activeOrderKey: "m", + }); } }), ); @@ -187,9 +195,11 @@ it.layer(NodeServices.layer)("active thread ordering", (it) => { sequence: readModel.snapshotSequence + 1, }); } - expect(readModel.threads[0]?.activeOrderKey, command.type).toBe(expectedKey); + expect(findThreadById(readModel, THREAD_ID)?.activeOrderKey, command.type).toBe( + expectedKey, + ); } - expect(readModel.threads[0]).toMatchObject({ + expect(findThreadById(readModel, THREAD_ID)).toMatchObject({ title: "Renamed", settledOverride: "active", settledAt: null, diff --git a/apps/server/src/orchestration/decider.delete.test.ts b/apps/server/src/orchestration/decider.delete.test.ts index fea36b5717fe..067ea3b2ecb4 100644 --- a/apps/server/src/orchestration/decider.delete.test.ts +++ b/apps/server/src/orchestration/decider.delete.test.ts @@ -2,6 +2,7 @@ import { CommandId, DEFAULT_PROVIDER_INTERACTION_MODE, EventId, + MessageId, ProjectId, ThreadId, type OrchestrationCommand, @@ -9,6 +10,7 @@ import { ProviderInstanceId, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { expect, it } from "@effect/vitest"; @@ -214,4 +216,133 @@ it.layer(NodeServices.layer)("decider deletion flows", (it) => { expect(normalizeDeleteEvent(forcedResult)).toEqual(normalizeDeleteEvent(sequentialEvents)); }), ); + + it.effect("rejects commands targeting an already-deleted (evicted) thread", () => + Effect.gen(function* () { + const seeded = yield* seedReadModel; + const now = "2026-01-01T00:00:00.000Z"; + + // Delete thread-delete-1; the projector evicts it from the model. + const afterDelete = yield* projectEvent(seeded, { + sequence: 4, + eventId: asEventId("evt-thread-delete-1"), + aggregateKind: "thread", + aggregateId: asThreadId("thread-delete-1"), + type: "thread.deleted", + occurredAt: now, + commandId: asCommandId("cmd-thread-delete-1"), + causationEventId: null, + correlationId: asCommandId("cmd-thread-delete-1"), + metadata: {}, + payload: { + threadId: asThreadId("thread-delete-1"), + deletedAt: now, + }, + }); + + // A follow-up command to the deleted thread now fails cleanly. + const error = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type: "thread.turn.start", + commandId: asCommandId("cmd-turn-after-delete"), + threadId: asThreadId("thread-delete-1"), + message: { + messageId: MessageId.make("msg-after-delete"), + role: "user", + text: "hello", + attachments: [], + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + createdAt: now, + }, + readModel: afterDelete, + }), + ); + expect(error.message).toContain("does not exist"); + + // A draft keeps its client-minted id across retries, so recreating the + // same id after eviction is allowed; only a live row blocks creation. + const recreateSameId = (threadId: ThreadId) => + decideOrchestrationCommand({ + command: { + type: "thread.create", + commandId: asCommandId(`cmd-recreate-${threadId}`), + threadId, + projectId: asProjectId("project-delete"), + title: "Recreate", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: null, + worktreePath: null, + createdAt: now, + }, + readModel: afterDelete, + }); + + const recreated = yield* recreateSameId(asThreadId("thread-delete-1")); + const recreatedEvents = Array.isArray(recreated) ? recreated : [recreated]; + expect(recreatedEvents.map((event) => event.type)).toEqual(["thread.created"]); + + // A fresh thread with a NEW, never-used id can still be created. + const created = yield* recreateSameId(asThreadId("thread-delete-3")); + const createdEvents = Array.isArray(created) ? created : [created]; + expect(createdEvents.map((event) => event.type)).toEqual(["thread.created"]); + }), + ); + + it.effect("projector evicts deleted threads but retains archived threads", () => + Effect.gen(function* () { + const seeded = yield* seedReadModel; + const now = "2026-01-01T00:00:00.000Z"; + expect(HashMap.size(seeded.threads)).toBe(2); + + // Archiving keeps the thread resident (unarchive/other commands need it). + const afterArchive = yield* projectEvent(seeded, { + sequence: 4, + eventId: asEventId("evt-thread-archive-1"), + aggregateKind: "thread", + aggregateId: asThreadId("thread-delete-1"), + type: "thread.archived", + occurredAt: now, + commandId: asCommandId("cmd-thread-archive-1"), + causationEventId: null, + correlationId: asCommandId("cmd-thread-archive-1"), + metadata: {}, + payload: { + threadId: asThreadId("thread-delete-1"), + archivedAt: now, + updatedAt: now, + }, + }); + expect(HashMap.size(afterArchive.threads)).toBe(2); + expect(HashMap.has(afterArchive.threads, asThreadId("thread-delete-1"))).toBe(true); + + // Deleting evicts the thread from the in-memory model entirely. + const afterDelete = yield* projectEvent(afterArchive, { + sequence: 5, + eventId: asEventId("evt-thread-delete-2"), + aggregateKind: "thread", + aggregateId: asThreadId("thread-delete-2"), + type: "thread.deleted", + occurredAt: now, + commandId: asCommandId("cmd-thread-delete-2"), + causationEventId: null, + correlationId: asCommandId("cmd-thread-delete-2"), + metadata: {}, + payload: { + threadId: asThreadId("thread-delete-2"), + deletedAt: now, + }, + }); + expect(HashMap.size(afterDelete.threads)).toBe(1); + expect(HashMap.has(afterDelete.threads, asThreadId("thread-delete-2"))).toBe(false); + expect(HashMap.has(afterDelete.threads, asThreadId("thread-delete-1"))).toBe(true); + }), + ); }); diff --git a/apps/server/src/orchestration/decider.import.test.ts b/apps/server/src/orchestration/decider.import.test.ts index c809c733800a..36887fce8415 100644 --- a/apps/server/src/orchestration/decider.import.test.ts +++ b/apps/server/src/orchestration/decider.import.test.ts @@ -9,10 +9,16 @@ import { ThreadId, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; import * as TestClock from "effect/testing/TestClock"; import { decideOrchestrationCommand } from "./decider.ts"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; +import type { CommandReadModel } from "./commandReadModel.ts"; + +function firstThread(model: CommandReadModel) { + return Array.from(HashMap.values(model.threads))[0]; +} it.layer(NodeServices.layer)("thread history import", (it) => { it.effect("marks imported thread creation without changing live creation", () => @@ -167,7 +173,7 @@ it.layer(NodeServices.layer)("thread history import", (it) => { metadata: {}, payload: { threadId, turnCount: 0 }, }); - expect(projected.threads[0]?.messages.map((message) => message.text)).toEqual([ + expect(firstThread(projected)?.messages.map((message) => message.text)).toEqual([ "Fix the bug", "Fixed", ]); @@ -312,7 +318,7 @@ it.layer(NodeServices.layer)("thread history import", (it) => { expect(error._tag).toBe("OrchestrationCommandInvariantError"); expect(error.message).toContain("must be active and empty"); - expect(readModel.threads[0]?.updatedAt).toBe(liveMessageAt); + expect(firstThread(readModel)?.updatedAt).toBe(liveMessageAt); }), ); diff --git a/apps/server/src/orchestration/decider.pinned.test.ts b/apps/server/src/orchestration/decider.pinned.test.ts index 7d6f55d8f622..83f3542d527c 100644 --- a/apps/server/src/orchestration/decider.pinned.test.ts +++ b/apps/server/src/orchestration/decider.pinned.test.ts @@ -1,15 +1,10 @@ -import { - CommandId, - ProjectId, - ProviderInstanceId, - ThreadId, - type OrchestrationReadModel, -} from "@t3tools/contracts"; +import { CommandId, ProjectId, ProviderInstanceId, ThreadId } from "@t3tools/contracts"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import { decideOrchestrationCommand } from "./decider.ts"; +import { fromWireReadModel, type CommandReadModel } from "./commandReadModel.ts"; const NOW = "2026-01-01T00:00:00.000Z"; const PINNED_AT = "1969-12-30T00:00:00.000Z"; @@ -22,8 +17,8 @@ function makeReadModel(input: { readonly settledAt?: string | null; readonly snoozedUntil?: string | null; readonly snoozedAt?: string | null; -}): OrchestrationReadModel { - return { +}): CommandReadModel { + return fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -49,6 +44,8 @@ function makeReadModel(input: { pinOrderKey: input.pinOrderKey ?? null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -56,7 +53,7 @@ function makeReadModel(input: { }, ], updatedAt: NOW, - }; + }); } it.layer(NodeServices.layer)("pinned thread decider", (it) => { diff --git a/apps/server/src/orchestration/decider.projectScripts.test.ts b/apps/server/src/orchestration/decider.projectScripts.test.ts index 732605d00217..893fe9889767 100644 --- a/apps/server/src/orchestration/decider.projectScripts.test.ts +++ b/apps/server/src/orchestration/decider.projectScripts.test.ts @@ -13,6 +13,7 @@ import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as NodeServices from "@effect/platform-node/NodeServices"; +import { findProjectById } from "./commandReadModel.ts"; import { decideOrchestrationCommand } from "./decider.ts"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; @@ -146,7 +147,7 @@ it.layer(NodeServices.layer)("decider project scripts", (it) => { expect(failure).toMatchObject({ _tag: "OrchestrationCommandInvariantError" }); expect(failure.message).toContain("Script ID"); expect(failure.message).toContain("24"); - expect(readModel.projects[0]?.scripts).toEqual([]); + expect(findProjectById(readModel, asProjectId("project-scripts"))?.scripts).toEqual([]); }), ); } @@ -175,7 +176,9 @@ it.layer(NodeServices.layer)("decider project scripts", (it) => { Effect.gen(function* () { const legacy = script("install-javascript-dependencies"); const readModel = yield* projectWithScripts([legacy]); - expect(readModel.projects[0]?.scripts).toEqual([legacy]); + expect(findProjectById(readModel, asProjectId("project-scripts"))?.scripts).toEqual([ + legacy, + ]); for (const scripts of [[{ ...legacy, command: "vp install" }, script("lint")], []]) { const result = yield* decideOrchestrationCommand({ readModel, diff --git a/apps/server/src/orchestration/decider.projectThreadEnvMode.test.ts b/apps/server/src/orchestration/decider.projectThreadEnvMode.test.ts index fd15d8f263dd..2e34b9bfbbd0 100644 --- a/apps/server/src/orchestration/decider.projectThreadEnvMode.test.ts +++ b/apps/server/src/orchestration/decider.projectThreadEnvMode.test.ts @@ -9,6 +9,8 @@ import { import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as NodeServices from "@effect/platform-node/NodeServices"; +import * as HashMap from "effect/HashMap"; +import * as Option from "effect/Option"; import { decideOrchestrationCommand } from "./decider.ts"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; @@ -16,6 +18,13 @@ import { createEmptyReadModel, projectEvent } from "./projector.ts"; const now = "2026-01-01T00:00:00.000Z"; const projectId = ProjectId.make("project-env-mode"); +const projectFromModel = (model: { + readonly projects: HashMap.HashMap; +}) => + Option.getOrUndefined(HashMap.get(model.projects, projectId)) as + | { readonly defaultThreadEnvMode: string | null } + | undefined; + const seedProjectCreated = (sequence: number): OrchestrationEvent => ({ sequence, eventId: EventId.make(`evt-project-env-mode-${sequence}`), @@ -88,7 +97,7 @@ it.layer(NodeServices.layer)("decider project defaults", (it) => { it.effect("propagates defaultThreadEnvMode through meta.update into the read model", () => Effect.gen(function* () { const readModel = yield* projectEvent(createEmptyReadModel(now), seedProjectCreated(1)); - expect(readModel.projects[0]?.defaultThreadEnvMode).toBeNull(); + expect(projectFromModel(readModel)?.defaultThreadEnvMode).toBeNull(); const result = yield* decideOrchestrationCommand({ command: { @@ -107,7 +116,7 @@ it.layer(NodeServices.layer)("decider project defaults", (it) => { ); const updated = yield* projectEvent(readModel, { ...event, sequence: 2 }); - expect(updated.projects[0]?.defaultThreadEnvMode).toBe("worktree"); + expect(projectFromModel(updated)?.defaultThreadEnvMode).toBe("worktree"); }), ); @@ -150,14 +159,16 @@ it.layer(NodeServices.layer)("decider project defaults", (it) => { }); const clearEvent = Array.isArray(clear) ? clear[0] : clear; const afterClear = yield* projectEvent(afterSet, { ...clearEvent, sequence: 3 }); - expect(afterClear.projects[0]?.defaultThreadEnvMode).toBeNull(); + expect(projectFromModel(afterClear)?.defaultThreadEnvMode).toBeNull(); }), ); it.effect("propagates autoPull through meta.update into the read model", () => Effect.gen(function* () { const readModel = yield* projectEvent(createEmptyReadModel(now), seedProjectCreated(1)); - expect(readModel.projects[0]?.autoPull).toBe(false); + expect( + (projectFromModel(readModel) as { readonly autoPull?: boolean } | undefined)?.autoPull, + ).toBe(false); const result = yield* decideOrchestrationCommand({ command: { @@ -172,7 +183,9 @@ it.layer(NodeServices.layer)("decider project defaults", (it) => { expect((event.payload as { autoPull?: unknown }).autoPull).toBe(true); const updated = yield* projectEvent(readModel, { ...event, sequence: 2 }); - expect(updated.projects[0]?.autoPull).toBe(true); + expect( + (projectFromModel(updated) as { readonly autoPull?: boolean } | undefined)?.autoPull, + ).toBe(true); }), ); }); diff --git a/apps/server/src/orchestration/decider.pullRequests.test.ts b/apps/server/src/orchestration/decider.pullRequests.test.ts index 49bfd4bea4de..603116ee6fa3 100644 --- a/apps/server/src/orchestration/decider.pullRequests.test.ts +++ b/apps/server/src/orchestration/decider.pullRequests.test.ts @@ -14,6 +14,9 @@ import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; +import { findThreadById, fromWireReadModel } from "./commandReadModel.ts"; +import * as HashMap from "effect/HashMap"; +import * as Option from "effect/Option"; import { decideOrchestrationCommand } from "./decider.ts"; import { projectEvent } from "./projector.ts"; import { isThreadDetailEvent } from "../ws.ts"; @@ -94,6 +97,8 @@ function makeReadModel(pullRequests: ReadonlyArray): Orch settledAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -104,6 +109,14 @@ function makeReadModel(pullRequests: ReadonlyArray): Orch }; } +function makeCommandReadModel(pullRequests: ReadonlyArray) { + return fromWireReadModel(makeReadModel(pullRequests)); +} + +function threadOf(model: ReturnType) { + return findThreadById(model, THREAD_ID)!; +} + const snapshot: ThreadPullRequestSnapshot = { state: "open", title: "Add links", @@ -130,7 +143,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { linkedPullRequest: null, }); const decided = yield* decideOrchestrationCommand({ - readModel: makeReadModel([own, foreign]), + readModel: makeCommandReadModel([own, foreign]), command, }); const event = expectSingleEvent(decided, "thread.pull-request-unlinked"); @@ -142,7 +155,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { Effect.gen(function* () { const other = makeLink({ number: 7, snapshot: { ...snapshot, state: "merged" } }); const current = makeLink({ linkedAt: "2026-01-02T00:00:00Z" }); - let model = makeReadModel([other, current]); + let model = makeCommandReadModel([other, current]); const command = yield* decodeCommand({ type: "thread.meta.update", commandId: "replace", @@ -162,7 +175,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { ]); for (const event of events) model = yield* projectEvent(model, { ...event, sequence: model.snapshotSequence + 1 }); - expect(model.threads[0]!.pullRequests.map((link) => link.number)).toEqual([7, 99]); + expect(threadOf(model).pullRequests.map((link) => link.number)).toEqual([7, 99]); }), ); it.effect("round-trips an Azure legacy link and unlinks only its organization", () => @@ -173,10 +186,11 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { number: 7, url: "https://dev.azure.com/org-b/project/_git/web/pullrequest/7", }); - let model = makeReadModel([foreign]); + let model = makeCommandReadModel([foreign]); + const project = Option.getOrThrow(HashMap.get(model.projects, ProjectId.make("project-1"))); model = { ...model, - projects: model.projects.map((project) => ({ + projects: HashMap.set(model.projects, project.id, { ...project, repositoryIdentity: { ...project.repositoryIdentity!, @@ -185,7 +199,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { displayName: "v3/org-a/project/web", name: "web", }, - })), + }), }; const legacy = { projectId: "project-1", @@ -205,15 +219,15 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { model = yield* projectEvent(model, { ...event, sequence: model.snapshotSequence + 1 }); } if (linkedPullRequest !== null) { - expect(model.threads[0]!.linkedPullRequest).toEqual(legacy); - expect(model.threads[0]!.pullRequests.map((link) => link.repository)).toEqual([ + expect(threadOf(model).linkedPullRequest).toEqual(legacy); + expect(threadOf(model).pullRequests.map((link) => link.repository)).toEqual([ "org-b/project/_git/web", "org-a/project/_git/web", ]); } } - expect(model.threads[0]!.pullRequests).toEqual([foreign]); - expect(model.threads[0]!.linkedPullRequest).toBeNull(); + expect(threadOf(model).pullRequests).toEqual([foreign]); + expect(threadOf(model).linkedPullRequest).toBeNull(); }), ); it.effect("legacy unlink alone does not emit an empty metadata event", () => @@ -225,7 +239,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { linkedPullRequest: null, }); const decided = yield* decideOrchestrationCommand({ - readModel: makeReadModel([makeLink()]), + readModel: makeCommandReadModel([makeLink()]), command, }); const events = Array.isArray(decided) ? decided : [decided]; @@ -238,7 +252,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { Effect.gen(function* () { const other = makeLink({ number: 7, snapshot: { ...snapshot, state: "merged" } }); const current = makeLink({ source, linkedAt: "2026-01-02T00:00:00.000Z" }); - let model = makeReadModel([other, current]); + let model = makeCommandReadModel([other, current]); // This is the pre-array command shape sent by older clients. const command = yield* decodeCommand({ type: "thread.meta.update", @@ -254,10 +268,15 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { const encoded = yield* Schema.encodeEffect(OrchestrationEvent)(event); const decoded = yield* Schema.decodeUnknownEffect(OrchestrationEvent)(encoded); // Older detail-event unions must never receive the new PR discriminants. - expect(isThreadDetailEvent(decoded)).toBe(false); + // Fork still delivers `thread.meta-updated` as a live detail event so + // Discord/title subscribers see renames; only the PR discriminants + // must stay off that union. + if (decoded.type.startsWith("thread.pull-request-")) { + expect(isThreadDetailEvent(decoded)).toBe(false); + } model = yield* projectEvent(model, decoded); } - const thread = model.threads[0]!; + const thread = threadOf(model); expect(thread.title).toBe("Renamed by old client"); expect(thread.pullRequests).toEqual( source === "stack" ? [other, { ...current, source: "stack-dismissed" }] : [other], @@ -281,7 +300,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { url: "https://github.com/t3tools/t3code/pull/42", source: "manual", }, - readModel: makeReadModel([]), + readModel: makeCommandReadModel([]), }); expect(Array.isArray(decided)).toBe(false); const event = expectSingleEvent(decided, "thread.pull-request-linked"); @@ -312,7 +331,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { url: "https://github.com/t3tools/t3code/pull/42", source: "agent", }, - readModel: makeReadModel([makeLink()]), + readModel: makeCommandReadModel([makeLink()]), }).pipe(Effect.flip); expect(error._tag).toBe("OrchestrationCommandInvariantError"); }), @@ -343,7 +362,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { url: "https://github.com/t3tools/t3code/pull/42", source: "manual", }, - readModel: makeReadModel([dismissed]), + readModel: makeCommandReadModel([dismissed]), }); const event = expectSingleEvent(decided, "thread.pull-request-linked"); // Host state survives the flip; only the source changes. @@ -364,7 +383,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { url: "https://github.com/t3tools/t3code/pull/42", source: "stack", }, - readModel: makeReadModel([makeLink({ source: "stack-dismissed" })]), + readModel: makeCommandReadModel([makeLink({ source: "stack-dismissed" })]), }).pipe(Effect.flip); expect(error._tag).toBe("OrchestrationCommandInvariantError"); }), @@ -381,7 +400,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { repository: "t3tools/t3code", number: 42, }, - readModel: makeReadModel([makeLink()]), + readModel: makeCommandReadModel([makeLink()]), }); const event = expectSingleEvent(decided, "thread.pull-request-unlinked"); expect(event.payload).toMatchObject({ @@ -405,7 +424,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { repository: "t3tools/t3code", number: 42, }, - readModel: makeReadModel([member]), + readModel: makeCommandReadModel([member]), }); const event = expectSingleEvent(decided, "thread.pull-request-linked"); expect(event.payload.link).toEqual({ ...member, source: "stack-dismissed" }); @@ -431,7 +450,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { ], }, }); - let model = makeReadModel([member, sibling]); + let model = makeCommandReadModel([member, sibling]); const decided = yield* decideOrchestrationCommand({ readModel: model, command: { @@ -445,7 +464,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { }); const event = expectSingleEvent(decided, "thread.pull-request-linked"); model = yield* projectEvent(model, { ...event, sequence: 1 }); - expect(model.threads[0]!.pullRequests).toEqual([ + expect(threadOf(model).pullRequests).toEqual([ { ...member, source: "stack-dismissed" }, sibling, ]); @@ -478,7 +497,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { repository: "t3tools/t3code", number: 7, }, - readModel: makeReadModel([makeLink()]), + readModel: makeCommandReadModel([makeLink()]), }).pipe(Effect.flip); expect(error._tag).toBe("OrchestrationCommandInvariantError"); }), @@ -497,7 +516,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { snapshot, stack: null, }, - readModel: makeReadModel([]), + readModel: makeCommandReadModel([]), }).pipe(Effect.flip); expect(error._tag).toBe("OrchestrationCommandInvariantError"); }), @@ -516,7 +535,7 @@ it.layer(NodeServices.layer)("pull request link decider", (it) => { snapshot, stack: null, }, - readModel: makeReadModel([makeLink()]), + readModel: makeCommandReadModel([makeLink()]), }); const event = expectSingleEvent(decided, "thread.pull-request-synced"); expect(event.payload).toMatchObject({ diff --git a/apps/server/src/orchestration/decider.questionAttachments.test.ts b/apps/server/src/orchestration/decider.questionAttachments.test.ts index 53e87d7593cc..02f3d892e701 100644 --- a/apps/server/src/orchestration/decider.questionAttachments.test.ts +++ b/apps/server/src/orchestration/decider.questionAttachments.test.ts @@ -5,17 +5,17 @@ import { ProjectId, ProviderInstanceId, ThreadId, - type OrchestrationReadModel, } from "@t3tools/contracts"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import { fromWireReadModel } from "./commandReadModel.ts"; import { decideOrchestrationCommand } from "./decider.ts"; const UPDATED_AT = "2026-01-01T00:00:00.000Z"; -const readModel: OrchestrationReadModel = { +const readModel = fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -37,8 +37,11 @@ const readModel: OrchestrationReadModel = { settledAt: null, snoozedUntil: null, snoozedAt: null, + pinnedAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -46,7 +49,7 @@ const readModel: OrchestrationReadModel = { }, ], updatedAt: UPDATED_AT, -}; +}); const requestId = ApprovalRequestId.make("question-request"); const command = { diff --git a/apps/server/src/orchestration/decider.queue.test.ts b/apps/server/src/orchestration/decider.queue.test.ts new file mode 100644 index 000000000000..f84ce2b6ac90 --- /dev/null +++ b/apps/server/src/orchestration/decider.queue.test.ts @@ -0,0 +1,606 @@ +import { + CommandId, + DEFAULT_PROVIDER_INTERACTION_MODE, + EventId, + MessageId, + ProjectId, + ProviderInstanceId, + ThreadId, + TurnId, + type OrchestrationEvent, + type OrchestrationSessionStatus, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { expect, it } from "@effect/vitest"; + +import { decideOrchestrationCommand } from "./decider.ts"; +import { findThreadById, type CommandReadModel } from "./commandReadModel.ts"; +import { createEmptyReadModel, projectEvent } from "./projector.ts"; + +const NOW = "2026-01-01T00:00:00.000Z"; +const asCommandId = (value: string): CommandId => CommandId.make(value); +const asEventId = (value: string): EventId => EventId.make(value); +const asMessageId = (value: string): MessageId => MessageId.make(value); +const asProjectId = (value: string): ProjectId => ProjectId.make(value); +const asThreadId = (value: string): ThreadId => ThreadId.make(value); + +const THREAD_ID = asThreadId("thread-queue"); + +const seedReadModel = Effect.gen(function* () { + const initial = createEmptyReadModel(NOW); + const withProject = yield* projectEvent(initial, { + sequence: 1, + eventId: asEventId("evt-project-create"), + aggregateKind: "project", + aggregateId: asProjectId("project-queue"), + type: "project.created", + occurredAt: NOW, + commandId: asCommandId("cmd-project-create"), + causationEventId: null, + correlationId: asCommandId("cmd-project-create"), + metadata: {}, + payload: { + projectId: asProjectId("project-queue"), + title: "Project Queue", + workspaceRoot: "/tmp/project-queue", + defaultModelSelection: null, + scripts: [], + createdAt: NOW, + updatedAt: NOW, + }, + }); + + return yield* projectEvent(withProject, { + sequence: 2, + eventId: asEventId("evt-thread-create"), + aggregateKind: "thread", + aggregateId: THREAD_ID, + type: "thread.created", + occurredAt: NOW, + commandId: asCommandId("cmd-thread-create"), + causationEventId: null, + correlationId: asCommandId("cmd-thread-create"), + metadata: {}, + payload: { + threadId: THREAD_ID, + projectId: asProjectId("project-queue"), + title: "Thread Queue", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "full-access", + branch: null, + worktreePath: null, + createdAt: NOW, + updatedAt: NOW, + }, + }); +}); + +const withSessionStatus = ( + readModel: CommandReadModel, + status: OrchestrationSessionStatus, + sequence: number, +) => + projectEvent(readModel, { + sequence, + eventId: asEventId(`evt-session-${status}-${sequence}`), + aggregateKind: "thread", + aggregateId: THREAD_ID, + type: "thread.session-set", + occurredAt: NOW, + commandId: asCommandId(`cmd-session-${status}-${sequence}`), + causationEventId: null, + correlationId: null, + metadata: {}, + payload: { + threadId: THREAD_ID, + session: { + threadId: THREAD_ID, + status, + providerName: "codex", + runtimeMode: "full-access", + activeTurnId: status === "running" ? TurnId.make("turn-active") : null, + lastError: null, + updatedAt: NOW, + }, + }, + }); + +const turnStartCommand = (suffix: string) => + ({ + type: "thread.turn.start", + commandId: asCommandId(`cmd-turn-start-${suffix}`), + threadId: THREAD_ID, + message: { + messageId: asMessageId(`message-${suffix}`), + role: "user", + text: `Follow up ${suffix}`, + attachments: [], + }, + runtimeMode: "full-access", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + createdAt: NOW, + }) as const; + +const applyPlanned = ( + readModel: CommandReadModel, + planned: + | Omit + | ReadonlyArray>, +) => + Effect.gen(function* () { + let nextReadModel = readModel; + let nextSequence = readModel.snapshotSequence; + for (const event of Array.isArray(planned) ? planned : [planned]) { + nextSequence += 1; + nextReadModel = yield* projectEvent(nextReadModel, { ...event, sequence: nextSequence }); + } + return nextReadModel; + }); + +it.layer(NodeServices.layer)("decider queue flows", (it) => { + it.effect("starts a turn immediately when the thread is idle", () => + Effect.gen(function* () { + const readModel = yield* seedReadModel; + const planned = yield* decideOrchestrationCommand({ + command: turnStartCommand("idle"), + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual([ + "thread.message-sent", + "thread.turn-start-requested", + ]); + }), + ); + + it.effect("queues a follow-up while a turn is running", () => + Effect.gen(function* () { + const readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + const planned = yield* decideOrchestrationCommand({ + command: turnStartCommand("busy"), + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual(["thread.message-queued"]); + + const projected = yield* applyPlanned(readModel, planned); + const thread = findThreadById(projected, THREAD_ID); + expect(thread?.queuedMessages.map((entry) => entry.messageId)).toEqual([ + asMessageId("message-busy"), + ]); + }), + ); + + it.effect("queues a follow-up racing in behind a just-dispatched turn start", () => + Effect.gen(function* () { + // First send on an idle thread: dispatches message-sent + + // turn-start-requested, but the provider has not reported any + // session status yet — the pending-start window. + let readModel = yield* seedReadModel; + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("pending-1"), readModel }), + ); + + // Second send in that window must queue, not open a second turn. + const planned = yield* decideOrchestrationCommand({ + command: turnStartCommand("pending-2"), + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual(["thread.message-queued"]); + + // A drain in the same window is rejected and keeps the queue intact. + readModel = yield* applyPlanned(readModel, planned); + const drainError = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type: "thread.queue.drain", + commandId: asCommandId("cmd-drain-pending"), + threadId: THREAD_ID, + createdAt: NOW, + }, + readModel, + }), + ); + expect(drainError.message).toContain("busy"); + }), + ); + + it.effect("drains after a mid-turn steer once the turn settles to ready", () => + Effect.gen(function* () { + // Two messages queue while running; the first is steered mid-turn + // (re-arming pendingTurnStart), then the turn completes → ready. + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("settle-1"), readModel }), + ); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("settle-2"), readModel }), + ); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ + command: { + type: "thread.queue.steer", + commandId: asCommandId("cmd-steer-settle"), + threadId: THREAD_ID, + messageId: asMessageId("message-settle-1"), + createdAt: NOW, + }, + readModel, + }), + ); + // The steer left pendingTurnStart armed with the session still running. + let thread = findThreadById(readModel, THREAD_ID); + expect(thread?.pendingTurnStart?.messageId).toEqual(asMessageId("message-settle-1")); + + // Turn end: session settles to ready, which must release the pending + // flag so the queued follow-up can drain. + readModel = yield* withSessionStatus(readModel, "ready", readModel.snapshotSequence + 1); + thread = findThreadById(readModel, THREAD_ID); + expect(thread?.pendingTurnStart).toBeNull(); + + const planned = yield* decideOrchestrationCommand({ + command: { + type: "thread.queue.drain", + commandId: asCommandId("cmd-drain-settle"), + threadId: THREAD_ID, + createdAt: NOW, + }, + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual([ + "thread.queued-message-removed", + "thread.message-sent", + "thread.turn-start-requested", + ]); + }), + ); + + it.effect("rejects queueing past the per-thread cap", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + for (let index = 0; index < 50; index += 1) { + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ + command: turnStartCommand(`cap-${index}`), + readModel, + }), + ); + } + + const error = yield* Effect.flip( + decideOrchestrationCommand({ command: turnStartCommand("cap-overflow"), readModel }), + ); + expect(error.message).toContain("queued messages"); + + const thread = findThreadById(readModel, THREAD_ID); + expect(thread?.queuedMessages).toHaveLength(50); + }), + ); + + it.effect("steer dispatches a queued message even while running", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("steer"), readModel }), + ); + + const planned = yield* decideOrchestrationCommand({ + command: { + type: "thread.queue.steer", + commandId: asCommandId("cmd-steer"), + threadId: THREAD_ID, + messageId: asMessageId("message-steer"), + createdAt: NOW, + }, + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual([ + "thread.queued-message-removed", + "thread.message-sent", + "thread.turn-start-requested", + ]); + + const projected = yield* applyPlanned(readModel, planned); + const thread = findThreadById(projected, THREAD_ID); + expect(thread?.queuedMessages).toEqual([]); + expect(thread?.messages.map((entry) => entry.id)).toContain(asMessageId("message-steer")); + }), + ); + + it.effect("steer rejects while the session is still starting", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "starting", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ + command: turnStartCommand("steer-starting"), + readModel, + }), + ); + + const error = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type: "thread.queue.steer", + commandId: asCommandId("cmd-steer-starting"), + threadId: THREAD_ID, + messageId: asMessageId("message-steer-starting"), + createdAt: NOW, + }, + readModel, + }), + ); + expect(error.message).toContain("starting"); + + // The queued message survives the rejected steer. + const thread = findThreadById(readModel, THREAD_ID); + expect(thread?.queuedMessages.map((entry) => entry.messageId)).toEqual([ + asMessageId("message-steer-starting"), + ]); + }), + ); + + it.effect("remove deletes a queued message without dispatching", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("remove"), readModel }), + ); + + const planned = yield* decideOrchestrationCommand({ + command: { + type: "thread.queue.remove", + commandId: asCommandId("cmd-remove"), + threadId: THREAD_ID, + messageId: asMessageId("message-remove"), + createdAt: NOW, + }, + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual(["thread.queued-message-removed"]); + + const projected = yield* applyPlanned(readModel, planned); + const thread = findThreadById(projected, THREAD_ID); + expect(thread?.queuedMessages).toEqual([]); + expect(thread?.messages.map((entry) => entry.id)).not.toContain( + asMessageId("message-remove"), + ); + }), + ); + + it.effect("update edits queued text while preserving its durable payload", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("edit"), readModel }), + ); + const before = findThreadById(readModel, THREAD_ID)?.queuedMessages[0]; + + const planned = yield* decideOrchestrationCommand({ + command: { + type: "thread.queue.update", + commandId: asCommandId("cmd-edit"), + threadId: THREAD_ID, + messageId: asMessageId("message-edit"), + text: "Edited follow-up", + createdAt: NOW, + }, + readModel, + }); + const projected = yield* applyPlanned(readModel, planned); + const after = findThreadById(projected, THREAD_ID)?.queuedMessages[0]; + + expect(after?.text).toBe("Edited follow-up"); + expect(after?.attachments).toEqual(before?.attachments); + expect(after?.modelSelection).toEqual(before?.modelSelection); + expect(after?.queuedAt).toBe(before?.queuedAt); + }), + ); + + it.effect("steer, update, and remove reject unknown queued messages", () => + Effect.gen(function* () { + const readModel = yield* seedReadModel; + for (const type of ["thread.queue.steer", "thread.queue.remove"] as const) { + const error = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type, + commandId: asCommandId(`cmd-${type}-missing`), + threadId: THREAD_ID, + messageId: asMessageId("message-missing"), + createdAt: NOW, + }, + readModel, + }), + ); + expect(error.message).toContain("does not exist"); + } + const updateError = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type: "thread.queue.update", + commandId: asCommandId("cmd-update-missing"), + threadId: THREAD_ID, + messageId: asMessageId("message-missing"), + text: "Missing", + createdAt: NOW, + }, + readModel, + }), + ); + expect(updateError.message).toContain("does not exist"); + }), + ); + + it.effect("drain dispatches the queue head once the thread is idle", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("drain-1"), readModel }), + ); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("drain-2"), readModel }), + ); + readModel = yield* withSessionStatus(readModel, "ready", readModel.snapshotSequence + 1); + + const planned = yield* decideOrchestrationCommand({ + command: { + type: "thread.queue.drain", + commandId: asCommandId("cmd-drain"), + threadId: THREAD_ID, + createdAt: NOW, + }, + readModel, + }); + const events = Array.isArray(planned) ? planned : [planned]; + expect(events.map((event) => event.type)).toEqual([ + "thread.queued-message-removed", + "thread.message-sent", + "thread.turn-start-requested", + ]); + + const projected = yield* applyPlanned(readModel, planned); + const thread = findThreadById(projected, THREAD_ID); + // FIFO: the first queued message dispatches, the second stays queued. + expect(thread?.messages.map((entry) => entry.id)).toContain(asMessageId("message-drain-1")); + expect(thread?.queuedMessages.map((entry) => entry.messageId)).toEqual([ + asMessageId("message-drain-2"), + ]); + }), + ); + + it.effect("drain rejects while the thread is busy and keeps the queue intact", () => + Effect.gen(function* () { + let readModel = yield* withSessionStatus(yield* seedReadModel, "running", 3); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("drain-busy"), readModel }), + ); + + const error = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type: "thread.queue.drain", + commandId: asCommandId("cmd-drain-busy"), + threadId: THREAD_ID, + createdAt: NOW, + }, + readModel, + }), + ); + expect(error.message).toContain("busy"); + }), + ); + + it.effect("drain rejects when the queue is empty", () => + Effect.gen(function* () { + const readModel = yield* seedReadModel; + const error = yield* Effect.flip( + decideOrchestrationCommand({ + command: { + type: "thread.queue.drain", + commandId: asCommandId("cmd-drain-empty"), + threadId: THREAD_ID, + createdAt: NOW, + }, + readModel, + }), + ); + expect(error.message).toContain("no queued messages"); + }), + ); + + it.effect("keeps follow-ups as turn starts while a /compact pending start is held", () => + Effect.gen(function* () { + let readModel = yield* seedReadModel; + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ + command: { + ...turnStartCommand("compact"), + message: { + messageId: asMessageId("message-compact"), + role: "user", + text: "/compact", + attachments: [], + }, + }, + readModel, + }), + ); + readModel = yield* withSessionStatus(readModel, "starting", readModel.snapshotSequence + 1); + expect(findThreadById(readModel, THREAD_ID)?.pendingTurnStart?.messageId).toEqual( + asMessageId("message-compact"), + ); + + const firstFollowUp = yield* decideOrchestrationCommand({ + command: turnStartCommand("during-compact-1"), + readModel, + }); + expect( + (Array.isArray(firstFollowUp) ? firstFollowUp : [firstFollowUp]).map((event) => event.type), + ).toEqual(["thread.message-sent", "thread.turn-start-requested"]); + + readModel = yield* applyPlanned(readModel, firstFollowUp); + expect(findThreadById(readModel, THREAD_ID)?.pendingTurnStart?.messageId).toEqual( + asMessageId("message-compact"), + ); + + const secondFollowUp = yield* decideOrchestrationCommand({ + command: turnStartCommand("during-compact-2"), + readModel, + }); + expect( + (Array.isArray(secondFollowUp) ? secondFollowUp : [secondFollowUp]).map( + (event) => event.type, + ), + ).toEqual(["thread.message-sent", "thread.turn-start-requested"]); + }), + ); + + it.effect("replays an already-sent message instead of queueing it behind a pending start", () => + Effect.gen(function* () { + let readModel = yield* seedReadModel; + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("replay-1"), readModel }), + ); + readModel = yield* withSessionStatus(readModel, "starting", readModel.snapshotSequence + 1); + readModel = yield* applyPlanned( + readModel, + yield* decideOrchestrationCommand({ command: turnStartCommand("replay-2"), readModel }), + ); + expect( + findThreadById(readModel, THREAD_ID)?.queuedMessages.map((entry) => entry.messageId), + ).toEqual([asMessageId("message-replay-2")]); + + const replay = yield* decideOrchestrationCommand({ + command: turnStartCommand("replay-1"), + readModel, + }); + expect((Array.isArray(replay) ? replay : [replay]).map((event) => event.type)).toEqual([ + "thread.message-sent", + "thread.turn-start-requested", + ]); + }), + ); +}); diff --git a/apps/server/src/orchestration/decider.settled.test.ts b/apps/server/src/orchestration/decider.settled.test.ts index bcb2408c21e1..39c948386fe9 100644 --- a/apps/server/src/orchestration/decider.settled.test.ts +++ b/apps/server/src/orchestration/decider.settled.test.ts @@ -6,7 +6,6 @@ import { ProviderInstanceId, ThreadId, type OrchestrationEvent, - type OrchestrationReadModel, type OrchestrationSession, type OrchestrationThread, } from "@t3tools/contracts"; @@ -15,6 +14,7 @@ import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import { decideOrchestrationCommand } from "./decider.ts"; +import { findThreadById, fromWireReadModel, type CommandReadModel } from "./commandReadModel.ts"; import { projectEvent } from "./projector.ts"; const NOW = "2026-01-01T00:00:00.000Z"; @@ -33,8 +33,8 @@ function makeReadModel( readonly snoozedUntil?: string | null; readonly snoozedAt?: string | null; } = {}, -): OrchestrationReadModel { - return { +): CommandReadModel { + return fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -59,6 +59,8 @@ function makeReadModel( pinnedAt: lifecycle.pinnedAt ?? null, deletedAt: null, messages, + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities, checkpoints: [], @@ -66,7 +68,7 @@ function makeReadModel( }, ], updatedAt: NOW, - }; + }); } function makeSession(status: OrchestrationSession["status"]): OrchestrationSession { @@ -371,8 +373,8 @@ it.layer(NodeServices.layer)("settled thread decider", (it) => { for (const [index, event] of events.entries()) { projected = yield* projectEvent(projected, { ...event, sequence: index + 1 }); } - expect(projected.threads[0]?.settledOverride).toBe("settled"); - expect(projected.threads[0]?.messages).toEqual([]); + expect(findThreadById(projected, command.threadId)?.settledOverride).toBe("settled"); + expect(findThreadById(projected, command.threadId)?.messages).toEqual([]); const repeated = yield* decideOrchestrationCommand({ command, readModel: projected }); expect(repeated).toMatchObject({ type: "thread.settled" }); }), @@ -621,7 +623,7 @@ it.layer(NodeServices.layer)("settled thread decider", (it) => { ...unsettled, sequence: readModel.snapshotSequence + 1, } as OrchestrationEvent); - const thread = projected.threads[0]!; + const thread = findThreadById(projected, ThreadId.make("thread-1"))!; expect(thread.settledOverride).toBe("active"); // The stamp is the decider's accept time: every thread created before // the un-settle anchors below it. diff --git a/apps/server/src/orchestration/decider.snoozed.test.ts b/apps/server/src/orchestration/decider.snoozed.test.ts index 505bb79df034..78afe062b0f6 100644 --- a/apps/server/src/orchestration/decider.snoozed.test.ts +++ b/apps/server/src/orchestration/decider.snoozed.test.ts @@ -5,7 +5,6 @@ import { ProjectId, ProviderInstanceId, ThreadId, - type OrchestrationReadModel, type OrchestrationThread, } from "@t3tools/contracts"; import * as NodeServices from "@effect/platform-node/NodeServices"; @@ -13,6 +12,7 @@ import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import { decideOrchestrationCommand } from "./decider.ts"; +import { fromWireReadModel, type CommandReadModel } from "./commandReadModel.ts"; const NOW = "2026-01-01T00:00:00.000Z"; // The decider's clock is the Effect test clock, pinned to the epoch, so @@ -27,8 +27,8 @@ function makeReadModel(input: { readonly archivedAt?: string | null; readonly activities?: OrchestrationThread["activities"]; readonly messages?: OrchestrationThread["messages"]; -}): OrchestrationReadModel { - return { +}): CommandReadModel { + return fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -52,6 +52,8 @@ function makeReadModel(input: { snoozedAt: input.snoozedAt ?? (input.snoozedUntil != null ? SNOOZED_AT : null), deletedAt: null, messages: input.messages ?? [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: input.activities ?? [], checkpoints: [], @@ -59,7 +61,7 @@ function makeReadModel(input: { }, ], updatedAt: NOW, - }; + }); } it.layer(NodeServices.layer)("snoozed thread decider", (it) => { diff --git a/apps/server/src/orchestration/decider.titleRegeneration.test.ts b/apps/server/src/orchestration/decider.titleRegeneration.test.ts index c032f33d0d01..8bcd3ac249f7 100644 --- a/apps/server/src/orchestration/decider.titleRegeneration.test.ts +++ b/apps/server/src/orchestration/decider.titleRegeneration.test.ts @@ -1,19 +1,14 @@ -import { - CommandId, - ProjectId, - ProviderInstanceId, - ThreadId, - type OrchestrationReadModel, -} from "@t3tools/contracts"; +import { CommandId, ProjectId, ProviderInstanceId, ThreadId } from "@t3tools/contracts"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import { decideOrchestrationCommand } from "./decider.ts"; +import { fromWireReadModel, type CommandReadModel } from "./commandReadModel.ts"; const UPDATED_AT = "2026-01-01T00:00:00.000Z"; -const readModel: OrchestrationReadModel = { +const readModel: CommandReadModel = fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -37,6 +32,8 @@ const readModel: OrchestrationReadModel = { snoozedAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -44,7 +41,7 @@ const readModel: OrchestrationReadModel = { }, ], updatedAt: UPDATED_AT, -}; +}); it.layer(NodeServices.layer)("title regeneration decider", (it) => { it.effect("preserves updatedAt for a stale completion", () => @@ -56,6 +53,7 @@ it.layer(NodeServices.layer)("title regeneration decider", (it) => { threadId: ThreadId.make("thread-1"), requestId: CommandId.make("cmd-old-regeneration-request"), title: "Generated title", + createdAt: UPDATED_AT, }, readModel, }); diff --git a/apps/server/src/orchestration/decider.ts b/apps/server/src/orchestration/decider.ts index c0787a18d096..2c2e645b271c 100644 --- a/apps/server/src/orchestration/decider.ts +++ b/apps/server/src/orchestration/decider.ts @@ -8,11 +8,12 @@ import { isImportedAgentSessionMessageId, type OrchestrationCommand, type OrchestrationEvent, - type OrchestrationReadModel, + type OrchestrationQueuedMessage, type OrchestrationThread, type ThreadPullRequestKey, type ThreadPullRequestLink, type OrchestrationThreadActivity, + type SourceRef, } from "@t3tools/contracts"; import { legacyLinkedPullRequestOf, @@ -29,6 +30,7 @@ import * as Option from "effect/Option"; import * as Predicate from "effect/Predicate"; import type * as PlatformError from "effect/PlatformError"; +import { findProjectById, findThreadById, type CommandReadModel } from "./commandReadModel.ts"; import { OrchestrationCommandInvariantError, OrchestrationThreadSettleBlockedError, @@ -172,12 +174,223 @@ type DecideOrchestrationCommandResult = | PlannedOrchestrationEvent | ReadonlyArray; +/** + * A turn is considered active while its session is starting or running. + * Follow-up `thread.turn.start` commands arriving in that window are queued + * instead of dispatched; explicit `thread.queue.steer` bypasses the queue. + */ +function isThreadTurnActive(thread: OrchestrationThread): boolean { + const status = thread.session?.status; + return status === "running" || status === "starting"; +} + +function isPendingCompactTurnStart(thread: OrchestrationThread): boolean { + const pending = thread.pendingTurnStart; + if (pending === null) { + return false; + } + const message = thread.messages.find((entry) => entry.id === pending.messageId); + return ( + message !== undefined && + message.role === "user" && + (message.attachments?.length ?? 0) === 0 && + message.text.trim().toLowerCase() === "/compact" + ); +} + +/** + * Enforced here in the decider so a `thread.message-queued` event past the + * cap is never emitted — projections and persistence stay in lockstep with + * the event stream instead of each clamping independently. + */ +const MAX_THREAD_QUEUED_MESSAGES = 50; + +interface TurnStartMessageInput { + readonly messageId: OrchestrationQueuedMessage["messageId"]; + readonly text: string; + readonly attachments: OrchestrationQueuedMessage["attachments"]; + readonly modelSelection?: OrchestrationQueuedMessage["modelSelection"]; + readonly titleSeed?: string; + readonly sourceProposedPlan?: OrchestrationQueuedMessage["sourceProposedPlan"]; + /** Server-stamped SourceRef for this user message (absent when identity off). */ + readonly source?: SourceRef; +} + +/** + * Plan the `thread.message-sent` + `thread.turn-start-requested` event pair + * shared by immediate turn starts, queued-message steers, and queue drains. + */ +const planTurnStartEvents = Effect.fn("planTurnStartEvents")(function* ({ + commandId, + thread, + message, + occurredAt, +}: { + readonly commandId: OrchestrationCommand["commandId"]; + readonly thread: OrchestrationThread; + readonly message: TurnStartMessageInput; + readonly occurredAt: string; +}): Effect.fn.Return< + ReadonlyArray, + PlatformError.PlatformError, + Crypto.Crypto +> { + const userMessageEvent: PlannedOrchestrationEvent = { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: thread.id, + occurredAt, + commandId, + })), + type: "thread.message-sent", + payload: { + threadId: thread.id, + messageId: message.messageId, + role: "user", + text: message.text, + attachments: message.attachments, + turnId: null, + streaming: false, + ...(message.source !== undefined ? { source: message.source } : {}), + createdAt: occurredAt, + updatedAt: occurredAt, + }, + }; + const turnStartRequestedEvent: PlannedOrchestrationEvent = { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: thread.id, + occurredAt, + commandId, + })), + causationEventId: userMessageEvent.eventId, + type: "thread.turn-start-requested", + payload: { + threadId: thread.id, + messageId: message.messageId, + ...(message.modelSelection !== undefined ? { modelSelection: message.modelSelection } : {}), + ...(message.titleSeed !== undefined ? { titleSeed: message.titleSeed } : {}), + runtimeMode: thread.runtimeMode, + interactionMode: thread.interactionMode, + ...(message.sourceProposedPlan !== undefined + ? { sourceProposedPlan: message.sourceProposedPlan } + : {}), + createdAt: occurredAt, + }, + }; + // Real activity resets lifecycle overrides. It wakes an explicitly + // settled thread, clears a keep-active pin, and spends a snooze return + // ticket when the user re-engages. + const lifecycleResetEvents: Array = []; + if (thread.settledOverride !== null) { + lifecycleResetEvents.push({ + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: thread.id, + occurredAt, + commandId, + })), + type: "thread.unsettled", + payload: { + threadId: thread.id, + reason: "activity", + updatedAt: occurredAt, + }, + }); + } + // Older snapshots may omit the optional snooze fields entirely. Treat both + // null and undefined as awake; only a real wake timestamp needs an event. + if (thread.snoozedUntil != null) { + lifecycleResetEvents.push({ + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: thread.id, + occurredAt, + commandId, + })), + type: "thread.unsnoozed", + payload: { + threadId: thread.id, + reason: "activity", + updatedAt: occurredAt, + }, + }); + } + return [...lifecycleResetEvents, userMessageEvent, turnStartRequestedEvent]; +}); + +/** + * Plan the dispatch of one queued message: remove it from the queue and + * start (or steer into) a turn with it. `sourceProposedPlan` is dropped + * rather than failed when the referenced plan no longer exists — the + * message itself must still send. + */ +const planQueuedMessageDispatch = Effect.fn("planQueuedMessageDispatch")(function* ({ + commandId, + readModel, + thread, + queuedMessage, + occurredAt, +}: { + readonly commandId: OrchestrationCommand["commandId"]; + readonly readModel: CommandReadModel; + readonly thread: OrchestrationThread; + readonly queuedMessage: OrchestrationQueuedMessage; + readonly occurredAt: string; +}): Effect.fn.Return< + ReadonlyArray, + PlatformError.PlatformError, + Crypto.Crypto +> { + const sourceProposedPlan = queuedMessage.sourceProposedPlan; + const sourceThread = sourceProposedPlan + ? findThreadById(readModel, sourceProposedPlan.threadId) + : undefined; + const sourcePlanStillValid = + sourceProposedPlan !== undefined && + sourceThread !== undefined && + sourceThread.projectId === thread.projectId && + sourceThread.proposedPlans.some((entry) => entry.id === sourceProposedPlan.planId); + + const removedEvent: PlannedOrchestrationEvent = { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: thread.id, + occurredAt, + commandId, + })), + type: "thread.queued-message-removed", + payload: { + threadId: thread.id, + messageId: queuedMessage.messageId, + reason: "dispatched", + removedAt: occurredAt, + }, + }; + const turnStartEvents = yield* planTurnStartEvents({ + commandId, + thread, + message: { + messageId: queuedMessage.messageId, + text: queuedMessage.text, + attachments: queuedMessage.attachments, + ...(queuedMessage.modelSelection !== undefined + ? { modelSelection: queuedMessage.modelSelection } + : {}), + ...(sourcePlanStillValid ? { sourceProposedPlan } : {}), + ...(queuedMessage.source !== undefined ? { source: queuedMessage.source } : {}), + }, + occurredAt, + }); + return [removedEvent, ...turnStartEvents]; +}); + const decideCommandSequence = Effect.fn("decideCommandSequence")(function* ({ commands, readModel, }: { readonly commands: ReadonlyArray; - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; }): Effect.fn.Return< ReadonlyArray, OrchestrationCommandRejection | PlatformError.PlatformError, @@ -212,7 +425,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" userInputActivity, }: { readonly command: OrchestrationCommand; - readonly readModel: OrchestrationReadModel; + readonly readModel: CommandReadModel; readonly userInputActivity?: OrchestrationThreadActivity; }): Effect.fn.Return< DecideOrchestrationCommandResult, @@ -631,36 +844,30 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" // structurally just a string): NaN fails every comparison, and an // unparseable snoozedUntil must never persist. if (!(Date.parse(command.snoozedUntil) > Date.parse(occurredAt))) { - return yield* Effect.fail( - new OrchestrationCommandInvariantError({ - commandType: command.type, - detail: `thread ${command.threadId} snooze wake time ${command.snoozedUntil} is not in the future`, - }), - ); + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `thread ${command.threadId} snooze wake time ${command.snoozedUntil} is not in the future`, + }); } // Blocked-on-you work must not be snoozed away: a pending approval or // user-input request is the agent waiting on the user, and hiding it // defeats the request. (A running session IS snoozable — snooze only // affects visibility, never the agent.) if (openRequests(thread).size > 0) { - return yield* Effect.fail( - new OrchestrationCommandInvariantError({ - commandType: command.type, - detail: `thread ${command.threadId} has a pending approval or user-input request and cannot be snoozed`, - }), - ); + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `thread ${command.threadId} has a pending approval or user-input request and cannot be snoozed`, + }); } // A queued turn start — a user message no turn has adopted yet — is // invisible pending work: no session, no pending flags. Snoozing in // that window would hide a just-requested turn exactly the way settle // would. if (hasQueuedTurnStartForThread(thread, occurredAt)) { - return yield* Effect.fail( - new OrchestrationCommandInvariantError({ - commandType: command.type, - detail: `thread ${command.threadId} has a queued turn start and cannot be snoozed`, - }), - ); + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `thread ${command.threadId} has a queued turn start and cannot be snoozed`, + }); } // Re-snoozing an already-snoozed thread to the SAME wake time is a // duplicate (double-click, raced clients): re-emit with the original @@ -897,7 +1104,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" const legacy = legacyLinkedPullRequestOf( thread.pullRequests, thread.projectId, - readModel.projects.find((project) => project.id === thread.projectId)?.repositoryIdentity, + findProjectById(readModel, thread.projectId)?.repositoryIdentity, ); const currentPullRequest = legacy === null @@ -907,7 +1114,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" ) ?? null); if (command.linkedPullRequest != null) { const { linkedPullRequest: linked, ...metadata } = command; - const project = readModel.projects.find((project) => project.id === thread.projectId); + const project = findProjectById(readModel, thread.projectId); let host = project?.repositoryIdentity?.canonicalKey.split("/")[0] ?? "unknown"; try { host = new URL(linked.url).hostname; @@ -971,6 +1178,10 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" thread.branch !== command.expectedBranch ? thread.branch : command.branch; + const nextWorktreePath = + command.worktreePath === null && thread.worktreePath !== null + ? thread.worktreePath + : command.worktreePath; const occurredAt = yield* nowIso; return { ...(yield* withEventBase({ @@ -1000,7 +1211,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" ? { modelSelection: command.modelSelection } : {}), ...(branch !== undefined ? { branch } : {}), - ...(command.worktreePath !== undefined ? { worktreePath: command.worktreePath } : {}), + ...(nextWorktreePath !== undefined ? { worktreePath: nextWorktreePath } : {}), ...(command.linkedPullRequest !== undefined ? { linkedPullRequest: command.linkedPullRequest } : {}), @@ -1305,87 +1516,224 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" detail: `Proposed plan '${sourceProposedPlan?.planId}' belongs to thread '${sourceThread.id}' in a different project.`, }); } - const userMessageEvent: Omit = { + // Queue-by-default: a follow-up arriving while a turn is active is + // held server-side and drained on natural turn completion. Explicit + // mid-turn injection goes through `thread.queue.steer`. Bootstrap + // starts are exempt — their thread was created in the same dispatch. + // `pendingTurnStart` covers the window where a turn start was just + // dispatched (by a send or a queue drain) but the provider has not + // reported the session status yet — a send in that gap must queue, + // not open a second concurrent turn ahead of already-queued chips. + // + // Compaction is the other exemption: `/compact` occupies the pending + // slot (and the session stays `starting`) so the reactor can restore + // it, but follow-ups must still emit `thread.turn-start-requested` + // for the in-memory compaction queue. Replaying an already-sent + // message id is the restore path (`server:after-compaction:`) — the + // previous replay's pending start is still live, so queueing would + // swallow the rest of the held turns. + const isCompactionQueueHold = isPendingCompactTurnStart(targetThread); + const isAfterCompactionReplay = targetThread.messages.some( + (entry) => entry.id === command.message.messageId && entry.role === "user", + ); + if ( + command.bootstrap === undefined && + !isCompactionQueueHold && + !isAfterCompactionReplay && + (isThreadTurnActive(targetThread) || targetThread.pendingTurnStart !== null) + ) { + if (targetThread.queuedMessages.length >= MAX_THREAD_QUEUED_MESSAGES) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Thread '${command.threadId}' already has ${MAX_THREAD_QUEUED_MESSAGES} queued messages.`, + }); + } + return { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt: command.createdAt, + commandId: command.commandId, + })), + type: "thread.message-queued", + payload: { + threadId: command.threadId, + messageId: command.message.messageId, + text: command.message.text, + attachments: command.message.attachments, + ...(command.modelSelection !== undefined + ? { modelSelection: command.modelSelection } + : {}), + ...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}), + ...(command.source !== undefined ? { source: command.source } : {}), + queuedAt: command.createdAt, + }, + }; + } + + return yield* planTurnStartEvents({ + commandId: command.commandId, + thread: targetThread, + message: { + messageId: command.message.messageId, + text: command.message.text, + attachments: command.message.attachments, + ...(command.modelSelection !== undefined + ? { modelSelection: command.modelSelection } + : {}), + ...(command.titleSeed !== undefined ? { titleSeed: command.titleSeed } : {}), + ...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}), + ...(command.source !== undefined ? { source: command.source } : {}), + }, + occurredAt: command.createdAt, + }); + } + + case "thread.queue.steer": { + const thread = yield* requireThread({ + readModel, + command, + threadId: command.threadId, + }); + const queuedMessage = thread.queuedMessages.find( + (entry) => entry.messageId === command.messageId, + ); + if (!queuedMessage) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Queued message '${command.messageId}' does not exist on thread '${command.threadId}'.`, + }); + } + // While a turn start is still pending there is no provider turn to + // steer into — dispatching now would race the pending turn/start with + // a second one. The message stays queued; steer again once running. + // A session that already tracks an active turn (running, or a + // provider reconnect mid-turn) is steerable. Rejected shapes: starting + // with no active turn, and any session without an active turn while a + // just-dispatched turn start is still awaiting adoption — including + // "running" with a null activeTurnId (provider waiting). + const steerRacesPendingStart = + (thread.session?.status === "starting" && thread.session.activeTurnId === null) || + (thread.pendingTurnStart !== null && (thread.session?.activeTurnId ?? null) === null); + if (steerRacesPendingStart) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Thread '${command.threadId}' is still starting a turn; steer once it is running.`, + }); + } + // Otherwise dispatch unconditionally: with a running turn the provider + // adapters treat the resulting sendTurn as a steer; on an idle thread + // this degrades to a normal turn start. + return yield* planQueuedMessageDispatch({ + commandId: command.commandId, + readModel, + thread, + queuedMessage, + occurredAt: command.createdAt, + }); + } + + case "thread.queue.remove": { + const thread = yield* requireThread({ + readModel, + command, + threadId: command.threadId, + }); + const queuedMessage = thread.queuedMessages.find( + (entry) => entry.messageId === command.messageId, + ); + if (!queuedMessage) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Queued message '${command.messageId}' does not exist on thread '${command.threadId}'.`, + }); + } + return { ...(yield* withEventBase({ aggregateKind: "thread", aggregateId: command.threadId, occurredAt: command.createdAt, commandId: command.commandId, })), - type: "thread.message-sent", + type: "thread.queued-message-removed", payload: { threadId: command.threadId, - messageId: command.message.messageId, - role: "user", - text: command.message.text, - attachments: command.message.attachments, - turnId: null, - streaming: false, - createdAt: command.createdAt, - updatedAt: command.createdAt, + messageId: command.messageId, + reason: "user", + removedAt: command.createdAt, }, }; - const turnStartRequestedEvent: Omit = { + } + + case "thread.queue.update": { + const thread = yield* requireThread({ + readModel, + command, + threadId: command.threadId, + }); + const queuedMessage = thread.queuedMessages.find( + (entry) => entry.messageId === command.messageId, + ); + if (!queuedMessage) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Queued message '${command.messageId}' does not exist on thread '${command.threadId}'.`, + }); + } + return { ...(yield* withEventBase({ aggregateKind: "thread", aggregateId: command.threadId, occurredAt: command.createdAt, commandId: command.commandId, })), - causationEventId: userMessageEvent.eventId, - type: "thread.turn-start-requested", + type: "thread.message-queued", payload: { threadId: command.threadId, - messageId: command.message.messageId, - ...(command.modelSelection !== undefined - ? { modelSelection: command.modelSelection } + messageId: queuedMessage.messageId, + text: command.text, + attachments: queuedMessage.attachments, + ...(queuedMessage.modelSelection !== undefined + ? { modelSelection: queuedMessage.modelSelection } : {}), - ...(command.titleSeed !== undefined ? { titleSeed: command.titleSeed } : {}), - runtimeMode: targetThread.runtimeMode, - interactionMode: targetThread.interactionMode, - ...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}), - createdAt: command.createdAt, + ...(queuedMessage.sourceProposedPlan !== undefined + ? { sourceProposedPlan: queuedMessage.sourceProposedPlan } + : {}), + queuedAt: queuedMessage.queuedAt, }, }; - // Real activity resets ANY override: it wakes an explicitly settled - // thread, and it clears a keep-active pin back to neutral so the - // thread can auto-settle again after this burst of work goes stale. - // A snooze clears the same way — sending a message to a snoozed - // thread is the user re-engaging, so the return ticket is spent. - const lifecycleResetEvents: Array> = []; - if (targetThread.settledOverride !== null) { - lifecycleResetEvents.push({ - ...(yield* withEventBase({ - aggregateKind: "thread", - aggregateId: command.threadId, - occurredAt: command.createdAt, - commandId: command.commandId, - })), - type: "thread.unsettled", - payload: { - threadId: command.threadId, - reason: "activity", - updatedAt: command.createdAt, - }, + } + + case "thread.queue.drain": { + const thread = yield* requireThread({ + readModel, + command, + threadId: command.threadId, + }); + const queuedMessage = thread.queuedMessages.at(0); + if (!queuedMessage) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Thread '${command.threadId}' has no queued messages to drain.`, }); } - if (targetThread.snoozedUntil != null) { - lifecycleResetEvents.push({ - ...(yield* withEventBase({ - aggregateKind: "thread", - aggregateId: command.threadId, - occurredAt: command.createdAt, - commandId: command.commandId, - })), - type: "thread.unsnoozed", - payload: { - threadId: command.threadId, - reason: "activity", - updatedAt: command.createdAt, - }, + // The user may have raced a new message in between turn completion and + // this drain; keep the queue intact and let the next completion retry. + // The pending-start check also stops a duplicate drain from double- + // dispatching while the first drained turn's session is still unset. + if (isThreadTurnActive(thread) || thread.pendingTurnStart !== null) { + return yield* new OrchestrationCommandInvariantError({ + commandType: command.type, + detail: `Thread '${command.threadId}' is busy; queued messages drain on turn completion.`, }); } - return [...lifecycleResetEvents, userMessageEvent, turnStartRequestedEvent]; + return yield* planQueuedMessageDispatch({ + commandId: command.commandId, + readModel, + thread, + queuedMessage, + occurredAt: command.createdAt, + }); } case "thread.turn.interrupt": { @@ -1410,6 +1758,27 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" }; } + case "thread.context.compact": { + yield* requireThread({ + readModel, + command, + threadId: command.threadId, + }); + return { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt: command.createdAt, + commandId: command.commandId, + })), + type: "thread.context-compact-requested", + payload: { + threadId: command.threadId, + createdAt: command.createdAt, + }, + }; + } + case "thread.approval.respond": { yield* requireThread({ readModel, @@ -1504,9 +1873,10 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" [`${question.question}\n${answer.trim()}`, attachmentLabels].filter(Boolean).join("\n"), ); } - // Commit the answer and its message together. The normal turn path - // steers a running agent or resumes an idle session. - return yield* decideCommandSequence({ + // Commit the answer and its message together. Do not go through + // `thread.turn.start` here: queue-by-default would hold the answer + // while the agent is still running, and the user never sees it. + const resolvedEvents = yield* decideCommandSequence({ readModel, commands: [ { @@ -1531,22 +1901,19 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" }, }, }, - { - type: "thread.turn.start", - commandId: command.commandId, - threadId: command.threadId, - createdAt: command.createdAt, - runtimeMode: thread.runtimeMode, - interactionMode: thread.interactionMode, - message: { - messageId: MessageId.make(`async-answer:${command.requestId}`), - role: "user", - text: replies.join("\n\n"), - attachments, - }, - }, ], }); + const turnEvents = yield* planTurnStartEvents({ + commandId: command.commandId, + thread, + message: { + messageId: MessageId.make(`async-answer:${command.requestId}`), + text: replies.join("\n\n"), + attachments, + }, + occurredAt: command.createdAt, + }); + return [...resolvedEvents, ...turnEvents]; } const responseEvent = { ...(yield* withEventBase({ @@ -1963,6 +2330,29 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" }; } + case "thread.messages.resync": { + yield* requireThread({ + readModel, + command, + threadId: command.threadId, + }); + return { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt: command.createdAt, + commandId: command.commandId, + })), + type: "thread.messages-resynced", + payload: { + threadId: command.threadId, + afterMessageId: command.afterMessageId, + messages: command.messages, + reason: command.reason, + }, + }; + } + case "thread.activity.append": { const thread = yield* requireThread({ readModel, diff --git a/apps/server/src/orchestration/decider.userInputDismiss.test.ts b/apps/server/src/orchestration/decider.userInputDismiss.test.ts index a61da0ca78b3..9d50d8ce67db 100644 --- a/apps/server/src/orchestration/decider.userInputDismiss.test.ts +++ b/apps/server/src/orchestration/decider.userInputDismiss.test.ts @@ -5,13 +5,13 @@ import { ProviderInstanceId, ThreadId, ApprovalRequestId, - type OrchestrationReadModel, type OrchestrationThreadActivity, } from "@t3tools/contracts"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import { findThreadById, fromWireReadModel } from "./commandReadModel.ts"; import { decideOrchestrationCommand } from "./decider.ts"; import { projectEvent } from "./projector.ts"; @@ -35,10 +35,8 @@ function makeRequest(responseMode: "message" | undefined): OrchestrationThreadAc }; } -function makeReadModel( - activities: ReadonlyArray, -): OrchestrationReadModel { - return { +function makeReadModel(activities: ReadonlyArray) { + return fromWireReadModel({ snapshotSequence: 0, projects: [], threads: [ @@ -63,6 +61,8 @@ function makeReadModel( pinnedAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [...activities], checkpoints: [], @@ -70,7 +70,7 @@ function makeReadModel( }, ], updatedAt: NOW, - }; + }); } const command = { @@ -102,8 +102,8 @@ it.layer(NodeServices.layer)("user input dismiss decider", (it) => { }, }); const projected = yield* projectEvent(readModel, { ...events[0]!, sequence: 1 }); - expect(projected.threads[0]?.messages).toEqual([]); - expect(projected.threads[0]?.latestTurn).toBeNull(); + expect(findThreadById(projected, threadId)?.messages).toEqual([]); + expect(findThreadById(projected, threadId)?.latestTurn).toBeNull(); }), ); diff --git a/apps/server/src/orchestration/http.ts b/apps/server/src/orchestration/http.ts index f7147106c7a9..a1ed2c6a6d73 100644 --- a/apps/server/src/orchestration/http.ts +++ b/apps/server/src/orchestration/http.ts @@ -2,6 +2,8 @@ import { AuthOrchestrationOperateScope, AuthOrchestrationReadScope, EnvironmentHttpApi, + type EnvironmentRequestInvalidReason, + IdentityError, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; import * as Option from "effect/Option"; @@ -16,15 +18,34 @@ import { failEnvironmentNotFound, requireEnvironmentScope, } from "../auth/http.ts"; +import * as SessionStore from "../auth/SessionStore.ts"; +import { GrokTranscriptResync } from "../externalSessions/GrokTranscriptResync.ts"; +import * as IdentityService from "../identity/IdentityService.ts"; +import { stampOrchestrationCommandSource } from "../identity/stampSource.ts"; import { OrchestrationEngineService } from "./Services/OrchestrationEngine.ts"; import { ProjectionSnapshotQuery } from "./Services/ProjectionSnapshotQuery.ts"; +const identityErrorToHttpReason = (error: IdentityError): EnvironmentRequestInvalidReason => { + switch (error.code) { + case "identity_claim_required": + case "identity_claim_missing": + return "identity_claim_required"; + case "identity_unknown_person": + return "identity_unknown_person"; + default: + return "identity_map_invalid"; + } +}; + export const orchestrationHttpApiLayer = HttpApiBuilder.group( EnvironmentHttpApi, "orchestration", Effect.fnUntraced(function* (handlers) { const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; const orchestrationEngine = yield* OrchestrationEngineService; + const grokTranscriptResync = yield* GrokTranscriptResync; + const identity = yield* IdentityService.IdentityService; + const sessions = yield* SessionStore.SessionStore; return handlers .handle( @@ -65,6 +86,11 @@ export const orchestrationHttpApiLayer = HttpApiBuilder.group( Effect.fn("environment.orchestration.threadSnapshot")(function* (args) { yield* annotateEnvironmentRequest(args.endpoint.name); yield* requireEnvironmentScope(AuthOrchestrationReadScope); + // Desktop/web cold-load the snapshot over HTTP before the WS + // subscribe. Resync here so the gzip HTTP payload already includes + // any grok-session-log catch-up (and so afterSequence catch-up is not + // the only path that heals dropped ACP updates). + yield* grokTranscriptResync.resyncThread(args.params.threadId); const snapshot = yield* projectionSnapshotQuery .getThreadDetailSnapshot( args.params.threadId, @@ -92,10 +118,33 @@ export const orchestrationHttpApiLayer = HttpApiBuilder.group( "dispatch", Effect.fn("environment.orchestration.dispatch")(function* (args) { yield* annotateEnvironmentRequest(args.endpoint.name); - yield* requireEnvironmentScope(AuthOrchestrationOperateScope); - const normalizedCommand = yield* normalizeDispatchCommand(args.payload).pipe( - Effect.catch(() => failEnvironmentInvalidRequest("invalid_command")), + const session = yield* requireEnvironmentScope(AuthOrchestrationOperateScope); + const clientDeviceType = yield* sessions.listActive().pipe( + Effect.map( + (active) => + active.find((entry) => entry.sessionId === session.sessionId)?.client.deviceType, + ), + Effect.orElseSucceed(() => undefined), ); + const operateClaim = yield* identity + .requireOperateClaim( + session.sessionId, + clientDeviceType !== undefined ? { clientDeviceType } : {}, + ) + .pipe( + Effect.catchTag("IdentityError", (error) => + failEnvironmentInvalidRequest(identityErrorToHttpReason(error)), + ), + ); + const mapPeople = yield* identity.listMapPeople(); + const normalizedCommand = stampOrchestrationCommandSource({ + command: yield* normalizeDispatchCommand(args.payload).pipe( + Effect.catch(() => failEnvironmentInvalidRequest("invalid_command")), + ), + claim: operateClaim, + clientDeviceType, + people: mapPeople, + }); return yield* orchestrationEngine.dispatch(normalizedCommand).pipe( Effect.tapError(() => cleanupFailedUploadedAttachments(args.payload, normalizedCommand), diff --git a/apps/server/src/orchestration/projector.pinned.test.ts b/apps/server/src/orchestration/projector.pinned.test.ts index 791bd4b75e61..68af8aad04b3 100644 --- a/apps/server/src/orchestration/projector.pinned.test.ts +++ b/apps/server/src/orchestration/projector.pinned.test.ts @@ -2,6 +2,7 @@ import { CommandId, EventId, ProjectId, + ProviderDriverKind, ThreadId, type OrchestrationEvent, } from "@t3tools/contracts"; @@ -10,6 +11,9 @@ import * as Effect from "effect/Effect"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; +const firstThread = (model: ReturnType) => + Array.from(model.threads)[0]?.[1]; + function makeEvent(input: { readonly sequence: number; readonly type: OrchestrationEvent["type"]; @@ -42,7 +46,7 @@ it.effect("projects pin lifecycle events", () => threadId: ThreadId.make("thread-1"), projectId: ProjectId.make("project-1"), title: "Thread", - modelSelection: { provider: "codex", model: "gpt-5.4" }, + modelSelection: { provider: ProviderDriverKind.make("codex"), model: "gpt-5.4" }, runtimeMode: "full-access", interactionMode: "default", branch: null, @@ -52,7 +56,7 @@ it.effect("projects pin lifecycle events", () => }, }), ); - expect(created.threads[0]?.pinnedAt ?? null).toBeNull(); + expect(firstThread(created)?.pinnedAt ?? null).toBeNull(); const pinned = yield* projectEvent( created, @@ -62,7 +66,7 @@ it.effect("projects pin lifecycle events", () => payload: { threadId: ThreadId.make("thread-1"), pinnedAt: now, updatedAt: now }, }), ); - expect(pinned.threads[0]?.pinnedAt).toBe(now); + expect(firstThread(pinned)?.pinnedAt).toBe(now); const unpinned = yield* projectEvent( pinned, @@ -72,7 +76,7 @@ it.effect("projects pin lifecycle events", () => payload: { threadId: ThreadId.make("thread-1"), updatedAt: now }, }), ); - expect(unpinned.threads[0]?.pinnedAt).toBeNull(); + expect(firstThread(unpinned)?.pinnedAt ?? null).toBeNull(); }), ); @@ -98,7 +102,7 @@ it.effect("projects pin order key lifecycle", () => }, }), ); - expect(created.threads[0]?.pinOrderKey ?? null).toBeNull(); + expect(firstThread(created)?.pinOrderKey ?? null).toBeNull(); // Fresh pin carries the client's slot in the arranged order. const pinned = yield* projectEvent( @@ -114,7 +118,7 @@ it.effect("projects pin order key lifecycle", () => }, }), ); - expect(pinned.threads[0]?.pinOrderKey).toBe("g"); + expect(firstThread(pinned)?.pinOrderKey).toBe("g"); // Re-pins and events from pre-reorder servers omit the field entirely; // the existing key must survive rather than being nulled out. @@ -126,7 +130,7 @@ it.effect("projects pin order key lifecycle", () => payload: { threadId: ThreadId.make("thread-1"), pinnedAt: now, updatedAt: now }, }), ); - expect(repinned.threads[0]?.pinOrderKey).toBe("g"); + expect(firstThread(repinned)?.pinOrderKey).toBe("g"); // A drag persists the new slot. const reordered = yield* projectEvent( @@ -137,7 +141,7 @@ it.effect("projects pin order key lifecycle", () => payload: { threadId: ThreadId.make("thread-1"), orderKey: "m", updatedAt: now }, }), ); - expect(reordered.threads[0]?.pinOrderKey).toBe("m"); + expect(firstThread(reordered)?.pinOrderKey).toBe("m"); // Unpin clears the slot: re-pinning is "pin again", not "restore an // ancient position". @@ -149,6 +153,6 @@ it.effect("projects pin order key lifecycle", () => payload: { threadId: ThreadId.make("thread-1"), updatedAt: now }, }), ); - expect(unpinned.threads[0]?.pinOrderKey).toBeNull(); + expect(firstThread(unpinned)?.pinOrderKey).toBeNull(); }), ); diff --git a/apps/server/src/orchestration/projector.pullRequests.test.ts b/apps/server/src/orchestration/projector.pullRequests.test.ts index 6876cdde4f0c..7ad8c4fcdc2c 100644 --- a/apps/server/src/orchestration/projector.pullRequests.test.ts +++ b/apps/server/src/orchestration/projector.pullRequests.test.ts @@ -4,14 +4,16 @@ import { ProjectId, ThreadId, type OrchestrationEvent, - type OrchestrationReadModel, type RepositoryIdentity, type ThreadPullRequestLink, type ThreadPullRequestSnapshot, } from "@t3tools/contracts"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; +import * as Option from "effect/Option"; +import { type CommandReadModel } from "./commandReadModel.ts"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; const NOW = "2026-01-01T00:00:00.000Z"; @@ -63,7 +65,11 @@ const snapshot: ThreadPullRequestSnapshot = { syncedAt: LATER, }; -const createThread = (model: OrchestrationReadModel) => +function threadOf(model: CommandReadModel) { + return Option.getOrThrow(HashMap.get(model.threads, THREAD_ID)); +} + +const createThread = (model: CommandReadModel) => projectEvent( model, makeEvent({ @@ -84,7 +90,7 @@ const createThread = (model: OrchestrationReadModel) => }), ); -const createProject = (model: OrchestrationReadModel, repositoryIdentity: RepositoryIdentity) => +const createProject = (model: CommandReadModel, repositoryIdentity: RepositoryIdentity) => projectEvent(model, { ...makeEvent({ sequence: model.snapshotSequence + 1, @@ -104,17 +110,18 @@ const createProject = (model: OrchestrationReadModel, repositoryIdentity: Reposi }).pipe( Effect.map((next) => ({ ...next, - projects: next.projects.map((project) => - project.id === PROJECT_ID ? { ...project, repositoryIdentity } : project, - ), + projects: HashMap.set(next.projects, PROJECT_ID, { + ...Option.getOrThrow(HashMap.get(next.projects, PROJECT_ID)), + repositoryIdentity, + }), })), ); it.effect("seeds threads with no pull requests", () => Effect.gen(function* () { const created = yield* createThread(createEmptyReadModel(NOW)); - expect(created.threads[0]?.pullRequests).toEqual([]); - expect(created.threads[0]?.linkedPullRequest ?? null).toBeNull(); + expect(threadOf(created)?.pullRequests).toEqual([]); + expect(threadOf(created)?.linkedPullRequest ?? null).toBeNull(); }), ); @@ -142,10 +149,10 @@ it.effect("projects link, sync, and unlink onto the thread", () => payload: { threadId: THREAD_ID, link, updatedAt: LATER }, }), ); - expect(linked.threads[0]?.pullRequests).toEqual([link]); - expect(linked.threads[0]?.updatedAt).toBe(LATER); + expect(threadOf(linked)?.pullRequests).toEqual([link]); + expect(threadOf(linked)?.updatedAt).toBe(LATER); // The legacy field is derived from the array so old clients keep working. - expect(linked.threads[0]?.linkedPullRequest).toEqual({ + expect(threadOf(linked)?.linkedPullRequest).toEqual({ projectId: PROJECT_ID, repository: "t3tools/t3code", number: 42, @@ -166,8 +173,8 @@ it.effect("projects link, sync, and unlink onto the thread", () => }, }), ); - expect(relinked.threads[0]?.pullRequests).toHaveLength(1); - expect(relinked.threads[0]?.pullRequests[0]?.source).toBe("agent"); + expect(threadOf(relinked)?.pullRequests).toHaveLength(1); + expect(threadOf(relinked)?.pullRequests[0]?.source).toBe("agent"); const synced = yield* projectEvent( relinked, @@ -185,7 +192,7 @@ it.effect("projects link, sync, and unlink onto the thread", () => }, }), ); - expect(synced.threads[0]?.pullRequests[0]?.snapshot).toEqual(snapshot); + expect(threadOf(synced)?.pullRequests[0]?.snapshot).toEqual(snapshot); const unlinked = yield* projectEvent( synced, @@ -201,8 +208,8 @@ it.effect("projects link, sync, and unlink onto the thread", () => }, }), ); - expect(unlinked.threads[0]?.pullRequests).toEqual([]); - expect(unlinked.threads[0]?.linkedPullRequest).toBeNull(); + expect(threadOf(unlinked)?.pullRequests).toEqual([]); + expect(threadOf(unlinked)?.linkedPullRequest).toBeNull(); }), ); @@ -234,8 +241,8 @@ it.effect("ignores a sync for a pull request that is no longer linked", () => }, }), ); - expect(synced.threads[0]?.pullRequests).toEqual([other]); - expect(synced.threads[0]?.updatedAt).toBe(NOW); + expect(threadOf(synced)?.pullRequests).toEqual([other]); + expect(threadOf(synced)?.updatedAt).toBe(NOW); }), ); @@ -283,7 +290,7 @@ it.effect("mirrors legacy meta-updated links into pullRequests using the project }, }), ); - expect(legacyLinked.threads[0]?.pullRequests).toEqual([ + expect(threadOf(legacyLinked)?.pullRequests).toEqual([ agentLink, { host: "github.com", @@ -297,7 +304,7 @@ it.effect("mirrors legacy meta-updated links into pullRequests using the project }, ]); // Two open links read as a stack; the derived field points at the top. - expect(legacyLinked.threads[0]?.linkedPullRequest).toEqual({ + expect(threadOf(legacyLinked)?.linkedPullRequest).toEqual({ projectId: PROJECT_ID, repository: "t3tools/t3code", number: 42, @@ -313,8 +320,8 @@ it.effect("mirrors legacy meta-updated links into pullRequests using the project payload: { threadId: THREAD_ID, linkedPullRequest: null, updatedAt: LATER }, }), ); - expect(legacyCleared.threads[0]?.pullRequests).toEqual([agentLink]); - expect(legacyCleared.threads[0]?.linkedPullRequest).toEqual({ + expect(threadOf(legacyCleared)?.pullRequests).toEqual([agentLink]); + expect(threadOf(legacyCleared)?.linkedPullRequest).toEqual({ projectId: PROJECT_ID, repository: "t3tools/t3code", number: 7, @@ -343,7 +350,7 @@ it.effect("falls back to the link URL host when the project has no repository id }, }), ); - expect(legacyLinked.threads[0]?.pullRequests[0]?.host).toBe("gitlab.example.com"); + expect(threadOf(legacyLinked)?.pullRequests[0]?.host).toBe("gitlab.example.com"); }), ); @@ -367,8 +374,8 @@ it.effect("leaves pullRequests alone when meta-updated carries no legacy link", payload: { threadId: THREAD_ID, title: "Renamed", updatedAt: LATER }, }), ); - expect(retitled.threads[0]?.title).toBe("Renamed"); - expect(retitled.threads[0]?.pullRequests).toEqual([link]); + expect(threadOf(retitled)?.title).toBe("Renamed"); + expect(threadOf(retitled)?.pullRequests).toEqual([link]); }), ); @@ -400,7 +407,7 @@ it.effect("replays Azure legacy selectors as full repository keys", () => payload: { threadId: THREAD_ID, linkedPullRequest: legacy, updatedAt: LATER }, }), ); - expect(model.threads[0]?.pullRequests).toEqual([ + expect(threadOf(model)?.pullRequests).toEqual([ { host: "dev.azure.com", repository: "org-a/project/_git/web", @@ -412,6 +419,6 @@ it.effect("replays Azure legacy selectors as full repository keys", () => stack: null, }, ]); - expect(model.threads[0]?.linkedPullRequest).toEqual(legacy); + expect(threadOf(model)?.linkedPullRequest).toEqual(legacy); }), ); diff --git a/apps/server/src/orchestration/projector.settled.test.ts b/apps/server/src/orchestration/projector.settled.test.ts index 7c9395e6d2bd..0ef95553a16a 100644 --- a/apps/server/src/orchestration/projector.settled.test.ts +++ b/apps/server/src/orchestration/projector.settled.test.ts @@ -8,6 +8,7 @@ import { import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import { findThreadById } from "./commandReadModel.ts"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; function makeEvent(input: { @@ -60,9 +61,9 @@ it.effect("projects settled lifecycle events", () => payload: { threadId: ThreadId.make("thread-1"), settledAt: now, updatedAt: now }, }), ); - expect(settled.threads[0]?.settledOverride).toBe("settled"); - expect(settled.threads[0]?.settledAt).toBe(now); - expect(settled.threads[0]?.unsettledAt).toBeNull(); + expect(findThreadById(settled, ThreadId.make("thread-1"))?.settledOverride).toBe("settled"); + expect(findThreadById(settled, ThreadId.make("thread-1"))?.settledAt).toBe(now); + expect(findThreadById(settled, ThreadId.make("thread-1"))?.unsettledAt).toBeNull(); const unsettleAt = "2026-01-02T00:00:00.000Z"; const userUnsettled = yield* projectEvent( @@ -73,9 +74,11 @@ it.effect("projects settled lifecycle events", () => payload: { threadId: ThreadId.make("thread-1"), reason: "user", updatedAt: unsettleAt }, }), ); - expect(userUnsettled.threads[0]?.settledOverride).toBe("active"); - expect(userUnsettled.threads[0]?.settledAt).toBeNull(); - expect(userUnsettled.threads[0]?.unsettledAt).toBe(unsettleAt); + expect(findThreadById(userUnsettled, ThreadId.make("thread-1"))?.settledOverride).toBe( + "active", + ); + expect(findThreadById(userUnsettled, ThreadId.make("thread-1"))?.settledAt).toBeNull(); + expect(findThreadById(userUnsettled, ThreadId.make("thread-1"))?.unsettledAt).toBe(unsettleAt); // Clearing the keep-active pin on activity is not a re-entry: the thread // is already in the active list, so the stamp must not move it. @@ -88,9 +91,13 @@ it.effect("projects settled lifecycle events", () => payload: { threadId: ThreadId.make("thread-1"), reason: "activity", updatedAt: activityAt }, }), ); - expect(activityUnsettled.threads[0]?.settledOverride).toBeNull(); - expect(activityUnsettled.threads[0]?.settledAt).toBeNull(); - expect(activityUnsettled.threads[0]?.unsettledAt).toBe(unsettleAt); + expect( + findThreadById(activityUnsettled, ThreadId.make("thread-1"))?.settledOverride, + ).toBeNull(); + expect(findThreadById(activityUnsettled, ThreadId.make("thread-1"))?.settledAt).toBeNull(); + expect(findThreadById(activityUnsettled, ThreadId.make("thread-1"))?.unsettledAt).toBe( + unsettleAt, + ); const resettledAt = "2026-01-04T00:00:00.000Z"; const resettled = yield* projectEvent( @@ -105,7 +112,7 @@ it.effect("projects settled lifecycle events", () => }, }), ); - expect(resettled.threads[0]?.unsettledAt).toBeNull(); + expect(findThreadById(resettled, ThreadId.make("thread-1"))?.unsettledAt).toBeNull(); // Waking a settled thread on activity IS a re-entry and stamps. const wakeAt = "2026-01-05T00:00:00.000Z"; @@ -117,7 +124,7 @@ it.effect("projects settled lifecycle events", () => payload: { threadId: ThreadId.make("thread-1"), reason: "activity", updatedAt: wakeAt }, }), ); - expect(woke.threads[0]?.settledOverride).toBeNull(); - expect(woke.threads[0]?.unsettledAt).toBe(wakeAt); + expect(findThreadById(woke, ThreadId.make("thread-1"))?.settledOverride).toBeNull(); + expect(findThreadById(woke, ThreadId.make("thread-1"))?.unsettledAt).toBe(wakeAt); }), ); diff --git a/apps/server/src/orchestration/projector.test.ts b/apps/server/src/orchestration/projector.test.ts index 39aaacd8739d..5638733f9b68 100644 --- a/apps/server/src/orchestration/projector.test.ts +++ b/apps/server/src/orchestration/projector.test.ts @@ -5,13 +5,26 @@ import { ProviderDriverKind, ThreadId, type OrchestrationEvent, + type OrchestrationThread, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; import { it as effectIt } from "@effect/vitest"; import { describe, expect, it } from "vite-plus/test"; +import type { CommandReadModel } from "./commandReadModel.ts"; import { createEmptyReadModel, projectEvent } from "./projector.ts"; +/** Thread list from the map, for assertions that previously used an array. */ +function threadsArray(model: CommandReadModel): ReadonlyArray { + return Array.from(HashMap.values(model.threads)); +} + +/** First thread in the map (insertion-order-independent tests use a single thread). */ +function firstThread(model: CommandReadModel): OrchestrationThread | undefined { + return threadsArray(model)[0]; +} + function makeEvent(input: { sequence: number; type: OrchestrationEvent["type"]; @@ -73,7 +86,7 @@ describe("orchestration projector", () => { ); expect(next.snapshotSequence).toBe(1); - expect(next.threads).toEqual([ + expect(threadsArray(next)).toEqual([ { id: "thread-1", projectId: "project-1", @@ -100,6 +113,8 @@ describe("orchestration projector", () => { snoozedAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -120,28 +135,31 @@ describe("orchestration projector", () => { let model = yield* projectEvent( { ...createEmptyReadModel(now), - projects: [ - { - id: ProjectId.make("project-1"), - title: "T3 Code", - workspaceRoot: "/repo", - defaultModelSelection: null, - scripts: [], - createdAt: now, - updatedAt: now, - deletedAt: null, - repositoryIdentity: { - canonicalKey: "github.com/pingdotgg/t3code", - provider: "github", - displayName: "pingdotgg/t3code", - locator: { - source: "git-remote", - remoteName: "origin", - remoteUrl: "https://github.com/pingdotgg/t3code.git", + projects: HashMap.fromIterable([ + [ + ProjectId.make("project-1"), + { + id: ProjectId.make("project-1"), + title: "T3 Code", + workspaceRoot: "/repo", + defaultModelSelection: null, + scripts: [], + createdAt: now, + updatedAt: now, + deletedAt: null, + repositoryIdentity: { + canonicalKey: "github.com/pingdotgg/t3code", + provider: "github", + displayName: "pingdotgg/t3code", + locator: { + source: "git-remote", + remoteName: "origin", + remoteUrl: "https://github.com/pingdotgg/t3code.git", + }, }, }, - }, - ], + ], + ]), }, makeEvent({ ...eventFields, @@ -187,8 +205,8 @@ describe("orchestration projector", () => { payload: { threadId: "thread-1", updatedAt: now, ...update.payload }, }), ); - expect(model.threads[0]?.branchPullRequest).toEqual(update.expected); - expect(model.threads[0]?.linkedPullRequest).toEqual(linkedPullRequest); + expect(firstThread(model)?.branchPullRequest).toEqual(update.expected); + expect(firstThread(model)?.linkedPullRequest).toEqual(linkedPullRequest); } }), ); @@ -277,7 +295,7 @@ describe("orchestration projector", () => { }), ), ); - expect(archived.threads[0]?.archivedAt).toBe(later); + expect(firstThread(archived)?.archivedAt).toBe(later); const unarchived = await Effect.runPromise( projectEvent( @@ -296,7 +314,7 @@ describe("orchestration projector", () => { }), ), ); - expect(unarchived.threads[0]?.archivedAt).toBeNull(); + expect(firstThread(unarchived)?.archivedAt).toBeNull(); }); it("keeps projector forward-compatible for unhandled event types", async () => { @@ -325,7 +343,7 @@ describe("orchestration projector", () => { expect(next.snapshotSequence).toBe(7); expect(next.updatedAt).toBe("2026-01-01T00:00:00.000Z"); - expect(next.threads).toEqual([]); + expect(threadsArray(next)).toEqual([]); }); effectIt.effect.each([ @@ -423,13 +441,13 @@ describe("orchestration projector", () => { ), ); - const thread = afterRunning.threads[0]; + const thread = firstThread(afterRunning); expect(thread?.latestTurn?.turnId).toBe("turn-1"); expect(thread?.session?.status).toBe("running"); // Leaving the "running" session status settles the running turn with the // session timestamp as the turn end. - const settledThread = afterReady.threads[0]; + const settledThread = firstThread(afterReady); expect(settledThread?.latestTurn?.turnId).toBe("turn-1"); expect(settledThread?.latestTurn?.state).toBe(state); expect(settledThread?.latestTurn?.completedAt).toBe(settledAt); @@ -455,8 +473,8 @@ describe("orchestration projector", () => { }, }), ); - expect(captured.threads[0]?.latestTurn?.state).toBe(state); - expect(captured.threads[0]?.checkpoints[0]?.status).toBe("ready"); + expect(firstThread(captured)?.latestTurn?.state).toBe(state); + expect(firstThread(captured)?.checkpoints[0]?.status).toBe("ready"); }), ); @@ -549,7 +567,7 @@ describe("orchestration projector", () => { checkpointRef: "refs/t3/checkpoints/thread-placeholder/turn/1", }), ); - expect(model.threads[0]?.latestTurn?.state).toBe( + expect(firstThread(model)?.latestTurn?.state).toBe( sessionStatus === "interrupted" || sessionStatus === "stopped" ? "interrupted" : "completed", @@ -609,8 +627,8 @@ describe("orchestration projector", () => { ), ); - expect(afterUpdate.threads[0]?.runtimeMode).toBe("approval-required"); - expect(afterUpdate.threads[0]?.updatedAt).toBe(updatedAt); + expect(firstThread(afterUpdate)?.runtimeMode).toBe("approval-required"); + expect(firstThread(afterUpdate)?.updatedAt).toBe(updatedAt); }); it("marks assistant messages completed with non-streaming updates", async () => { @@ -695,13 +713,128 @@ describe("orchestration projector", () => { ), ); - const message = afterComplete.threads[0]?.messages[0]; + const message = firstThread(afterComplete)?.messages[0]; expect(message?.id).toBe("assistant:msg-1"); expect(message?.text).toBe("hello"); expect(message?.streaming).toBe(false); expect(message?.updatedAt).toBe(completeAt); }); + it("does not rebind an assistant message turnId when a later complete races under the next turn", async () => { + // Production race (t3vm thread 16feaadd…): queue drain re-emits + // assistant.complete for the same segment id under the new turnId with empty + // text. The body must stay, and turnId must stay on the completed turn so + // Discord/web do not swallow the final under the next Working tip. + const createdAt = "2026-07-27T05:54:00.000Z"; + const completeAt = "2026-07-27T05:57:21.174Z"; + const restampAt = "2026-07-27T05:57:32.206Z"; + const model = createEmptyReadModel(createdAt); + + // Single runPromise so we stay within the file's LEGACY_BASELINE for + // t3code/no-manual-effect-runtime-in-tests. + const afterRestamp = await Effect.runPromise( + Effect.gen(function* () { + const afterCreate = yield* projectEvent( + model, + makeEvent({ + sequence: 1, + type: "thread.created", + aggregateKind: "thread", + aggregateId: "thread-1", + occurredAt: createdAt, + commandId: "cmd-create", + payload: { + threadId: "thread-1", + projectId: "project-1", + title: "demo", + modelSelection: { + provider: ProviderDriverKind.make("codex"), + model: "gpt-5.3-codex", + }, + runtimeMode: "full-access", + branch: null, + worktreePath: null, + createdAt, + updatedAt: createdAt, + }, + }), + ); + + const afterFinal = yield* projectEvent( + afterCreate, + makeEvent({ + sequence: 2, + type: "thread.message-sent", + aggregateKind: "thread", + aggregateId: "thread-1", + occurredAt: completeAt, + commandId: "cmd-final-delta", + payload: { + threadId: "thread-1", + messageId: "assistant:run:segment:5", + role: "assistant", + text: "**Yes — the bug is almost entirely a naming/dual-use problem.**", + turnId: "turn-prior", + streaming: true, + createdAt: completeAt, + updatedAt: completeAt, + }, + }), + ); + + const afterComplete = yield* projectEvent( + afterFinal, + makeEvent({ + sequence: 3, + type: "thread.message-sent", + aggregateKind: "thread", + aggregateId: "thread-1", + occurredAt: completeAt, + commandId: "cmd-final-complete", + payload: { + threadId: "thread-1", + messageId: "assistant:run:segment:5", + role: "assistant", + text: "", + turnId: "turn-prior", + streaming: false, + createdAt: completeAt, + updatedAt: completeAt, + }, + }), + ); + + return yield* projectEvent( + afterComplete, + makeEvent({ + sequence: 4, + type: "thread.message-sent", + aggregateKind: "thread", + aggregateId: "thread-1", + occurredAt: restampAt, + commandId: "cmd-restamp-complete", + payload: { + threadId: "thread-1", + messageId: "assistant:run:segment:5", + role: "assistant", + text: "", + turnId: "turn-next", + streaming: false, + createdAt: restampAt, + updatedAt: restampAt, + }, + }), + ); + }), + ); + + const message = firstThread(afterRestamp)?.messages[0]; + expect(message?.id).toBe("assistant:run:segment:5"); + expect(message?.text).toBe("**Yes — the bug is almost entirely a naming/dual-use problem.**"); + expect(message?.turnId).toBe("turn-prior"); + expect(message?.streaming).toBe(false); + }); + it("prunes reverted turn messages from in-memory thread snapshot", async () => { const createdAt = "2026-02-23T10:00:00.000Z"; const model = createEmptyReadModel(createdAt); @@ -903,7 +1036,7 @@ describe("orchestration projector", () => { Promise.resolve(afterCreate), ); - const thread = afterRevert.threads[0]; + const thread = firstThread(afterRevert); expect(thread?.messages.map((message) => ({ role: message.role, text: message.text }))).toEqual( [ { role: "user", text: "First edit" }, @@ -1060,7 +1193,7 @@ describe("orchestration projector", () => { Promise.resolve(afterCreate), ); - const thread = afterRevert.threads[0]; + const thread = firstThread(afterRevert); expect( thread?.messages.map((message) => ({ id: message.id, @@ -1074,34 +1207,6 @@ describe("orchestration projector", () => { const createdAt = "2026-03-01T10:00:00.000Z"; const model = createEmptyReadModel(createdAt); - const afterCreate = await Effect.runPromise( - projectEvent( - model, - makeEvent({ - sequence: 1, - type: "thread.created", - aggregateKind: "thread", - aggregateId: "thread-capped", - occurredAt: createdAt, - commandId: "cmd-create-capped", - payload: { - threadId: "thread-capped", - projectId: "project-1", - title: "capped", - modelSelection: { - provider: ProviderDriverKind.make("codex"), - model: "gpt-5-codex", - }, - runtimeMode: "full-access", - branch: null, - worktreePath: null, - createdAt, - updatedAt: createdAt, - }, - }), - ), - ); - const messageEvents: ReadonlyArray = Array.from( { length: 2_100 }, (_, index) => @@ -1124,14 +1229,6 @@ describe("orchestration projector", () => { }, }), ); - const afterMessages = await messageEvents.reduce< - Promise> - >( - (statePromise, event) => - statePromise.then((state) => Effect.runPromise(projectEvent(state, event))), - Promise.resolve(afterCreate), - ); - const checkpointEvents: ReadonlyArray = Array.from( { length: 600 }, (_, index) => @@ -1154,15 +1251,44 @@ describe("orchestration projector", () => { }, }), ); - const finalState = await checkpointEvents.reduce< - Promise> - >( - (statePromise, event) => - statePromise.then((state) => Effect.runPromise(projectEvent(state, event))), - Promise.resolve(afterMessages), + const finalState = await Effect.runPromise( + Effect.gen(function* () { + let state = yield* projectEvent( + model, + makeEvent({ + sequence: 1, + type: "thread.created", + aggregateKind: "thread", + aggregateId: "thread-capped", + occurredAt: createdAt, + commandId: "cmd-create-capped", + payload: { + threadId: "thread-capped", + projectId: "project-1", + title: "capped", + modelSelection: { + provider: ProviderDriverKind.make("codex"), + model: "gpt-5-codex", + }, + runtimeMode: "full-access", + branch: null, + worktreePath: null, + createdAt, + updatedAt: createdAt, + }, + }), + ); + for (const event of messageEvents) { + state = yield* projectEvent(state, event); + } + for (const event of checkpointEvents) { + state = yield* projectEvent(state, event); + } + return state; + }), ); - const thread = finalState.threads[0]; + const thread = firstThread(finalState); expect(thread?.messages).toHaveLength(2_000); expect(thread?.messages[0]?.id).toBe("msg-100"); expect(thread?.messages.at(-1)?.id).toBe("msg-2099"); diff --git a/apps/server/src/orchestration/projector.ts b/apps/server/src/orchestration/projector.ts index 02435ea5ba44..a413404db2de 100644 --- a/apps/server/src/orchestration/projector.ts +++ b/apps/server/src/orchestration/projector.ts @@ -13,7 +13,10 @@ import { OrchestrationMessage, OrchestrationSession, OrchestrationThread, + type SourceRef, + type ThreadParticipantSummary, } from "@t3tools/contracts"; +import { mergeParticipantSummaries, nextOriginSource } from "@t3tools/shared/sourceAttribution"; import { legacyLinkedPullRequestOf, legacyThreadPullRequestKey, @@ -21,12 +24,22 @@ import { } from "@t3tools/shared/threadPullRequests"; import { compareDateTimeStrings } from "@t3tools/shared/dateTime"; import * as Effect from "effect/Effect"; +import * as HashMap from "effect/HashMap"; +import * as HashSet from "effect/HashSet"; +import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import * as Predicate from "effect/Predicate"; +import { + createEmptyCommandReadModel, + findThreadById, + type CommandReadModel, +} from "./commandReadModel.ts"; import { toProjectorDecodeError, type OrchestrationProjectorDecodeError } from "./Errors.ts"; import { MessageSentPayloadSchema, + ThreadMessageQueuedPayload, + ThreadQueuedMessageRemovedPayload, ProjectCreatedPayload, ProjectDeletedPayload, ProjectMetaUpdatedPayload, @@ -52,6 +65,7 @@ import { ThreadRevertedPayload, ThreadSessionSetPayload, ThreadTurnDiffCompletedPayload, + ThreadTurnStartRequestedPayload, } from "./Schemas.ts"; type ThreadPatch = Partial>; @@ -86,6 +100,20 @@ function checkpointStatusToLatestTurnState(status: "ready" | "missing" | "error" return "completed" as const; } +function isPendingCompactTurnStart(thread: OrchestrationThread): boolean { + const pending = thread.pendingTurnStart; + if (pending === null) { + return false; + } + const message = thread.messages.find((entry) => entry.id === pending.messageId); + return ( + message !== undefined && + message.role === "user" && + (message.attachments?.length ?? 0) === 0 && + message.text.trim().toLowerCase() === "/compact" + ); +} + /** * Turn state to settle a still-running latest turn with when its session * leaves the "running" status, or null while the session is (re)starting or @@ -109,26 +137,55 @@ function settledTurnStateForSessionStatus( } } +/** + * Apply a patch to a single thread, keyed by id. No-op if the thread is absent + * (mirrors the previous array-map behavior, which left the collection unchanged + * when no entry matched). + */ function updateThread( - threads: ReadonlyArray, + threads: HashMap.HashMap, threadId: ThreadId, patch: ThreadPatch, -): OrchestrationThread[] { - return threads.map((thread) => (thread.id === threadId ? { ...thread, ...patch } : thread)); +): HashMap.HashMap { + const existing = HashMap.get(threads, threadId); + if (Option.isNone(existing)) { + return threads; + } + return HashMap.set(threads, threadId, { ...existing.value, ...patch }); +} + +/** + * Apply an update function to a single project in the model, keyed by id. No-op + * if the project is absent. + */ +function updateProject( + model: CommandReadModel, + projectId: OrchestrationProject["id"], + update: (project: OrchestrationProject) => OrchestrationProject, +): CommandReadModel { + const existing = HashMap.get(model.projects, projectId); + if (Option.isNone(existing)) { + return model; + } + return { + ...model, + projects: HashMap.set(model.projects, projectId, update(existing.value)), + }; } /** Patch that swaps a thread's links and re-derives the legacy single-PR field from them. */ function pullRequestsPatch( thread: Pick, pullRequests: ReadonlyArray, - projects: OrchestrationReadModel["projects"], + projects: CommandReadModel["projects"], ): Pick { + const project = Option.getOrUndefined(HashMap.get(projects, thread.projectId)); return { pullRequests, linkedPullRequest: legacyLinkedPullRequestOf( pullRequests, thread.projectId, - projects.find((project) => project.id === thread.projectId)?.repositoryIdentity, + project?.repositoryIdentity, ), }; } @@ -305,20 +362,15 @@ function compareThreadActivities( return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id); } -export function createEmptyReadModel(nowIso: string): OrchestrationReadModel { - return { - snapshotSequence: 0, - projects: [], - threads: [], - updatedAt: nowIso, - }; +export function createEmptyReadModel(nowIso: string): CommandReadModel { + return createEmptyCommandReadModel(nowIso); } export function projectEvent( - model: OrchestrationReadModel, + model: CommandReadModel, event: OrchestrationEvent, -): Effect.Effect { - const nextBase: OrchestrationReadModel = { +): Effect.Effect { + const nextBase: CommandReadModel = { ...model, snapshotSequence: event.sequence, updatedAt: event.occurredAt, @@ -328,8 +380,7 @@ export function projectEvent( case "project.created": return decodeForEvent(ProjectCreatedPayload, event.payload, event.type, "payload").pipe( Effect.map((payload) => { - const existing = nextBase.projects.find((entry) => entry.id === payload.projectId); - const nextProject = { + const nextProject: OrchestrationProject = { id: payload.projectId, title: payload.title, workspaceRoot: payload.workspaceRoot, @@ -346,62 +397,44 @@ export function projectEvent( return { ...nextBase, - projects: existing - ? nextBase.projects.map((entry) => - entry.id === payload.projectId ? nextProject : entry, - ) - : [...nextBase.projects, nextProject], + projects: HashMap.set(nextBase.projects, payload.projectId, nextProject), }; }), ); case "project.meta-updated": return decodeForEvent(ProjectMetaUpdatedPayload, event.payload, event.type, "payload").pipe( - Effect.map((payload) => ({ - ...nextBase, - projects: nextBase.projects.map((project) => - project.id === payload.projectId - ? { - ...project, - ...(payload.title !== undefined ? { title: payload.title } : {}), - ...(payload.workspaceRoot !== undefined - ? { workspaceRoot: payload.workspaceRoot } - : {}), - ...(payload.defaultModelSelection !== undefined - ? { defaultModelSelection: payload.defaultModelSelection } - : {}), - ...(payload.defaultThreadEnvMode !== undefined - ? { defaultThreadEnvMode: payload.defaultThreadEnvMode } - : {}), - ...(payload.autoPull !== undefined ? { autoPull: payload.autoPull } : {}), - ...(payload.faviconPath !== undefined - ? { faviconPath: payload.faviconPath } - : {}), - ...(payload.projectIcon !== undefined - ? { projectIcon: payload.projectIcon } - : {}), - ...(payload.scripts !== undefined ? { scripts: payload.scripts } : {}), - updatedAt: payload.updatedAt, - } - : project, - ), - })), + Effect.map((payload) => + updateProject(nextBase, payload.projectId, (project) => ({ + ...project, + ...(payload.title !== undefined ? { title: payload.title } : {}), + ...(payload.workspaceRoot !== undefined + ? { workspaceRoot: payload.workspaceRoot } + : {}), + ...(payload.defaultModelSelection !== undefined + ? { defaultModelSelection: payload.defaultModelSelection } + : {}), + ...(payload.defaultThreadEnvMode !== undefined + ? { defaultThreadEnvMode: payload.defaultThreadEnvMode } + : {}), + ...(payload.autoPull !== undefined ? { autoPull: payload.autoPull } : {}), + ...(payload.faviconPath !== undefined ? { faviconPath: payload.faviconPath } : {}), + ...(payload.projectIcon !== undefined ? { projectIcon: payload.projectIcon } : {}), + ...(payload.scripts !== undefined ? { scripts: payload.scripts } : {}), + updatedAt: payload.updatedAt, + })), + ), ); case "project.deleted": return decodeForEvent(ProjectDeletedPayload, event.payload, event.type, "payload").pipe( - Effect.map((payload) => ({ - ...nextBase, - projects: nextBase.projects.map((project) => - project.id === payload.projectId - ? { - ...project, - deletedAt: payload.deletedAt, - updatedAt: payload.deletedAt, - } - : project, - ), - })), + Effect.map((payload) => + updateProject(nextBase, payload.projectId, (project) => ({ + ...project, + deletedAt: payload.deletedAt, + updatedAt: payload.deletedAt, + })), + ), ); case "thread.created": @@ -437,6 +470,8 @@ export function projectEvent( snoozedAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, activities: [], checkpoints: [], session: null, @@ -444,23 +479,27 @@ export function projectEvent( event.type, "thread", ); - const existing = nextBase.threads.find((entry) => entry.id === thread.id); return { ...nextBase, - threads: existing - ? nextBase.threads.map((entry) => (entry.id === thread.id ? thread : entry)) - : [...nextBase.threads, thread], + threads: HashMap.set(nextBase.threads, thread.id, thread), }; }); case "thread.deleted": + // Evict deleted threads from the in-memory model entirely rather than + // tombstoning them. The DB projection retains the row (it is the source + // of truth for downstream/HTTP reads and cleanup reactors consume the + // event stream, not this model), and no command legitimately targets an + // already-deleted thread. This is the primary fix for unbounded growth: + // a deleted thread's messages/activities/checkpoints are freed and it no + // longer costs anything on every subsequent event. The id is recorded in + // `deletedThreadIds` so `requireThreadAbsent` still rejects re-creating a + // thread with a previously-used id (the invariant the DB tombstone kept). return decodeForEvent(ThreadDeletedPayload, event.payload, event.type, "payload").pipe( Effect.map((payload) => ({ ...nextBase, - threads: updateThread(nextBase.threads, payload.threadId, { - deletedAt: payload.deletedAt, - updatedAt: payload.deletedAt, - }), + threads: HashMap.remove(nextBase.threads, payload.threadId), + deletedThreadIds: HashSet.add(nextBase.deletedThreadIds, payload.threadId), })), ); @@ -504,7 +543,7 @@ export function projectEvent( case "thread.unsettled": return decodeForEvent(ThreadUnsettledPayload, event.payload, event.type, "payload").pipe( Effect.map((payload) => { - const existing = nextBase.threads.find((thread) => thread.id === payload.threadId); + const existing = findThreadById(nextBase, payload.threadId); return { ...nextBase, threads: updateThread(nextBase.threads, payload.threadId, { @@ -587,7 +626,7 @@ export function projectEvent( case "thread.meta-updated": return decodeForEvent(ThreadMetaUpdatedPayload, event.payload, event.type, "payload").pipe( Effect.map((payload) => { - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); // Legacy single-link events replay into the link array so the // derived linkedPullRequest and pullRequests never disagree. const legacyLinkPatch = @@ -596,7 +635,7 @@ export function projectEvent( thread, legacyLinkToPullRequests( thread, - nextBase.projects.find((project) => project.id === thread.projectId), + Option.getOrUndefined(HashMap.get(nextBase.projects, thread.projectId)), payload.linkedPullRequest, payload.updatedAt, ), @@ -636,7 +675,7 @@ export function projectEvent( "payload", ).pipe( Effect.map((payload) => { - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -662,7 +701,7 @@ export function projectEvent( "payload", ).pipe( Effect.map((payload) => { - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -688,7 +727,7 @@ export function projectEvent( "payload", ).pipe( Effect.map((payload) => { - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); // A sync for a link the user removed in the meantime is stale; drop it. if ( !thread || @@ -746,7 +785,7 @@ export function projectEvent( event.type, "payload", ); - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -760,6 +799,7 @@ export function projectEvent( ...(payload.attachments !== undefined ? { attachments: payload.attachments } : {}), turnId: payload.turnId, streaming: payload.streaming, + ...(payload.source !== undefined ? { source: payload.source } : {}), createdAt: payload.createdAt, updatedAt: payload.updatedAt, }, @@ -780,25 +820,179 @@ export function projectEvent( : entry.text, streaming: message.streaming, updatedAt: message.updatedAt, - turnId: message.turnId, + // Once an assistant bubble is bound to a turn, never rebind it + // to a different turn. Queue drain races re-emit + // assistant.complete for the same messageId under the next + // activeTurnId (empty text + streaming:false), which would + // otherwise orphan the real final from its completed turn and + // hide it under the next Working tip (Discord/web fold). + turnId: + entry.role === "assistant" && + entry.turnId !== null && + message.turnId !== null && + entry.turnId !== message.turnId + ? entry.turnId + : message.turnId, ...(message.attachments !== undefined ? { attachments: message.attachments } : {}), + // Preserve source on first write; streaming deltas don't re-stamp. + ...(entry.source === undefined && message.source !== undefined + ? { source: message.source } + : {}), } : entry, ) : [...thread.messages, message]; const cappedMessages = messages.slice(-MAX_THREAD_MESSAGES); + const messageSource: SourceRef | undefined = + existingMessage === undefined + ? message.source + : (existingMessage.source ?? message.source); + const nextOrigin = nextOriginSource({ + current: thread.originSource ?? null, + messageSource, + role: message.role, + }); + // Preserve branded SourceRef from the event when setting origin. + const originSource: SourceRef | null | undefined = + nextOrigin === null || nextOrigin === undefined + ? nextOrigin + : messageSource !== undefined && + (thread.originSource === undefined || thread.originSource === null) + ? messageSource + : (thread.originSource ?? null); + const existingSummaries = thread.participantSummaries ?? []; + const participantSummaries: ReadonlyArray = + message.role === "user" && + messageSource?.personId !== undefined && + messageSource.username !== undefined + ? (mergeParticipantSummaries({ + existing: existingSummaries, + source: { + personId: messageSource.personId, + username: messageSource.username, + channel: messageSource.channel, + }, + participatedAt: message.createdAt, + originPersonId: originSource?.personId ?? null, + }).map((entry) => ({ + personId: entry.personId as ThreadParticipantSummary["personId"], + username: entry.username as ThreadParticipantSummary["username"], + ...(entry.name !== undefined ? { name: entry.name } : {}), + ...(entry.firstChannel !== undefined ? { firstChannel: entry.firstChannel } : {}), + ...(entry.channels !== undefined ? { channels: [...entry.channels] } : {}), + firstParticipatedAt: entry.firstParticipatedAt, + })) as ReadonlyArray) + : existingSummaries; + return { ...nextBase, threads: updateThread(nextBase.threads, payload.threadId, { messages: cappedMessages, updatedAt: event.occurredAt, + ...(originSource !== undefined ? { originSource } : {}), + ...(participantSummaries.length > 0 ? { participantSummaries } : {}), }), }; }); + case "thread.message-queued": + return decodeForEvent(ThreadMessageQueuedPayload, event.payload, event.type, "payload").pipe( + Effect.map((payload) => { + const thread = findThreadById(nextBase, payload.threadId); + if (!thread) { + return nextBase; + } + + // No cap here: the decider refuses to emit `thread.message-queued` + // past its queue limit, so replaying the event stream stays in + // lockstep with the persisted projection. + const queuedMessages = [ + ...thread.queuedMessages.filter((entry) => entry.messageId !== payload.messageId), + { + messageId: payload.messageId, + text: payload.text, + attachments: payload.attachments, + ...(payload.modelSelection !== undefined + ? { modelSelection: payload.modelSelection } + : {}), + ...(payload.sourceProposedPlan !== undefined + ? { sourceProposedPlan: payload.sourceProposedPlan } + : {}), + ...(payload.source !== undefined ? { source: payload.source } : {}), + queuedAt: payload.queuedAt, + }, + ]; + + return { + ...nextBase, + threads: updateThread(nextBase.threads, payload.threadId, { + queuedMessages, + updatedAt: event.occurredAt, + }), + }; + }), + ); + + case "thread.queued-message-removed": + return decodeForEvent( + ThreadQueuedMessageRemovedPayload, + event.payload, + event.type, + "payload", + ).pipe( + Effect.map((payload) => { + const thread = findThreadById(nextBase, payload.threadId); + if (!thread) { + return nextBase; + } + + return { + ...nextBase, + threads: updateThread(nextBase.threads, payload.threadId, { + queuedMessages: thread.queuedMessages.filter( + (entry) => entry.messageId !== payload.messageId, + ), + updatedAt: event.occurredAt, + }), + }; + }), + ); + + case "thread.turn-start-requested": + return decodeForEvent( + ThreadTurnStartRequestedPayload, + event.payload, + event.type, + "payload", + ).pipe( + Effect.map((payload) => { + const thread = findThreadById(nextBase, payload.threadId); + if (!thread) { + return nextBase; + } + // Match ProjectionPipeline: a pending `/compact` occupies the + // pending-start slot until restore. Follow-ups stay as + // turn-start-requested so the reactor can hold them in memory + // instead of replacing this placeholder (or queue-by-default). + if (isPendingCompactTurnStart(thread)) { + return nextBase; + } + return { + ...nextBase, + threads: updateThread(nextBase.threads, payload.threadId, { + pendingTurnStart: { + messageId: payload.messageId, + requestedAt: payload.createdAt, + }, + updatedAt: event.occurredAt, + }), + }; + }), + ); + case "thread.session-set": return Effect.gen(function* () { const payload = yield* decodeForEvent( @@ -807,7 +1001,7 @@ export function projectEvent( event.type, "payload", ); - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -822,10 +1016,23 @@ export function projectEvent( // Leaving the "running" session status is the turn-end signal: settle // a still-running latest turn so its duration reflects the whole turn. const settledTurnState = settledTurnStateForSessionStatus(session.status); + // Mirrors the SQL pipeline's pending-turn-start clearing: a running + // session with an active turn adopts the pending start; every settled + // or terminal status (ready/idle/error/stopped/interrupted) clears it + // — a mid-turn steer re-arms the flag without any adopting session + // transition, so the turn-end ready must release it or drains would + // be rejected forever. Only "starting" (and running while waiting on + // a turn id) keeps it pending. + const pendingTurnStart = + (session.status === "running" && session.activeTurnId !== null) || + settledTurnStateForSessionStatus(session.status) !== null + ? null + : thread.pendingTurnStart; return { ...nextBase, threads: updateThread(nextBase.threads, payload.threadId, { session, + pendingTurnStart, latestTurn: session.status === "running" && session.activeTurnId !== null ? { @@ -870,7 +1077,7 @@ export function projectEvent( event.type, "payload", ); - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -902,7 +1109,7 @@ export function projectEvent( event.type, "payload", ); - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -976,7 +1183,7 @@ export function projectEvent( case "thread.reverted": return decodeForEvent(ThreadRevertedPayload, event.payload, event.type, "payload").pipe( Effect.map((payload) => { - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } @@ -1032,7 +1239,7 @@ export function projectEvent( "payload", ).pipe( Effect.map((payload) => { - const thread = nextBase.threads.find((entry) => entry.id === payload.threadId); + const thread = findThreadById(nextBase, payload.threadId); if (!thread) { return nextBase; } diff --git a/apps/server/src/persistence/ForkMigrations.ts b/apps/server/src/persistence/ForkMigrations.ts new file mode 100644 index 000000000000..a07d9e076aba --- /dev/null +++ b/apps/server/src/persistence/ForkMigrations.ts @@ -0,0 +1,29 @@ +import * as Migrator from "effect/unstable/sql/Migrator"; + +import Migration0001 from "./Migrations/037_ProjectionQueuedMessages.ts"; +import Migration0002 from "./Migrations/038_SessionIdentityClaims.ts"; +import Migration0003 from "./Migrations/041_ProjectionThreadSourceAttribution.ts"; + +export const forkMigrationTable = "t3_fork_sql_migrations"; + +/** + * Fork migrations have their own id space and ledger. Never add a downstream + * migration to the upstream manifest in Migrations.ts. + * + * IDs 2 and 3 are already assigned to the identity overlay's historical + * SessionIdentityClaims and ProjectionThreadSourceAttribution migrations. + */ +export const forkMigrationEntries = [ + [1, "ProjectionQueuedMessages", Migration0001], + [2, "SessionIdentityClaims", Migration0002], + [3, "ProjectionThreadSourceAttribution", Migration0003], +] as const; + +export const forkMigrationManifest = forkMigrationEntries.map(([id, name]) => [id, name] as const); + +export const makeForkMigrationLoader = () => + Migrator.fromRecord( + Object.fromEntries( + forkMigrationEntries.map(([id, name, migration]) => [`${id}_${name}`, migration]), + ), + ); diff --git a/apps/server/src/persistence/Layers/ProjectionQueuedMessages.ts b/apps/server/src/persistence/Layers/ProjectionQueuedMessages.ts new file mode 100644 index 000000000000..0e3d20e948d8 --- /dev/null +++ b/apps/server/src/persistence/Layers/ProjectionQueuedMessages.ts @@ -0,0 +1,131 @@ +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import * as SqlSchema from "effect/unstable/sql/SqlSchema"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; +import * as Struct from "effect/Struct"; +import { ChatAttachment, ModelSelection } from "@t3tools/contracts"; + +import { toPersistenceSqlError } from "../Errors.ts"; +import { + DeleteProjectionQueuedMessageInput, + DeleteProjectionQueuedMessagesInput, + ListProjectionQueuedMessagesInput, + ProjectionQueuedMessage, + ProjectionQueuedMessageRepository, + type ProjectionQueuedMessageRepositoryShape, +} from "../Services/ProjectionQueuedMessages.ts"; + +const ProjectionQueuedMessageDbRowSchema = ProjectionQueuedMessage.mapFields( + Struct.assign({ + attachments: Schema.fromJsonString(Schema.Array(ChatAttachment)), + modelSelection: Schema.NullOr(Schema.fromJsonString(ModelSelection)), + }), +); + +const makeProjectionQueuedMessageRepository = Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + + // Replace-then-insert (not ON CONFLICT UPDATE) so a re-queued messageId + // gets a fresh rowid and moves to the queue tail — the same semantics as + // the in-memory projector. Drain order is rowid order: a monotonic + // insertion sequence that never ties, unlike queued_at timestamps. + const upsertProjectionQueuedMessageRow = SqlSchema.void({ + Request: ProjectionQueuedMessage, + execute: (row) => sql` + INSERT OR REPLACE INTO projection_queued_messages ( + message_id, + thread_id, + text, + attachments_json, + model_selection_json, + source_proposed_plan_thread_id, + source_proposed_plan_id, + queued_at + ) + VALUES ( + ${row.messageId}, + ${row.threadId}, + ${row.text}, + ${JSON.stringify(row.attachments)}, + ${row.modelSelection !== null ? JSON.stringify(row.modelSelection) : null}, + ${row.sourceProposedPlanThreadId}, + ${row.sourceProposedPlanId}, + ${row.queuedAt} + ) + `, + }); + + const listProjectionQueuedMessageRows = SqlSchema.findAll({ + Request: ListProjectionQueuedMessagesInput, + Result: ProjectionQueuedMessageDbRowSchema, + execute: ({ threadId }) => sql` + SELECT + message_id AS "messageId", + thread_id AS "threadId", + text, + attachments_json AS "attachments", + model_selection_json AS "modelSelection", + source_proposed_plan_thread_id AS "sourceProposedPlanThreadId", + source_proposed_plan_id AS "sourceProposedPlanId", + queued_at AS "queuedAt" + FROM projection_queued_messages + WHERE thread_id = ${threadId} + ORDER BY rowid ASC + `, + }); + + const deleteProjectionQueuedMessageRow = SqlSchema.void({ + Request: DeleteProjectionQueuedMessageInput, + execute: ({ threadId, messageId }) => sql` + DELETE FROM projection_queued_messages + WHERE thread_id = ${threadId} AND message_id = ${messageId} + `, + }); + + const deleteProjectionQueuedMessageRows = SqlSchema.void({ + Request: DeleteProjectionQueuedMessagesInput, + execute: ({ threadId }) => sql` + DELETE FROM projection_queued_messages + WHERE thread_id = ${threadId} + `, + }); + + const upsert: ProjectionQueuedMessageRepositoryShape["upsert"] = (row) => + upsertProjectionQueuedMessageRow(row).pipe( + Effect.mapError(toPersistenceSqlError("ProjectionQueuedMessageRepository.upsert:query")), + ); + + const listByThreadId: ProjectionQueuedMessageRepositoryShape["listByThreadId"] = (input) => + listProjectionQueuedMessageRows(input).pipe( + Effect.mapError( + toPersistenceSqlError("ProjectionQueuedMessageRepository.listByThreadId:query"), + ), + ); + + const deleteByMessageId: ProjectionQueuedMessageRepositoryShape["deleteByMessageId"] = (input) => + deleteProjectionQueuedMessageRow(input).pipe( + Effect.mapError( + toPersistenceSqlError("ProjectionQueuedMessageRepository.deleteByMessageId:query"), + ), + ); + + const deleteByThreadId: ProjectionQueuedMessageRepositoryShape["deleteByThreadId"] = (input) => + deleteProjectionQueuedMessageRows(input).pipe( + Effect.mapError( + toPersistenceSqlError("ProjectionQueuedMessageRepository.deleteByThreadId:query"), + ), + ); + + return { + upsert, + listByThreadId, + deleteByMessageId, + deleteByThreadId, + } satisfies ProjectionQueuedMessageRepositoryShape; +}); + +export const ProjectionQueuedMessageRepositoryLive = Layer.effect( + ProjectionQueuedMessageRepository, + makeProjectionQueuedMessageRepository, +); diff --git a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts b/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts index b7b2fdefba2f..970d1ecf321f 100644 --- a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts +++ b/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts @@ -468,6 +468,89 @@ projectionRepositoriesLayer("Projection repositories", (it) => { }), ); + it.effect("lists nondeleted worktree references including archived rows", () => + Effect.gen(function* () { + const threads = yield* ProjectionThreadRepository; + const sql = yield* SqlClient.SqlClient; + yield* sql`DELETE FROM projection_threads`; + + const baseRow = { + projectId: ProjectId.make("project-worktrees"), + title: "Worktree thread", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + runtimeMode: "full-access", + interactionMode: "default", + branch: "feature-1", + latestTurnId: null, + createdAt: "2026-03-24T00:00:00.000Z", + updatedAt: "2026-03-24T00:00:00.000Z", + settledOverride: null, + settledAt: null, + unsettledAt: null, + snoozedUntil: null, + snoozedAt: null, + pinnedAt: null, + latestUserMessageAt: null, + pendingApprovalCount: 0, + pendingUserInputCount: 0, + hasActionableProposedPlan: 0, + } as const; + + yield* threads.upsert({ + ...baseRow, + threadId: ThreadId.make("thread-active-worktree"), + worktreePath: "/tmp/worktrees/feature-1", + archivedAt: null, + deletedAt: null, + }); + yield* threads.upsert({ + ...baseRow, + threadId: ThreadId.make("thread-archived-worktree"), + worktreePath: "/tmp/worktrees/feature-1", + archivedAt: "2026-03-25T00:00:00.000Z", + deletedAt: null, + }); + yield* threads.upsert({ + ...baseRow, + threadId: ThreadId.make("thread-deleted-worktree"), + worktreePath: "/tmp/worktrees/feature-1", + archivedAt: null, + deletedAt: "2026-03-25T00:00:00.000Z", + }); + yield* threads.upsert({ + ...baseRow, + threadId: ThreadId.make("thread-no-worktree"), + worktreePath: null, + archivedAt: null, + deletedAt: null, + }); + + const references = yield* threads.listWorktreeReferences(); + assert.deepStrictEqual( + references.map((reference) => ({ + threadId: reference.threadId, + worktreePath: reference.worktreePath, + archivedAt: reference.archivedAt, + })), + [ + { + threadId: ThreadId.make("thread-active-worktree"), + worktreePath: "/tmp/worktrees/feature-1", + archivedAt: null, + }, + { + threadId: ThreadId.make("thread-archived-worktree"), + worktreePath: "/tmp/worktrees/feature-1", + archivedAt: "2026-03-25T00:00:00.000Z", + }, + ], + ); + }), + ); + it.effect("round-trips manual and branch pull requests through the thread row", () => Effect.gen(function* () { const threads = yield* ProjectionThreadRepository; diff --git a/apps/server/src/persistence/Layers/ProjectionThreadActivities.test.ts b/apps/server/src/persistence/Layers/ProjectionThreadActivities.test.ts index d92ed97ea6fa..d56d31b1062d 100644 --- a/apps/server/src/persistence/Layers/ProjectionThreadActivities.test.ts +++ b/apps/server/src/persistence/Layers/ProjectionThreadActivities.test.ts @@ -5,19 +5,131 @@ import * as Layer from "effect/Layer"; import * as SqlClient from "effect/unstable/sql/SqlClient"; import { ProjectionThreadActivityRepository } from "../Services/ProjectionThreadActivities.ts"; +import type { ProjectionThreadActivity } from "../Services/ProjectionThreadActivities.ts"; import { ProjectionThreadActivityRepositoryLive } from "./ProjectionThreadActivities.ts"; import { SqlitePersistenceMemory } from "./Sqlite.ts"; +const threadId = ThreadId.make("thread-activity-kinds"); +const otherThreadId = ThreadId.make("thread-activity-kinds-other"); + +const activity = ( + id: string, + kind: string, + createdAt: string, + overrides: Partial = {}, +): ProjectionThreadActivity => ({ + activityId: EventId.make(id), + threadId, + turnId: null, + tone: "info", + kind, + summary: `${kind} ${id}`, + payload: { requestId: `request-${id}` }, + createdAt, + ...overrides, +}); + const layer = it.layer( - ProjectionThreadActivityRepositoryLive.pipe(Layer.provideMerge(SqlitePersistenceMemory)), + Layer.mergeAll( + ProjectionThreadActivityRepositoryLive.pipe(Layer.provideMerge(SqlitePersistenceMemory)), + SqlitePersistenceMemory, + ), ); layer("ProjectionThreadActivityRepository", (it) => { + const seed = Effect.fn("seed")(function* () { + const activities = yield* ProjectionThreadActivityRepository; + yield* activities.upsert(activity("a1", "user-input.requested", "2026-03-24T00:00:01.000Z")); + yield* activities.upsert(activity("a2", "tool.updated", "2026-03-24T00:00:02.000Z")); + yield* activities.upsert(activity("a3", "user-input.resolved", "2026-03-24T00:00:03.000Z")); + yield* activities.upsert(activity("a4", "tool.completed", "2026-03-24T00:00:04.000Z")); + yield* activities.upsert( + activity("a5", "user-input.requested", "2026-03-24T00:00:05.000Z", { + threadId: otherThreadId, + }), + ); + return activities; + }); + + it.effect("returns only the requested kinds", () => + Effect.gen(function* () { + const activities = yield* seed(); + + const rows = yield* activities.listByThreadIdAndKinds({ + threadId, + kinds: ["user-input.requested", "user-input.resolved"], + }); + + assert.deepStrictEqual( + rows.map((row) => row.activityId), + ["a1", "a3"], + ); + }), + ); + + it.effect("keeps the same ordering as the unfiltered list", () => + Effect.gen(function* () { + const activities = yield* seed(); + + const all = yield* activities.listByThreadId({ threadId }); + const filtered = yield* activities.listByThreadIdAndKinds({ + threadId, + kinds: ["user-input.requested", "user-input.resolved", "tool.updated", "tool.completed"], + }); + + assert.deepStrictEqual( + filtered.map((row) => row.activityId), + all.map((row) => row.activityId), + ); + }), + ); + + it.effect("decodes the payload the same way the unfiltered list does", () => + Effect.gen(function* () { + const activities = yield* seed(); + + const [filtered] = yield* activities.listByThreadIdAndKinds({ + threadId, + kinds: ["user-input.requested"], + }); + const all = yield* activities.listByThreadId({ threadId }); + const unfiltered = all.find((row) => row.activityId === "a1"); + + assert.deepStrictEqual(filtered, unfiltered); + }), + ); + + it.effect("does not reach across threads", () => + Effect.gen(function* () { + const activities = yield* seed(); + + const rows = yield* activities.listByThreadIdAndKinds({ + threadId: otherThreadId, + kinds: ["user-input.requested"], + }); + + assert.deepStrictEqual( + rows.map((row) => row.activityId), + ["a5"], + ); + }), + ); + + it.effect("returns nothing for an empty kind list without querying", () => + Effect.gen(function* () { + const activities = yield* seed(); + + const rows = yield* activities.listByThreadIdAndKinds({ threadId, kinds: [] }); + + assert.deepStrictEqual(rows, []); + }), + ); + it.effect("reads only the latest matching task activity", () => Effect.gen(function* () { const repository = yield* ProjectionThreadActivityRepository; const sql = yield* SqlClient.SqlClient; - const threadId = ThreadId.make("thread-latest-task-activity"); + const latestTaskThreadId = ThreadId.make("thread-latest-task-activity"); yield* sql` INSERT INTO projection_thread_activities ( @@ -25,21 +137,21 @@ layer("ProjectionThreadActivityRepository", (it) => { ) VALUES ( - 'activity-task-unrelated-tool', ${threadId}, NULL, 'tool', 'tool.completed', + 'activity-task-unrelated-tool', ${latestTaskThreadId}, NULL, 'tool', 'tool.completed', 'large tool output', 'not-json', 1, '2026-03-01T00:00:00.000Z' ), ( - 'activity-task-started', ${threadId}, NULL, 'info', 'task.started', + 'activity-task-started', ${latestTaskThreadId}, NULL, 'info', 'task.started', 'started', '{"taskId":"task-1","title":"Initial title"}', 2, '2026-03-01T00:00:01.000Z' ), ( - 'activity-task-progress', ${threadId}, NULL, 'info', 'task.progress', + 'activity-task-progress', ${latestTaskThreadId}, NULL, 'info', 'task.progress', 'progress', '{"taskId":"task-1","title":"Updated title"}', 3, '2026-03-01T00:00:02.000Z' ), ( - 'activity-task-other', ${threadId}, NULL, 'info', 'task.progress', + 'activity-task-other', ${latestTaskThreadId}, NULL, 'info', 'task.progress', 'other', '{"taskId":"task-2","title":"Other title"}', 4, '2026-03-01T00:00:03.000Z' ) @@ -47,7 +159,7 @@ layer("ProjectionThreadActivityRepository", (it) => { yield* repository.upsert({ activityId: EventId.make("activity-task-untitled"), - threadId, + threadId: latestTaskThreadId, turnId: null, tone: "info", kind: "task.progress", @@ -58,7 +170,7 @@ layer("ProjectionThreadActivityRepository", (it) => { }); yield* repository.upsert({ activityId: EventId.make("activity-task-blank-title"), - threadId, + threadId: latestTaskThreadId, turnId: null, tone: "info", kind: "task.progress", @@ -69,7 +181,7 @@ layer("ProjectionThreadActivityRepository", (it) => { }); const recent = yield* repository.listByThreadId({ - threadId, + threadId: latestTaskThreadId, activityKinds: ["task.progress"], limit: 2, }); @@ -78,21 +190,24 @@ layer("ProjectionThreadActivityRepository", (it) => { ["activity-task-untitled", "activity-task-blank-title"], ); - const activity = yield* repository.getLatestTaskActivity({ - threadId, + const latestTaskActivity = yield* repository.getLatestTaskActivity({ + threadId: latestTaskThreadId, taskId: "task-1", }); - assert.equal(activity._tag, "Some"); - if (activity._tag === "Some") { - assert.equal(activity.value.activityId, EventId.make("activity-task-progress")); - assert.deepEqual(activity.value.payload, { + assert.equal(latestTaskActivity._tag, "Some"); + if (latestTaskActivity._tag === "Some") { + assert.equal(latestTaskActivity.value.activityId, EventId.make("activity-task-progress")); + assert.deepEqual(latestTaskActivity.value.payload, { taskId: "task-1", title: "Updated title", }); } assert.equal( - (yield* repository.getLatestTaskActivity({ threadId, taskId: "missing" }))._tag, + (yield* repository.getLatestTaskActivity({ + threadId: latestTaskThreadId, + taskId: "missing", + }))._tag, "None", ); }), diff --git a/apps/server/src/persistence/Layers/ProjectionThreadActivities.ts b/apps/server/src/persistence/Layers/ProjectionThreadActivities.ts index 9b6d44d170ee..73f89af88714 100644 --- a/apps/server/src/persistence/Layers/ProjectionThreadActivities.ts +++ b/apps/server/src/persistence/Layers/ProjectionThreadActivities.ts @@ -11,6 +11,7 @@ import { toPersistenceDecodeError, toPersistenceSqlError } from "../Errors.ts"; import { DeleteProjectionThreadActivitiesInput, + ListProjectionThreadActivitiesByKindInput, ListProjectionThreadActivitiesInput, GetLatestProjectionThreadTaskActivityInput, ProjectionThreadActivity, @@ -125,6 +126,32 @@ const makeProjectionThreadActivityRepository = Effect.gen(function* () { `, }); + const listProjectionThreadActivityRowsByKind = SqlSchema.findAll({ + Request: ListProjectionThreadActivitiesByKindInput, + Result: ProjectionThreadActivityDbRowSchema, + execute: ({ threadId, kinds }) => + sql` + SELECT + activity_id AS "activityId", + thread_id AS "threadId", + turn_id AS "turnId", + tone, + kind, + summary, + payload_json AS "payload", + sequence, + created_at AS "createdAt" + FROM projection_thread_activities + WHERE thread_id = ${threadId} + AND kind IN ${sql.in(kinds)} + ORDER BY + CASE WHEN sequence IS NULL THEN 0 ELSE 1 END ASC, + sequence ASC, + created_at ASC, + activity_id ASC + `, + }); + const listUserInputLifecycleActivityRows = SqlSchema.findAll({ Request: ListProjectionThreadActivitiesInput, Result: ProjectionThreadActivityDbRowSchema, @@ -219,6 +246,20 @@ const makeProjectionThreadActivityRepository = Effect.gen(function* () { Effect.map((rows) => rows.map(toProjectionThreadActivity)), ); + const listByThreadIdAndKinds: ProjectionThreadActivityRepositoryShape["listByThreadIdAndKinds"] = + (input) => + input.kinds.length === 0 + ? Effect.succeed([]) + : listProjectionThreadActivityRowsByKind(input).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionThreadActivityRepository.listByThreadIdAndKinds:query", + "ProjectionThreadActivityRepository.listByThreadIdAndKinds:decodeRows", + ), + ), + Effect.map((rows) => rows.map(toProjectionThreadActivity)), + ); + const listUserInputLifecycleByThreadId: ProjectionThreadActivityRepositoryShape["listUserInputLifecycleByThreadId"] = (input) => listUserInputLifecycleActivityRows(input).pipe( @@ -254,6 +295,7 @@ const makeProjectionThreadActivityRepository = Effect.gen(function* () { return { upsert, listByThreadId, + listByThreadIdAndKinds, listUserInputLifecycleByThreadId, getLatestTaskActivity, deleteByThreadId, diff --git a/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts b/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts index eae7189de5b2..26b79973932f 100644 --- a/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts +++ b/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts @@ -5,7 +5,7 @@ import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import * as Struct from "effect/Struct"; -import { ChatAttachment } from "@t3tools/contracts"; +import { ChatAttachment, SourceRef } from "@t3tools/contracts"; import { toPersistenceSqlError } from "../Errors.ts"; import { @@ -23,6 +23,8 @@ const ProjectionThreadMessageDbRowSchema = ProjectionThreadMessage.mapFields( Struct.assign({ isStreaming: Schema.Number, attachments: Schema.NullOr(Schema.fromJsonString(Schema.Array(ChatAttachment))), + // JSON column may be SQL NULL or the string "null" from JSON.stringify(null). + source: Schema.NullOr(Schema.fromJsonString(Schema.NullOr(SourceRef))), }), ); const ProjectionThreadMessageExistsDbRowSchema = Schema.Struct({ exists: Schema.Number }); @@ -40,6 +42,7 @@ function toProjectionThreadMessage( createdAt: row.createdAt, updatedAt: row.updatedAt, ...(row.attachments !== null ? { attachments: row.attachments } : {}), + ...(row.source !== null && row.source !== undefined ? { source: row.source } : {}), }; } @@ -51,6 +54,8 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () { execute: (row) => { const nextAttachmentsJson = row.attachments !== undefined ? JSON.stringify(row.attachments) : null; + // Avoid JSON.stringify(null) → "null" which fails SourceRef decode. + const nextSourceJson = row.source != null ? JSON.stringify(row.source) : null; return sql` INSERT INTO projection_thread_messages ( message_id, @@ -60,6 +65,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () { text, attachments_json, is_streaming, + source_json, created_at, updated_at ) @@ -78,6 +84,14 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () { ) ), ${row.isStreaming ? 1 : 0}, + COALESCE( + ${nextSourceJson}, + ( + SELECT source_json + FROM projection_thread_messages + WHERE message_id = ${row.messageId} + ) + ), ${row.createdAt}, ${row.updatedAt} ) @@ -92,6 +106,10 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () { projection_thread_messages.attachments_json ), is_streaming = excluded.is_streaming, + source_json = COALESCE( + excluded.source_json, + projection_thread_messages.source_json + ), created_at = excluded.created_at, updated_at = excluded.updated_at `; @@ -155,6 +173,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () { text, attachments_json AS "attachments", is_streaming AS "isStreaming", + source_json AS "source", created_at AS "createdAt", updated_at AS "updatedAt" FROM projection_thread_messages @@ -193,6 +212,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () { text, attachments_json AS "attachments", is_streaming AS "isStreaming", + source_json AS "source", created_at AS "createdAt", updated_at AS "updatedAt" FROM projection_thread_messages diff --git a/apps/server/src/persistence/Layers/ProjectionThreads.ts b/apps/server/src/persistence/Layers/ProjectionThreads.ts index 6406e8237bc9..01bb6417870f 100644 --- a/apps/server/src/persistence/Layers/ProjectionThreads.ts +++ b/apps/server/src/persistence/Layers/ProjectionThreads.ts @@ -2,6 +2,7 @@ import * as SqlClient from "effect/unstable/sql/SqlClient"; import * as SqlSchema from "effect/unstable/sql/SqlSchema"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import * as Struct from "effect/Struct"; @@ -12,19 +13,71 @@ import { ListProjectionThreadsByProjectInput, ProjectionThread, ProjectionThreadRepository, + ProjectionThreadWorktreeReference, type ProjectionThreadRepositoryShape, } from "../Services/ProjectionThreads.ts"; -import { ModelSelection, ThreadLinkedPullRequest } from "@t3tools/contracts"; +import { + ModelSelection, + SourceRef, + ThreadLinkedPullRequest, + ThreadParticipantSummary, +} from "@t3tools/contracts"; +// JSON columns may be SQL NULL or the string "null" (from JSON.stringify(null)). +// Decode with NullOr inside fromJsonString so both forms become null. const ProjectionThreadDbRow = ProjectionThread.mapFields( Struct.assign({ modelSelection: Schema.fromJsonString(ModelSelection), + originSource: Schema.NullOr(Schema.fromJsonString(Schema.NullOr(SourceRef))), + participantSummaries: Schema.NullOr( + Schema.fromJsonString(Schema.NullOr(Schema.Array(ThreadParticipantSummary))), + ), linkedPullRequest: Schema.NullOr(Schema.fromJsonString(ThreadLinkedPullRequest)), branchPullRequest: Schema.NullOr(Schema.fromJsonString(ThreadLinkedPullRequest)), }), ); type ProjectionThreadDbRow = typeof ProjectionThreadDbRow.Type; +function toProjectionThread(row: ProjectionThreadDbRow): ProjectionThread { + return { + threadId: row.threadId, + projectId: row.projectId, + title: row.title, + modelSelection: row.modelSelection, + runtimeMode: row.runtimeMode, + interactionMode: row.interactionMode, + branch: row.branch, + worktreePath: row.worktreePath, + linkedPullRequest: row.linkedPullRequest ?? null, + branchPullRequest: row.branchPullRequest ?? null, + latestTurnId: row.latestTurnId, + createdAt: row.createdAt, + updatedAt: row.updatedAt, + archivedAt: row.archivedAt, + settledOverride: row.settledOverride, + settledAt: row.settledAt, + unsettledAt: row.unsettledAt, + snoozedUntil: row.snoozedUntil, + snoozedAt: row.snoozedAt, + pinnedAt: row.pinnedAt, + pinOrderKey: row.pinOrderKey ?? null, + activeOrderKey: row.activeOrderKey ?? null, + titleRegenerationRequestId: row.titleRegenerationRequestId ?? null, + titleRegenerationStartedAt: row.titleRegenerationStartedAt ?? null, + latestUserMessageAt: row.latestUserMessageAt, + pendingApprovalCount: row.pendingApprovalCount, + pendingUserInputCount: row.pendingUserInputCount, + hasActionableProposedPlan: row.hasActionableProposedPlan, + deletedAt: row.deletedAt, + ...(row.originSource !== null && row.originSource !== undefined + ? { originSource: row.originSource } + : {}), + ...(row.participantSummaries !== null && row.participantSummaries !== undefined + ? { participantSummaries: row.participantSummaries } + : {}), + }; +} + const makeProjectionThreadRepository = Effect.gen(function* () { const sql = yield* SqlClient.SqlClient; @@ -61,7 +114,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () { pending_approval_count, pending_user_input_count, has_actionable_proposed_plan, - deleted_at + deleted_at, + origin_source_json, + participant_summaries_json ) VALUES ( ${row.threadId}, @@ -92,7 +147,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () { ${row.pendingApprovalCount}, ${row.pendingUserInputCount}, ${row.hasActionableProposedPlan}, - ${row.deletedAt} + ${row.deletedAt}, + ${row.originSource != null ? JSON.stringify(row.originSource) : null}, + ${row.participantSummaries != null ? JSON.stringify(row.participantSummaries) : null} ) ON CONFLICT (thread_id) DO UPDATE SET @@ -123,7 +180,15 @@ const makeProjectionThreadRepository = Effect.gen(function* () { pending_approval_count = excluded.pending_approval_count, pending_user_input_count = excluded.pending_user_input_count, has_actionable_proposed_plan = excluded.has_actionable_proposed_plan, - deleted_at = excluded.deleted_at + deleted_at = excluded.deleted_at, + origin_source_json = COALESCE( + excluded.origin_source_json, + projection_threads.origin_source_json + ), + participant_summaries_json = COALESCE( + excluded.participant_summaries_json, + projection_threads.participant_summaries_json + ) `, }); @@ -161,7 +226,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () { pending_approval_count AS "pendingApprovalCount", pending_user_input_count AS "pendingUserInputCount", has_actionable_proposed_plan AS "hasActionableProposedPlan", - deleted_at AS "deletedAt" + deleted_at AS "deletedAt", + origin_source_json AS "originSource", + participant_summaries_json AS "participantSummaries" FROM projection_threads WHERE thread_id = ${threadId} `, @@ -201,13 +268,32 @@ const makeProjectionThreadRepository = Effect.gen(function* () { pending_approval_count AS "pendingApprovalCount", pending_user_input_count AS "pendingUserInputCount", has_actionable_proposed_plan AS "hasActionableProposedPlan", - deleted_at AS "deletedAt" + deleted_at AS "deletedAt", + origin_source_json AS "originSource", + participant_summaries_json AS "participantSummaries" FROM projection_threads WHERE project_id = ${projectId} ORDER BY created_at ASC, thread_id ASC `, }); + const listProjectionThreadWorktreeReferenceRows = SqlSchema.findAll({ + Request: Schema.Void, + Result: ProjectionThreadWorktreeReference, + execute: () => + sql` + SELECT + thread_id AS "threadId", + project_id AS "projectId", + worktree_path AS "worktreePath", + archived_at AS "archivedAt" + FROM projection_threads + WHERE deleted_at IS NULL + AND worktree_path IS NOT NULL + ORDER BY created_at ASC, thread_id ASC + `, + }); + const deleteProjectionThreadRow = SqlSchema.void({ Request: DeleteProjectionThreadInput, execute: ({ threadId }) => @@ -225,11 +311,15 @@ const makeProjectionThreadRepository = Effect.gen(function* () { const getById: ProjectionThreadRepositoryShape["getById"] = (input) => getProjectionThreadRow(input).pipe( Effect.mapError(toPersistenceSqlError("ProjectionThreadRepository.getById:query")), + Effect.map((row) => + Option.isNone(row) ? Option.none() : Option.some(toProjectionThread(row.value)), + ), ); const listByProjectId: ProjectionThreadRepositoryShape["listByProjectId"] = (input) => listProjectionThreadRows(input).pipe( Effect.mapError(toPersistenceSqlError("ProjectionThreadRepository.listByProjectId:query")), + Effect.map((rows) => rows.map(toProjectionThread)), ); const deleteById: ProjectionThreadRepositoryShape["deleteById"] = (input) => @@ -237,11 +327,19 @@ const makeProjectionThreadRepository = Effect.gen(function* () { Effect.mapError(toPersistenceSqlError("ProjectionThreadRepository.deleteById:query")), ); + const listWorktreeReferences: ProjectionThreadRepositoryShape["listWorktreeReferences"] = () => + listProjectionThreadWorktreeReferenceRows(undefined).pipe( + Effect.mapError( + toPersistenceSqlError("ProjectionThreadRepository.listWorktreeReferences:query"), + ), + ); + return { upsert, getById, listByProjectId, deleteById, + listWorktreeReferences, } satisfies ProjectionThreadRepositoryShape; }); diff --git a/apps/server/src/persistence/Layers/ProjectionTurns.ts b/apps/server/src/persistence/Layers/ProjectionTurns.ts index bd57a4eaa30a..bc59d3ed45f5 100644 --- a/apps/server/src/persistence/Layers/ProjectionTurns.ts +++ b/apps/server/src/persistence/Layers/ProjectionTurns.ts @@ -169,6 +169,26 @@ const makeProjectionTurnRepository = Effect.gen(function* () { `, }); + const listPendingProjectionTurns = SqlSchema.findAll({ + Request: Schema.Void, + Result: ProjectionPendingTurnStart, + execute: () => + sql` + SELECT + thread_id AS "threadId", + pending_message_id AS "messageId", + source_proposed_plan_thread_id AS "sourceProposedPlanThreadId", + source_proposed_plan_id AS "sourceProposedPlanId", + requested_at AS "requestedAt" + FROM projection_turns + WHERE turn_id IS NULL + AND state = 'pending' + AND pending_message_id IS NOT NULL + AND checkpoint_turn_count IS NULL + ORDER BY requested_at ASC, thread_id ASC + `, + }); + const listProjectionTurnsByThread = SqlSchema.findAll({ Request: ListProjectionTurnsByThreadInput, Result: ProjectionTurnDbRowSchema, @@ -288,6 +308,13 @@ const makeProjectionTurnRepository = Effect.gen(function* () { ), ); + const listPendingTurnStarts: ProjectionTurnRepositoryShape["listPendingTurnStarts"] = () => + listPendingProjectionTurns(undefined).pipe( + Effect.mapError( + toPersistenceSqlError("ProjectionTurnRepository.listPendingTurnStarts:query"), + ), + ); + const deletePendingTurnStartByThreadId: ProjectionTurnRepositoryShape["deletePendingTurnStartByThreadId"] = (input) => clearPendingProjectionTurnsByThread(input).pipe( @@ -341,6 +368,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () { upsertByTurnId, replacePendingTurnStart, getPendingTurnStartByThreadId, + listPendingTurnStarts, deletePendingTurnStartByThreadId, listByThreadId, getByTurnId, diff --git a/apps/server/src/persistence/Layers/Sqlite.ts b/apps/server/src/persistence/Layers/Sqlite.ts index 41d8f5baf3fd..6319afd8a629 100644 --- a/apps/server/src/persistence/Layers/Sqlite.ts +++ b/apps/server/src/persistence/Layers/Sqlite.ts @@ -30,16 +30,21 @@ const makeRuntimeSqliteLayer = Effect.fn("makeRuntimeSqliteLayer")(function* ( return clientModule.layer(config); }, Layer.unwrap); -const setup = Layer.effectDiscard( - Effect.gen(function* () { - const sql = yield* SqlClient.SqlClient; - // CLI and server write from separate processes; wait rather than fail with SQLITE_BUSY. - yield* sql`PRAGMA busy_timeout = 5000;`; - yield* sql`PRAGMA foreign_keys = ON;`; - yield* sql`PRAGMA journal_mode = WAL;`; - yield* runMigrations(); - }), -); +const setup = (trial: boolean) => + Layer.effectDiscard( + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + // CLI and server write from separate processes; wait rather than fail with + // SQLITE_BUSY. Bounded so auth (websocket-ticket) cannot hang indefinitely + // when writers hold the single SQL permit longer than expected. + yield* sql`PRAGMA busy_timeout = 5000;`; + yield* sql`PRAGMA foreign_keys = ON;`; + if (!trial) { + yield* sql`PRAGMA journal_mode = WAL;`; + yield* runMigrations(); + } + }), + ); export const makeSqlitePersistenceLive = Effect.fn("makeSqlitePersistenceLive")(function* ( dbPath: string, @@ -49,7 +54,7 @@ export const makeSqlitePersistenceLive = Effect.fn("makeSqlitePersistenceLive")( yield* fs.makeDirectory(path.dirname(dbPath), { recursive: true }); return Layer.provideMerge( - setup, + setup(false), makeRuntimeSqliteLayer({ filename: dbPath, spanAttributes: { @@ -61,7 +66,7 @@ export const makeSqlitePersistenceLive = Effect.fn("makeSqlitePersistenceLive")( }, Layer.unwrap); export const SqlitePersistenceMemory = Layer.provideMerge( - setup, + setup(false), makeRuntimeSqliteLayer({ filename: ":memory:" }), ); diff --git a/apps/server/src/persistence/MigrationBootstrap.ts b/apps/server/src/persistence/MigrationBootstrap.ts new file mode 100644 index 000000000000..9dc85c5e389e --- /dev/null +++ b/apps/server/src/persistence/MigrationBootstrap.ts @@ -0,0 +1,262 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import { MigrationError } from "effect/unstable/sql/Migrator"; + +import { forkMigrationTable } from "./ForkMigrations.ts"; +import Migration0035 from "./Migrations/035_ProjectionThreadTitleRegeneration.ts"; +import Migration0036 from "./Migrations/036_ProjectionThreadsPinned.ts"; + +export const upstreamMigrationTable = "effect_sql_migrations"; +export const legacyMigrationBackupTable = "effect_sql_migrations_backup_v1"; + +const namespaceTable = "t3_migration_namespaces"; +const namespaceVersion = 1; + +const upstreamNames = new Map([ + [1, "OrchestrationEvents"], + [2, "OrchestrationCommandReceipts"], + [3, "CheckpointDiffBlobs"], + [4, "ProviderSessionRuntime"], + [5, "Projections"], + [6, "ProjectionThreadSessionRuntimeModeColumns"], + [7, "ProjectionThreadMessageAttachments"], + [8, "ProjectionThreadActivitySequence"], + [9, "ProviderSessionRuntimeMode"], + [10, "ProjectionThreadsRuntimeMode"], + [11, "OrchestrationThreadCreatedRuntimeMode"], + [12, "ProjectionThreadsInteractionMode"], + [13, "ProjectionThreadProposedPlans"], + [14, "ProjectionThreadProposedPlanImplementation"], + [15, "ProjectionTurnsSourceProposedPlan"], + [16, "CanonicalizeModelSelections"], + [17, "ProjectionThreadsArchivedAt"], + [18, "ProjectionThreadsArchivedAtIndex"], + [19, "ProjectionSnapshotLookupIndexes"], + [20, "AuthAccessManagement"], + [21, "AuthSessionClientMetadata"], + [22, "AuthSessionLastConnectedAt"], + [23, "ProjectionThreadShellSummary"], + [24, "BackfillProjectionThreadShellSummary"], + [25, "CleanupInvalidProjectionPendingApprovals"], + [26, "CanonicalizeModelSelectionOptions"], + [27, "ProviderSessionRuntimeInstanceId"], + [28, "ProjectionThreadSessionInstanceId"], + [29, "ProjectionThreadDetailOrderingIndexes"], + [30, "ProjectionThreadShellArchiveIndexes"], + [31, "AuthAuthorizationScopes"], + [32, "AuthPairingProofKeyThumbprint"], + [33, "ProjectionThreadsSettled"], + [34, "ProjectionThreadsSnoozed"], + [35, "ProjectionThreadTitleRegeneration"], + [36, "ProjectionThreadsPinned"], +]); + +const knownForkNames = new Map([ + ["ProjectionQueuedMessages", 1], + ["SessionIdentityClaims", 2], + ["ProjectionThreadSourceAttribution", 3], +]); + +const knownRepairNames = new Set([ + "RepairProjectionThreadTitleRegeneration", + "RepairProjectionThreadsPinned", +]); + +interface LedgerRow { + readonly migration_id: number; + readonly name: string; +} + +const failBadState = (message: string) => + Effect.fail(new MigrationError({ kind: "BadState", message })); + +const createLedger = (sql: SqlClient.SqlClient, table: string) => + sql`CREATE TABLE IF NOT EXISTS ${sql(table)} ( + migration_id integer PRIMARY KEY NOT NULL, + created_at datetime NOT NULL DEFAULT current_timestamp, + name VARCHAR(255) NOT NULL + )`; + +const tableExists = Effect.fn("MigrationBootstrap.tableExists")(function* (table: string) { + const sql = yield* SqlClient.SqlClient; + const rows = yield* sql<{ readonly present: number }>` + SELECT 1 AS present + FROM sqlite_master + WHERE type = 'table' AND name = ${table} + LIMIT 1 + `; + return rows.length > 0; +}); + +const indexExists = Effect.fn("MigrationBootstrap.indexExists")(function* (index: string) { + const sql = yield* SqlClient.SqlClient; + const rows = yield* sql<{ readonly present: number }>` + SELECT 1 AS present + FROM sqlite_master + WHERE type = 'index' AND name = ${index} + LIMIT 1 + `; + return rows.length > 0; +}); + +const verifyIdentitySchema = Effect.fn("MigrationBootstrap.verifyIdentitySchema")(function* () { + if ( + !(yield* tableExists("session_identity_claims")) || + !(yield* indexExists("idx_session_identity_claims_person")) + ) { + return yield* failBadState( + "Legacy migration ledger records SessionIdentityClaims, but its table or index is missing", + ); + } +}); + +const verifySourceAttributionSchema = Effect.fn("MigrationBootstrap.verifySourceAttributionSchema")( + function* () { + const sql = yield* SqlClient.SqlClient; + const messageColumns = yield* sql<{ readonly name: string }>` + PRAGMA table_info(projection_thread_messages) + `; + const threadColumns = yield* sql<{ readonly name: string }>` + PRAGMA table_info(projection_threads) + `; + const messageNames = new Set(messageColumns.map(({ name }) => name)); + const threadNames = new Set(threadColumns.map(({ name }) => name)); + if ( + !messageNames.has("source_json") || + !threadNames.has("origin_source_json") || + !threadNames.has("participant_summaries_json") + ) { + return yield* failBadState( + "Legacy migration ledger records ProjectionThreadSourceAttribution, but its columns are missing", + ); + } + }, +); + +const bootstrapLegacyLedger = Effect.fn("MigrationBootstrap.bootstrapLegacyLedger")(function* () { + const sql = yield* SqlClient.SqlClient; + yield* createLedger(sql, forkMigrationTable); + + if (!(yield* tableExists(upstreamMigrationTable))) { + yield* createLedger(sql, upstreamMigrationTable); + return; + } + + const legacyRows = yield* sql` + SELECT migration_id, name + FROM ${sql(upstreamMigrationTable)} + ORDER BY migration_id + `; + yield* createLedger(sql, legacyMigrationBackupTable); + if (legacyRows.length > 0) { + yield* sql`INSERT OR IGNORE INTO ${sql(legacyMigrationBackupTable)} ${sql.insert( + legacyRows.map(({ migration_id, name }) => ({ migration_id, name })), + )}`; + } + if (legacyRows.length === 0) { + return; + } + + let canonicalPrefix = 0; + for (const row of legacyRows) { + if ( + row.migration_id === canonicalPrefix + 1 && + upstreamNames.get(row.migration_id) === row.name + ) { + canonicalPrefix = row.migration_id; + continue; + } + break; + } + + const tail = legacyRows.filter(({ migration_id }) => migration_id > canonicalPrefix); + for (const { migration_id, name } of tail) { + const knownUpstream = upstreamNames.get(migration_id) === name; + if (!knownUpstream && !knownForkNames.has(name) && !knownRepairNames.has(name)) { + return yield* failBadState( + `Unrecognized legacy migration ${migration_id}_${name}; refusing to infer namespace state`, + ); + } + } + + const copiedUpstreamRows = legacyRows + .filter( + ({ migration_id, name }) => + migration_id <= canonicalPrefix && upstreamNames.get(migration_id) === name, + ) + .map(({ migration_id, name }) => ({ migration_id, name })); + if (tail.length > 0) { + yield* Migration0035; + yield* Migration0036; + } + + const forkNames = new Set(legacyRows.map(({ name }) => name)); + if ( + (forkNames.has("SessionIdentityClaims") && !forkNames.has("ProjectionQueuedMessages")) || + (forkNames.has("ProjectionThreadSourceAttribution") && + (!forkNames.has("ProjectionQueuedMessages") || !forkNames.has("SessionIdentityClaims"))) + ) { + return yield* failBadState( + "Legacy fork migrations do not form the expected contiguous prefix; refusing to skip missing work", + ); + } + if (forkNames.has("ProjectionQueuedMessages")) { + if ( + !(yield* tableExists("projection_queued_messages")) || + !(yield* indexExists("idx_projection_queued_messages_thread")) + ) { + return yield* failBadState( + "Legacy migration ledger records ProjectionQueuedMessages, but its table or index is missing", + ); + } + yield* sql`INSERT OR IGNORE INTO ${sql(forkMigrationTable)} ${sql.insert([ + { migration_id: 1, name: "ProjectionQueuedMessages" }, + ])}`; + } + if (forkNames.has("SessionIdentityClaims")) { + yield* verifyIdentitySchema(); + yield* sql`INSERT OR IGNORE INTO ${sql(forkMigrationTable)} ${sql.insert([ + { migration_id: 2, name: "SessionIdentityClaims" }, + ])}`; + } + if (forkNames.has("ProjectionThreadSourceAttribution")) { + yield* verifySourceAttributionSchema(); + yield* sql`INSERT OR IGNORE INTO ${sql(forkMigrationTable)} ${sql.insert([ + { migration_id: 3, name: "ProjectionThreadSourceAttribution" }, + ])}`; + } + + yield* sql`DELETE FROM ${sql(upstreamMigrationTable)}`; + if (copiedUpstreamRows.length > 0) { + yield* sql`INSERT INTO ${sql(upstreamMigrationTable)} ${sql.insert(copiedUpstreamRows)}`; + } + if (tail.length > 0) { + const reconciledRows = [35, 36] + .filter((migration_id) => migration_id > canonicalPrefix) + .map((migration_id) => ({ migration_id, name: upstreamNames.get(migration_id)! })); + if (reconciledRows.length > 0) { + yield* sql`INSERT INTO ${sql(upstreamMigrationTable)} ${sql.insert(reconciledRows)}`; + } + } +}); + +export const bootstrapMigrationNamespaces = Effect.fn("bootstrapMigrationNamespaces")(function* () { + const sql = yield* SqlClient.SqlClient; + yield* sql`CREATE TABLE IF NOT EXISTS ${sql(namespaceTable)} ( + version integer PRIMARY KEY NOT NULL, + created_at datetime NOT NULL DEFAULT current_timestamp + )`; + const rows = yield* sql<{ readonly version: number }>` + SELECT version FROM ${sql(namespaceTable)} WHERE version = ${namespaceVersion} + `; + if (rows.length > 0) { + return; + } + + yield* sql.withTransaction( + Effect.gen(function* () { + yield* bootstrapLegacyLedger(); + yield* sql`INSERT INTO ${sql(namespaceTable)} (version) VALUES (${namespaceVersion})`; + }), + ); +}); diff --git a/apps/server/src/persistence/MigrationNamespaces.test.ts b/apps/server/src/persistence/MigrationNamespaces.test.ts new file mode 100644 index 000000000000..731669c0165d --- /dev/null +++ b/apps/server/src/persistence/MigrationNamespaces.test.ts @@ -0,0 +1,27 @@ +import { assert, describe, it } from "@effect/vitest"; + +import { forkMigrationManifest, forkMigrationTable } from "./ForkMigrations.ts"; +import { upstreamMigrationTable } from "./MigrationBootstrap.ts"; +import { migrationManifest } from "./Migrations.ts"; + +describe("migration namespaces", () => { + it("keeps upstream and fork manifests in independent ledgers", () => { + assert.notEqual(upstreamMigrationTable, forkMigrationTable); + assert.deepStrictEqual(migrationManifest.slice(-4), [ + [47, "ProjectionProjectIcon"], + [48, "ProjectionThreadBranchPullRequest"], + [49, "ProjectionThreadsActiveOrderKey"], + [50, "ProjectionThreadPullRequests"], + ]); + assert.deepStrictEqual(forkMigrationManifest, [ + [1, "ProjectionQueuedMessages"], + [2, "SessionIdentityClaims"], + [3, "ProjectionThreadSourceAttribution"], + ]); + + const upstreamNames = new Set(migrationManifest.map(([, name]) => name)); + for (const [, name] of forkMigrationManifest) { + assert.ok(!upstreamNames.has(name), `${name} must not appear in the upstream manifest`); + } + }); +}); diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.ts index a728e6e6e22e..43e56772b3fc 100644 --- a/apps/server/src/persistence/Migrations.ts +++ b/apps/server/src/persistence/Migrations.ts @@ -11,6 +11,9 @@ import * as Migrator from "effect/unstable/sql/Migrator"; import * as Effect from "effect/Effect"; +import { forkMigrationTable, makeForkMigrationLoader } from "./ForkMigrations.ts"; +import { bootstrapMigrationNamespaces, upstreamMigrationTable } from "./MigrationBootstrap.ts"; + // Import all migrations statically import Migration0001 from "./Migrations/001_OrchestrationEvents.ts"; import Migration0002 from "./Migrations/002_OrchestrationCommandReceipts.ts"; @@ -128,7 +131,7 @@ const migrationEntries = [ export const migrationManifest = migrationEntries.map(([id, name]) => [id, name] as const); -const makeMigrationLoader = (throughId?: number) => +export const makeMigrationLoader = (throughId?: number) => Migrator.fromRecord( Object.fromEntries( migrationEntries @@ -160,7 +163,16 @@ export interface RunMigrationsOptions { export const runMigrations = Effect.fn("runMigrations")(function* ({ toMigrationInclusive, }: RunMigrationsOptions = {}) { - const executedMigrations = yield* run({ loader: makeMigrationLoader(toMigrationInclusive) }); + yield* bootstrapMigrationNamespaces(); + const upstreamMigrations = yield* run({ + loader: makeMigrationLoader(toMigrationInclusive), + table: upstreamMigrationTable, + }); + const forkMigrations = + toMigrationInclusive === undefined + ? yield* run({ loader: makeForkMigrationLoader(), table: forkMigrationTable }) + : []; + const executedMigrations = [...upstreamMigrations, ...forkMigrations]; const migrations = executedMigrations.map(([id, name]) => `${id}_${name}`); yield* migrations.length === 0 ? Effect.logDebug("Database schema is current") diff --git a/apps/server/src/persistence/Migrations/027_028_ProviderInstanceIdColumns.test.ts b/apps/server/src/persistence/Migrations/027_028_ProviderInstanceIdColumns.test.ts index b5e4f5cf3a22..7172f357ec58 100644 --- a/apps/server/src/persistence/Migrations/027_028_ProviderInstanceIdColumns.test.ts +++ b/apps/server/src/persistence/Migrations/027_028_ProviderInstanceIdColumns.test.ts @@ -3,6 +3,7 @@ import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as SqlClient from "effect/unstable/sql/SqlClient"; +import { upstreamMigrationTable } from "../MigrationBootstrap.ts"; import { runMigrations } from "../Migrations.ts"; import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; @@ -26,7 +27,7 @@ layer("027_028_ProviderInstanceIdColumns", (it) => { readonly name: string; }>` SELECT migration_id, name - FROM effect_sql_migrations + FROM ${sql(upstreamMigrationTable)} WHERE migration_id IN (27, 28) ORDER BY migration_id `; diff --git a/apps/server/src/persistence/Migrations/037_ProjectionQueuedMessages.ts b/apps/server/src/persistence/Migrations/037_ProjectionQueuedMessages.ts new file mode 100644 index 000000000000..33135eab60e3 --- /dev/null +++ b/apps/server/src/persistence/Migrations/037_ProjectionQueuedMessages.ts @@ -0,0 +1,26 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; + +export default Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + + yield* sql` + CREATE TABLE IF NOT EXISTS projection_queued_messages ( + message_id TEXT PRIMARY KEY, + thread_id TEXT NOT NULL, + text TEXT NOT NULL, + attachments_json TEXT NOT NULL, + model_selection_json TEXT, + source_proposed_plan_thread_id TEXT, + source_proposed_plan_id TEXT, + queued_at TEXT NOT NULL + ) + `; + + // Drain order is rowid (insertion) order; the index only serves the + // per-thread filter. + yield* sql` + CREATE INDEX IF NOT EXISTS idx_projection_queued_messages_thread + ON projection_queued_messages(thread_id) + `; +}); diff --git a/apps/server/src/persistence/Migrations/038_SessionIdentityClaims.ts b/apps/server/src/persistence/Migrations/038_SessionIdentityClaims.ts new file mode 100644 index 000000000000..b778ee3bcb37 --- /dev/null +++ b/apps/server/src/persistence/Migrations/038_SessionIdentityClaims.ts @@ -0,0 +1,19 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; + +export default Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* sql` + CREATE TABLE IF NOT EXISTS session_identity_claims ( + session_id TEXT PRIMARY KEY NOT NULL, + person_id TEXT NOT NULL, + username TEXT NOT NULL, + claimed_at TEXT NOT NULL, + method TEXT NOT NULL + ) + `; + yield* sql` + CREATE INDEX IF NOT EXISTS idx_session_identity_claims_person + ON session_identity_claims(person_id) + `; +}); diff --git a/apps/server/src/persistence/Migrations/039_040_RepairRestackedProjectionThreads.test.ts b/apps/server/src/persistence/Migrations/039_040_RepairRestackedProjectionThreads.test.ts new file mode 100644 index 000000000000..ddd61e7d216e --- /dev/null +++ b/apps/server/src/persistence/Migrations/039_040_RepairRestackedProjectionThreads.test.ts @@ -0,0 +1,107 @@ +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import * as Migrator from "effect/unstable/sql/Migrator"; + +import { forkMigrationTable } from "../ForkMigrations.ts"; +import { legacyMigrationBackupTable, upstreamMigrationTable } from "../MigrationBootstrap.ts"; +import { makeMigrationLoader, runMigrations } from "../Migrations.ts"; +import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; +import ProjectionQueuedMessages from "./037_ProjectionQueuedMessages.ts"; + +const layer = it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory())); +const runLegacyMigrations = Migrator.make({}); + +layer("b18 desktop migration namespace repair", (it) => { + it.effect("repairs the observed b18 mixed migration ledger", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + + yield* runLegacyMigrations({ loader: makeMigrationLoader(34) }); + yield* ProjectionQueuedMessages; + yield* sql` + CREATE TABLE session_identity_claims ( + session_id TEXT PRIMARY KEY NOT NULL, + person_id TEXT NOT NULL, + username TEXT NOT NULL, + claimed_at TEXT NOT NULL, + method TEXT NOT NULL + ) + `; + yield* sql` + CREATE INDEX idx_session_identity_claims_person + ON session_identity_claims(person_id) + `; + yield* sql`ALTER TABLE projection_thread_messages ADD COLUMN source_json TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN origin_source_json TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN participant_summaries_json TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN title_regeneration_request_id TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN title_regeneration_started_at TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN pinned_at TEXT`; + yield* sql` + INSERT INTO effect_sql_migrations (migration_id, name) + VALUES + (35, 'ProjectionQueuedMessages'), + (36, 'SessionIdentityClaims'), + (37, 'ProjectionThreadSourceAttribution'), + (38, 'ProjectionThreadSourceAttribution'), + (39, 'RepairProjectionThreadTitleRegeneration'), + (40, 'ProjectionThreadSourceAttribution') + `; + + yield* runMigrations(); + + const columns = yield* sql<{ readonly name: string }>` + PRAGMA table_info(projection_threads) + `; + const names = new Set(columns.map((column) => column.name)); + assert.ok(names.has("title_regeneration_request_id")); + assert.ok(names.has("title_regeneration_started_at")); + assert.ok(names.has("pinned_at")); + // Upstream 038 is asserted in the ledger above; assert its product + // effect too, so a repair that writes the row without applying the + // ALTER cannot pass. + assert.ok(names.has("pin_order_key")); + + const migrations = yield* sql<{ + readonly migration_id: number; + readonly name: string; + }>` + SELECT migration_id, name + FROM ${sql(legacyMigrationBackupTable)} + WHERE migration_id >= 35 + ORDER BY migration_id + `; + assert.deepStrictEqual(migrations, [ + { migration_id: 35, name: "ProjectionQueuedMessages" }, + { migration_id: 36, name: "SessionIdentityClaims" }, + { migration_id: 37, name: "ProjectionThreadSourceAttribution" }, + { migration_id: 38, name: "ProjectionThreadSourceAttribution" }, + { migration_id: 39, name: "RepairProjectionThreadTitleRegeneration" }, + { migration_id: 40, name: "ProjectionThreadSourceAttribution" }, + ]); + + const upstreamMigrations = yield* sql<{ + readonly migration_id: number; + readonly name: string; + }>`SELECT migration_id, name FROM ${sql(upstreamMigrationTable)} ORDER BY migration_id`; + assert.deepStrictEqual(upstreamMigrations.slice(-4), [ + { migration_id: 47, name: "ProjectionProjectIcon" }, + { migration_id: 48, name: "ProjectionThreadBranchPullRequest" }, + { migration_id: 49, name: "ProjectionThreadsActiveOrderKey" }, + { migration_id: 50, name: "ProjectionThreadPullRequests" }, + ]); + + const forkMigrations = yield* sql<{ + readonly migration_id: number; + readonly name: string; + }>`SELECT migration_id, name FROM ${sql(forkMigrationTable)} ORDER BY migration_id`; + assert.deepStrictEqual(forkMigrations, [ + { migration_id: 1, name: "ProjectionQueuedMessages" }, + { migration_id: 2, name: "SessionIdentityClaims" }, + { migration_id: 3, name: "ProjectionThreadSourceAttribution" }, + ]); + }), + ); +}); diff --git a/apps/server/src/persistence/Migrations/041_ProjectionThreadSourceAttribution.ts b/apps/server/src/persistence/Migrations/041_ProjectionThreadSourceAttribution.ts new file mode 100644 index 000000000000..9da2f9728055 --- /dev/null +++ b/apps/server/src/persistence/Migrations/041_ProjectionThreadSourceAttribution.ts @@ -0,0 +1,36 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; + +/** + * Source attribution denormalized onto projected messages and thread shells. + * JSON columns stay optional for legacy rows (NULL = absent). + */ +export default Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + + const messageColumns = yield* sql<{ readonly name: string }>` + PRAGMA table_info(projection_thread_messages) + `; + if (!messageColumns.some((column) => column.name === "source_json")) { + yield* sql` + ALTER TABLE projection_thread_messages + ADD COLUMN source_json TEXT + `; + } + + const threadColumns = yield* sql<{ readonly name: string }>` + PRAGMA table_info(projection_threads) + `; + if (!threadColumns.some((column) => column.name === "origin_source_json")) { + yield* sql` + ALTER TABLE projection_threads + ADD COLUMN origin_source_json TEXT + `; + } + if (!threadColumns.some((column) => column.name === "participant_summaries_json")) { + yield* sql` + ALTER TABLE projection_threads + ADD COLUMN participant_summaries_json TEXT + `; + } +}); diff --git a/apps/server/src/persistence/Migrations/ForkMigrationNamespaceFresh.test.ts b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceFresh.test.ts new file mode 100644 index 000000000000..278c4f11931e --- /dev/null +++ b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceFresh.test.ts @@ -0,0 +1,38 @@ +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; + +import { forkMigrationTable } from "../ForkMigrations.ts"; +import { upstreamMigrationTable } from "../MigrationBootstrap.ts"; +import { runMigrations } from "../Migrations.ts"; +import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; + +const layer = it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory())); + +layer("fork migration namespace on a fresh database", (it) => { + it.effect("runs equal numeric ids independently", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* runMigrations(); + + const upstream = yield* sql` + SELECT migration_id, name FROM ${sql(upstreamMigrationTable)} WHERE migration_id = 1 + `; + const fork = yield* sql` + SELECT migration_id, name FROM ${sql(forkMigrationTable)} ORDER BY migration_id + `; + assert.deepStrictEqual(upstream, [{ migration_id: 1, name: "OrchestrationEvents" }]); + assert.deepStrictEqual(fork, [ + { migration_id: 1, name: "ProjectionQueuedMessages" }, + { migration_id: 2, name: "SessionIdentityClaims" }, + { migration_id: 3, name: "ProjectionThreadSourceAttribution" }, + ]); + }), + ); +}); + +interface LedgerRow { + readonly migration_id: number; + readonly name: string; +} diff --git a/apps/server/src/persistence/Migrations/ForkMigrationNamespaceRepaired.test.ts b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceRepaired.test.ts new file mode 100644 index 000000000000..4e85d50bf104 --- /dev/null +++ b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceRepaired.test.ts @@ -0,0 +1,64 @@ +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import * as Migrator from "effect/unstable/sql/Migrator"; + +import { forkMigrationTable } from "../ForkMigrations.ts"; +import { legacyMigrationBackupTable, upstreamMigrationTable } from "../MigrationBootstrap.ts"; +import { makeMigrationLoader, runMigrations } from "../Migrations.ts"; +import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; +import ProjectionQueuedMessages from "./037_ProjectionQueuedMessages.ts"; + +const layer = it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory())); +const runLegacyMigrations = Migrator.make({}); + +layer("fork migration namespace for a repaired database", (it) => { + it.effect("converts the already-repaired fork ledger", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* runLegacyMigrations({ loader: makeMigrationLoader(36) }); + yield* ProjectionQueuedMessages; + yield* sql` + INSERT INTO effect_sql_migrations (migration_id, name) + VALUES + (37, 'ProjectionQueuedMessages'), + (39, 'RepairProjectionThreadTitleRegeneration'), + (40, 'RepairProjectionThreadsPinned') + `; + + yield* runMigrations(); + + const upstream = yield* sql` + SELECT migration_id, name FROM ${sql(upstreamMigrationTable)} ORDER BY migration_id + `; + const fork = yield* sql` + SELECT migration_id, name FROM ${sql(forkMigrationTable)} ORDER BY migration_id + `; + const backup = yield* sql` + SELECT migration_id, name FROM ${sql(legacyMigrationBackupTable)} ORDER BY migration_id + `; + assert.deepStrictEqual(upstream.slice(-4), [ + { migration_id: 47, name: "ProjectionProjectIcon" }, + { migration_id: 48, name: "ProjectionThreadBranchPullRequest" }, + { migration_id: 49, name: "ProjectionThreadsActiveOrderKey" }, + { migration_id: 50, name: "ProjectionThreadPullRequests" }, + ]); + assert.deepStrictEqual(fork, [ + { migration_id: 1, name: "ProjectionQueuedMessages" }, + { migration_id: 2, name: "SessionIdentityClaims" }, + { migration_id: 3, name: "ProjectionThreadSourceAttribution" }, + ]); + assert.deepStrictEqual(backup.slice(-3), [ + { migration_id: 37, name: "ProjectionQueuedMessages" }, + { migration_id: 39, name: "RepairProjectionThreadTitleRegeneration" }, + { migration_id: 40, name: "RepairProjectionThreadsPinned" }, + ]); + }), + ); +}); + +interface LedgerRow { + readonly migration_id: number; + readonly name: string; +} diff --git a/apps/server/src/persistence/Migrations/ForkMigrationNamespaceSmart.test.ts b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceSmart.test.ts new file mode 100644 index 000000000000..9e25dd113eaa --- /dev/null +++ b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceSmart.test.ts @@ -0,0 +1,95 @@ +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import * as Migrator from "effect/unstable/sql/Migrator"; + +import { forkMigrationTable } from "../ForkMigrations.ts"; +import { legacyMigrationBackupTable, upstreamMigrationTable } from "../MigrationBootstrap.ts"; +import { makeMigrationLoader, runMigrations } from "../Migrations.ts"; +import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; +import ProjectionQueuedMessages from "./037_ProjectionQueuedMessages.ts"; + +const layer = it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory())); +const runLegacyMigrations = Migrator.make({}); + +layer("smart migration namespace repair", (it) => { + it.effect("repairs the observed smart mixed migration ledger", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* runLegacyMigrations({ loader: makeMigrationLoader(34) }); + yield* ProjectionQueuedMessages; + yield* sql` + CREATE TABLE session_identity_claims ( + session_id TEXT PRIMARY KEY NOT NULL, + person_id TEXT NOT NULL, + username TEXT NOT NULL, + claimed_at TEXT NOT NULL, + method TEXT NOT NULL + ) + `; + yield* sql` + CREATE INDEX idx_session_identity_claims_person + ON session_identity_claims(person_id) + `; + yield* sql`ALTER TABLE projection_thread_messages ADD COLUMN source_json TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN origin_source_json TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN participant_summaries_json TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN title_regeneration_request_id TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN title_regeneration_started_at TEXT`; + yield* sql`ALTER TABLE projection_threads ADD COLUMN pinned_at TEXT`; + yield* sql` + INSERT INTO effect_sql_migrations (migration_id, name) + VALUES + (35, 'ProjectionQueuedMessages'), + (36, 'SessionIdentityClaims'), + (37, 'ProjectionThreadSourceAttribution'), + (38, 'ProjectionThreadSourceAttribution'), + (39, 'RepairProjectionThreadTitleRegeneration'), + (40, 'ProjectionThreadSourceAttribution'), + (41, 'ProjectionThreadSourceAttribution') + `; + + yield* runMigrations(); + + const backupTail = yield* sql` + SELECT migration_id, name + FROM ${sql(legacyMigrationBackupTable)} + WHERE migration_id >= 35 + ORDER BY migration_id + `; + assert.deepStrictEqual(backupTail, [ + { migration_id: 35, name: "ProjectionQueuedMessages" }, + { migration_id: 36, name: "SessionIdentityClaims" }, + { migration_id: 37, name: "ProjectionThreadSourceAttribution" }, + { migration_id: 38, name: "ProjectionThreadSourceAttribution" }, + { migration_id: 39, name: "RepairProjectionThreadTitleRegeneration" }, + { migration_id: 40, name: "ProjectionThreadSourceAttribution" }, + { migration_id: 41, name: "ProjectionThreadSourceAttribution" }, + ]); + + const upstream = yield* sql` + SELECT migration_id, name FROM ${sql(upstreamMigrationTable)} ORDER BY migration_id + `; + assert.deepStrictEqual(upstream.slice(-4), [ + { migration_id: 47, name: "ProjectionProjectIcon" }, + { migration_id: 48, name: "ProjectionThreadBranchPullRequest" }, + { migration_id: 49, name: "ProjectionThreadsActiveOrderKey" }, + { migration_id: 50, name: "ProjectionThreadPullRequests" }, + ]); + const fork = yield* sql` + SELECT migration_id, name FROM ${sql(forkMigrationTable)} ORDER BY migration_id + `; + assert.deepStrictEqual(fork, [ + { migration_id: 1, name: "ProjectionQueuedMessages" }, + { migration_id: 2, name: "SessionIdentityClaims" }, + { migration_id: 3, name: "ProjectionThreadSourceAttribution" }, + ]); + }), + ); +}); + +interface LedgerRow { + readonly migration_id: number; + readonly name: string; +} diff --git a/apps/server/src/persistence/Migrations/ForkMigrationNamespaceT3vm.test.ts b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceT3vm.test.ts new file mode 100644 index 000000000000..5475cf6a3c48 --- /dev/null +++ b/apps/server/src/persistence/Migrations/ForkMigrationNamespaceT3vm.test.ts @@ -0,0 +1,54 @@ +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import * as Migrator from "effect/unstable/sql/Migrator"; + +import { forkMigrationTable } from "../ForkMigrations.ts"; +import { legacyMigrationBackupTable, upstreamMigrationTable } from "../MigrationBootstrap.ts"; +import { makeMigrationLoader, runMigrations } from "../Migrations.ts"; +import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; + +const layer = it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory())); +const runLegacyMigrations = Migrator.make({}); + +layer("t3vm migration namespace repair", (it) => { + it.effect("upgrades the observed canonical upstream ledger at migration 32", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* runLegacyMigrations({ loader: makeMigrationLoader(32) }); + + yield* runMigrations(); + + const backup = yield* sql` + SELECT migration_id, name FROM ${sql(legacyMigrationBackupTable)} ORDER BY migration_id + `; + assert.equal(backup.at(-1)?.migration_id, 32); + + const upstream = yield* sql` + SELECT migration_id, name FROM ${sql(upstreamMigrationTable)} ORDER BY migration_id + `; + assert.deepStrictEqual(upstream.slice(-6), [ + { migration_id: 45, name: "ProjectionProjectsAutoPull" }, + { migration_id: 46, name: "RepairAutomaticSettlementTimestamps" }, + { migration_id: 47, name: "ProjectionProjectIcon" }, + { migration_id: 48, name: "ProjectionThreadBranchPullRequest" }, + { migration_id: 49, name: "ProjectionThreadsActiveOrderKey" }, + { migration_id: 50, name: "ProjectionThreadPullRequests" }, + ]); + const fork = yield* sql` + SELECT migration_id, name FROM ${sql(forkMigrationTable)} ORDER BY migration_id + `; + assert.deepStrictEqual(fork, [ + { migration_id: 1, name: "ProjectionQueuedMessages" }, + { migration_id: 2, name: "SessionIdentityClaims" }, + { migration_id: 3, name: "ProjectionThreadSourceAttribution" }, + ]); + }), + ); +}); + +interface LedgerRow { + readonly migration_id: number; + readonly name: string; +} diff --git a/apps/server/src/persistence/Services/ProjectionQueuedMessages.ts b/apps/server/src/persistence/Services/ProjectionQueuedMessages.ts new file mode 100644 index 000000000000..6a884dd7b578 --- /dev/null +++ b/apps/server/src/persistence/Services/ProjectionQueuedMessages.ts @@ -0,0 +1,61 @@ +import { + ChatAttachment, + IsoDateTime, + MessageId, + ModelSelection, + OrchestrationProposedPlanId, + ThreadId, +} from "@t3tools/contracts"; +import * as Schema from "effect/Schema"; +import * as Context from "effect/Context"; +import type * as Effect from "effect/Effect"; + +import type { ProjectionRepositoryError } from "../Errors.ts"; + +export const ProjectionQueuedMessage = Schema.Struct({ + messageId: MessageId, + threadId: ThreadId, + text: Schema.String, + attachments: Schema.Array(ChatAttachment), + modelSelection: Schema.NullOr(ModelSelection), + sourceProposedPlanThreadId: Schema.NullOr(ThreadId), + sourceProposedPlanId: Schema.NullOr(OrchestrationProposedPlanId), + queuedAt: IsoDateTime, +}); +export type ProjectionQueuedMessage = typeof ProjectionQueuedMessage.Type; + +export const ListProjectionQueuedMessagesInput = Schema.Struct({ + threadId: ThreadId, +}); +export type ListProjectionQueuedMessagesInput = typeof ListProjectionQueuedMessagesInput.Type; + +export const DeleteProjectionQueuedMessageInput = Schema.Struct({ + threadId: ThreadId, + messageId: MessageId, +}); +export type DeleteProjectionQueuedMessageInput = typeof DeleteProjectionQueuedMessageInput.Type; + +export const DeleteProjectionQueuedMessagesInput = Schema.Struct({ + threadId: ThreadId, +}); +export type DeleteProjectionQueuedMessagesInput = typeof DeleteProjectionQueuedMessagesInput.Type; + +export interface ProjectionQueuedMessageRepositoryShape { + readonly upsert: ( + queuedMessage: ProjectionQueuedMessage, + ) => Effect.Effect; + readonly listByThreadId: ( + input: ListProjectionQueuedMessagesInput, + ) => Effect.Effect, ProjectionRepositoryError>; + readonly deleteByMessageId: ( + input: DeleteProjectionQueuedMessageInput, + ) => Effect.Effect; + readonly deleteByThreadId: ( + input: DeleteProjectionQueuedMessagesInput, + ) => Effect.Effect; +} + +export class ProjectionQueuedMessageRepository extends Context.Service< + ProjectionQueuedMessageRepository, + ProjectionQueuedMessageRepositoryShape +>()("t3/persistence/Services/ProjectionQueuedMessages/ProjectionQueuedMessageRepository") {} diff --git a/apps/server/src/persistence/Services/ProjectionThreadActivities.ts b/apps/server/src/persistence/Services/ProjectionThreadActivities.ts index 85e9d368df4c..523ca1dddf1e 100644 --- a/apps/server/src/persistence/Services/ProjectionThreadActivities.ts +++ b/apps/server/src/persistence/Services/ProjectionThreadActivities.ts @@ -41,6 +41,13 @@ export const ListProjectionThreadActivitiesInput = Schema.Struct({ }); export type ListProjectionThreadActivitiesInput = typeof ListProjectionThreadActivitiesInput.Type; +export const ListProjectionThreadActivitiesByKindInput = Schema.Struct({ + threadId: ThreadId, + kinds: Schema.Array(Schema.String), +}); +export type ListProjectionThreadActivitiesByKindInput = + typeof ListProjectionThreadActivitiesByKindInput.Type; + export const GetLatestProjectionThreadTaskActivityInput = Schema.Struct({ threadId: ThreadId, taskId: Schema.String, @@ -77,6 +84,19 @@ export interface ProjectionThreadActivityRepositoryShape { input: ListProjectionThreadActivitiesInput, ) => Effect.Effect, ProjectionRepositoryError>; + /** + * List projected thread activity rows for a thread, restricted to `kinds`. + * + * Same order as {@link listByThreadId}. Callers that derive a fact from a few + * activity kinds must use this: a thread's full activity list carries every + * tool payload it ever produced, which reaches hundreds of megabytes on a + * long-running thread, and reading it per event is what drove the server heap + * into its ceiling. + */ + readonly listByThreadIdAndKinds: ( + input: ListProjectionThreadActivitiesByKindInput, + ) => Effect.Effect, ProjectionRepositoryError>; + /** * List activity rows used to derive pending user-input state. * diff --git a/apps/server/src/persistence/Services/ProjectionThreadMessages.ts b/apps/server/src/persistence/Services/ProjectionThreadMessages.ts index a7e258ad5dc0..67a2b12dd0b3 100644 --- a/apps/server/src/persistence/Services/ProjectionThreadMessages.ts +++ b/apps/server/src/persistence/Services/ProjectionThreadMessages.ts @@ -10,6 +10,7 @@ import { ChatAttachment, MessageId, OrchestrationMessageRole, + SourceRef, ThreadId, TurnId, IsoDateTime, @@ -30,6 +31,8 @@ export const ProjectionThreadMessage = Schema.Struct({ text: Schema.String, attachments: Schema.optional(Schema.Array(ChatAttachment)), isStreaming: Schema.Boolean, + /** Server-authored provenance; absent on legacy / assistant rows. */ + source: Schema.optional(SourceRef), createdAt: IsoDateTime, updatedAt: IsoDateTime, }); diff --git a/apps/server/src/persistence/Services/ProjectionThreads.ts b/apps/server/src/persistence/Services/ProjectionThreads.ts index 0a8b2e31c5ab..7379e4ec24f4 100644 --- a/apps/server/src/persistence/Services/ProjectionThreads.ts +++ b/apps/server/src/persistence/Services/ProjectionThreads.ts @@ -14,8 +14,10 @@ import { ProjectId, ProviderInteractionMode, RuntimeMode, + SourceRef, ThreadLinkedPullRequest, ThreadId, + ThreadParticipantSummary, TurnId, } from "@t3tools/contracts"; import * as Option from "effect/Option"; @@ -55,6 +57,10 @@ export const ProjectionThread = Schema.Struct({ pendingUserInputCount: NonNegativeInt, hasActionableProposedPlan: NonNegativeInt, deletedAt: Schema.NullOr(IsoDateTime), + /** First user-message SourceRef; null/absent on legacy threads. */ + originSource: Schema.optional(Schema.NullOr(SourceRef)), + /** Ordered participant stack data for list UI. */ + participantSummaries: Schema.optional(Schema.Array(ThreadParticipantSummary)), }); export type ProjectionThread = typeof ProjectionThread.Type; @@ -73,6 +79,14 @@ export const ListProjectionThreadsByProjectInput = Schema.Struct({ }); export type ListProjectionThreadsByProjectInput = typeof ListProjectionThreadsByProjectInput.Type; +export const ProjectionThreadWorktreeReference = Schema.Struct({ + threadId: ThreadId, + projectId: ProjectId, + worktreePath: Schema.String, + archivedAt: Schema.NullOr(IsoDateTime), +}); +export type ProjectionThreadWorktreeReference = typeof ProjectionThreadWorktreeReference.Type; + /** * ProjectionThreadRepositoryShape - Service API for projected thread records. */ @@ -106,6 +120,19 @@ export interface ProjectionThreadRepositoryShape { readonly deleteById: ( input: DeleteProjectionThreadInput, ) => Effect.Effect; + + /** + * List every nondeleted thread row that references a worktree path. + * + * Soft-deleted rows are excluded so they never count as worktree + * references; archived rows are included so callers can distinguish + * archived from active references. Path comparison is left to callers so + * they can apply the shared normalization helper. + */ + readonly listWorktreeReferences: () => Effect.Effect< + ReadonlyArray, + ProjectionRepositoryError + >; } /** diff --git a/apps/server/src/persistence/Services/ProjectionTurns.ts b/apps/server/src/persistence/Services/ProjectionTurns.ts index f3d5d5e47061..faf70bce24a2 100644 --- a/apps/server/src/persistence/Services/ProjectionTurns.ts +++ b/apps/server/src/persistence/Services/ProjectionTurns.ts @@ -128,6 +128,15 @@ export interface ProjectionTurnRepositoryShape { input: GetProjectionPendingTurnStartInput, ) => Effect.Effect, ProjectionRepositoryError>; + /** + * Lists every pending-start placeholder across active reconciliation scope. + * Callers must still resolve the owning thread and discard archived/deleted rows. + */ + readonly listPendingTurnStarts: () => Effect.Effect< + ReadonlyArray, + ProjectionRepositoryError + >; + /** * Deletes only pending-start placeholder rows (`turnId = null`) for a thread and leaves concrete turn rows untouched. */ diff --git a/apps/server/src/persistence/SessionIdentityClaims.ts b/apps/server/src/persistence/SessionIdentityClaims.ts new file mode 100644 index 000000000000..b7eafb4b4c31 --- /dev/null +++ b/apps/server/src/persistence/SessionIdentityClaims.ts @@ -0,0 +1,177 @@ +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; +import * as SqlSchema from "effect/unstable/sql/SqlSchema"; +import { + AuthSessionId, + IdentityUsername, + PersonId, + SessionIdentityClaimMethod, +} from "@t3tools/contracts"; + +import { + PersistenceDecodeError, + PersistenceSqlError, + type PersistenceErrorCorrelation, +} from "./Errors.ts"; + +export const SessionIdentityClaimRecord = Schema.Struct({ + sessionId: AuthSessionId, + personId: PersonId, + username: IdentityUsername, + claimedAt: Schema.String, + method: SessionIdentityClaimMethod, +}); +export type SessionIdentityClaimRecord = typeof SessionIdentityClaimRecord.Type; + +type ClaimRepoError = PersistenceSqlError | PersistenceDecodeError; + +export class SessionIdentityClaimRepository extends Context.Service< + SessionIdentityClaimRepository, + { + readonly getBySessionId: ( + sessionId: AuthSessionId, + ) => Effect.Effect, ClaimRepoError>; + readonly upsert: (record: SessionIdentityClaimRecord) => Effect.Effect; + readonly deleteBySessionId: ( + sessionId: AuthSessionId, + ) => Effect.Effect; + } +>()("t3/persistence/SessionIdentityClaims/SessionIdentityClaimRepository") {} + +const toError = + (sqlOp: string, decodeOp: string, correlation?: PersistenceErrorCorrelation) => + (cause: unknown): ClaimRepoError => + Schema.isSchemaError(cause) + ? PersistenceDecodeError.fromSchemaError(decodeOp, cause, correlation) + : new PersistenceSqlError({ + operation: sqlOp, + ...(correlation === undefined ? {} : { correlation }), + cause, + }); + +const ClaimDbRow = Schema.Struct({ + sessionId: AuthSessionId, + personId: PersonId, + username: IdentityUsername, + claimedAt: Schema.String, + method: SessionIdentityClaimMethod, +}); + +const decodeClaim = Schema.decodeUnknownEffect(ClaimDbRow); + +export const make = Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + + const getRow = SqlSchema.findOneOption({ + Request: Schema.Struct({ sessionId: AuthSessionId }), + Result: Schema.Struct({ + sessionId: Schema.String, + personId: Schema.Unknown, + username: Schema.Unknown, + claimedAt: Schema.Unknown, + method: Schema.Unknown, + }), + execute: ({ sessionId }) => + sql` + SELECT + session_id AS "sessionId", + person_id AS "personId", + username AS "username", + claimed_at AS "claimedAt", + method AS "method" + FROM session_identity_claims + WHERE session_id = ${sessionId} + `, + }); + + const upsertRow = SqlSchema.void({ + Request: SessionIdentityClaimRecord, + execute: (input) => + sql` + INSERT INTO session_identity_claims ( + session_id, + person_id, + username, + claimed_at, + method + ) + VALUES ( + ${input.sessionId}, + ${input.personId}, + ${input.username}, + ${input.claimedAt}, + ${input.method} + ) + ON CONFLICT(session_id) DO UPDATE SET + person_id = excluded.person_id, + username = excluded.username, + claimed_at = excluded.claimed_at, + method = excluded.method + `, + }); + + const deleteRow = SqlSchema.void({ + Request: Schema.Struct({ sessionId: AuthSessionId }), + execute: ({ sessionId }) => + sql` + DELETE FROM session_identity_claims + WHERE session_id = ${sessionId} + `, + }); + + return { + getBySessionId: (sessionId) => + getRow({ sessionId }).pipe( + Effect.mapError( + toError( + "SessionIdentityClaimRepository.getBySessionId:query", + "SessionIdentityClaimRepository.getBySessionId:decode", + { sessionId }, + ), + ), + Effect.flatMap((rowOption) => + Option.match(rowOption, { + onNone: () => Effect.succeed(Option.none()), + onSome: (row) => + decodeClaim(row).pipe( + Effect.mapError((cause) => + PersistenceDecodeError.fromSchemaError( + "SessionIdentityClaimRepository.getBySessionId:decode", + cause, + { sessionId }, + ), + ), + Effect.map((decoded) => Option.some(decoded)), + ), + }), + ), + ), + upsert: (record) => + upsertRow(record).pipe( + Effect.mapError( + toError( + "SessionIdentityClaimRepository.upsert:query", + "SessionIdentityClaimRepository.upsert:encode", + { sessionId: record.sessionId }, + ), + ), + ), + deleteBySessionId: (sessionId) => + deleteRow({ sessionId }).pipe( + Effect.mapError( + toError( + "SessionIdentityClaimRepository.deleteBySessionId:query", + "SessionIdentityClaimRepository.deleteBySessionId:encode", + { sessionId }, + ), + ), + Effect.as(true), + ), + } satisfies SessionIdentityClaimRepository["Service"]; +}); + +export const layer = Layer.effect(SessionIdentityClaimRepository, make); diff --git a/apps/server/src/preview/PortExposure.test.ts b/apps/server/src/preview/PortExposure.test.ts new file mode 100644 index 000000000000..b0dc11a68222 --- /dev/null +++ b/apps/server/src/preview/PortExposure.test.ts @@ -0,0 +1,332 @@ +import { assert, describe, it } from "@effect/vitest"; +import { PreviewPortUnreachableError } from "@t3tools/contracts"; +import * as Net from "@t3tools/shared/Net"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import * as Sink from "effect/Sink"; +import * as Stream from "effect/Stream"; +import * as TestClock from "effect/testing/TestClock"; +import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +import { PreviewPortExposure, layer as portExposureLayer } from "./PortExposure.ts"; + +const encoder = new TextEncoder(); + +const CLIENT_ON_TAILNET = "https://smart.tail.ts.net/"; +const CLIENT_ON_LOOPBACK = "http://localhost:5732/"; + +interface SpawnCall { + readonly args: ReadonlyArray; +} + +const serveStatusWith = (mappings: ReadonlyArray<{ servePort: number; localPort: number }>) => + JSON.stringify({ + Web: Object.fromEntries( + mappings.map(({ servePort, localPort }) => [ + `smart.tail.ts.net:${servePort}`, + { Handlers: { "/": { Proxy: `http://127.0.0.1:${localPort}` } } }, + ]), + ), + }); + +/** + * Records every tailscale invocation and answers `serve status` from a mutable + * script, so a test can assert that publishing a port is what makes it appear. + */ +const spawnerHarness = (input: { + readonly serveStatus: () => string; + readonly onServe?: (args: ReadonlyArray) => { stderr?: string; code?: number }; +}) => + Effect.gen(function* () { + const calls = yield* Ref.make>([]); + const layer = Layer.succeed( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make((command) => { + const spawned = command as unknown as { readonly args: ReadonlyArray }; + const args = spawned.args; + const isStatusRead = args[0] === "serve" && args[1] === "status"; + const result = isStatusRead + ? { stdout: input.serveStatus(), code: 0 } + : { stdout: "", ...(input.onServe?.(args) ?? { code: 0 }) }; + return Ref.update(calls, (previous) => [...previous, { args }]).pipe( + Effect.as( + ChildProcessSpawner.makeHandle({ + pid: ChildProcessSpawner.ProcessId(1), + exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(result.code ?? 0)), + isRunning: Effect.succeed(false), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.drain, + stdout: Stream.make(encoder.encode(result.stdout ?? "")), + stderr: Stream.make(encoder.encode(result.stderr ?? "")), + all: Stream.empty, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.empty, + }), + ), + ); + }), + ); + return { calls, layer }; + }); + +const netLayer = (listeningPorts: ReadonlyArray) => + Layer.succeed(Net.NetService, { + canListenOnHost: () => Effect.succeed(true), + isPortAvailableOnLoopback: (port: number) => Effect.succeed(!listeningPorts.includes(port)), + // Added upstream in #6572 for SSH host reachability. The bind-side checks + // above answer "could I listen"; this one answers "is something already + // listening", which is exactly what listeningPorts models. + hasListenerOnHost: (port: number) => Effect.succeed(listeningPorts.includes(port)), + reserveLoopbackPort: () => Effect.succeed(0), + findAvailablePort: (preferred: number) => Effect.succeed(preferred), + } as Net.NetServiceShape); + +/** + * Answers a probe only for origins the test says are actually serving. Modelled + * on reachability rather than a fixed status code, because the resolver's whole + * job is to tell a route that answers from one that does not. + */ +const httpLayer = (isReachable: (url: string) => boolean) => + Layer.succeed( + HttpClient.HttpClient, + HttpClient.make( + ( + request, + ): Effect.Effect => + isReachable(request.url) + ? Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status: 200 }))) + : Effect.fail( + new HttpClientError.HttpClientError({ + reason: new HttpClientError.TransportError({ + request, + description: "connection refused", + }), + }), + ), + ), + ); + +const runResolve = (input: { + readonly port: number; + readonly clientBaseUrl: string; + readonly serveStatus: () => string; + readonly listeningPorts: ReadonlyArray; + readonly onServe?: (args: ReadonlyArray) => { stderr?: string; code?: number }; + /** Origins that answer beyond whatever the current serve status publishes. */ + readonly alsoReachable?: ReadonlyArray; + /** Set when a published mapping still must not answer. */ + readonly neverReachable?: boolean; +}) => + Effect.gen(function* () { + const harness = yield* spawnerHarness({ + serveStatus: input.serveStatus, + ...(input.onServe ? { onServe: input.onServe } : {}), + }); + const reachable = (url: string) => { + if (input.neverReachable) return false; + if (input.alsoReachable?.some((origin) => url.startsWith(origin))) return true; + const published = JSON.parse(input.serveStatus()) as { + Web?: Record; + }; + return Object.keys(published.Web ?? {}).some((hostKey) => + url.startsWith(`https://${hostKey}`), + ); + }; + const resolving = yield* Effect.forkChild( + Effect.gen(function* () { + const exposure = yield* PreviewPortExposure; + return yield* exposure + .resolve({ port: input.port, clientBaseUrl: input.clientBaseUrl }) + .pipe(Effect.result); + }).pipe( + Effect.provide( + portExposureLayer.pipe( + Layer.provide(harness.layer), + Layer.provide(netLayer(input.listeningPorts)), + Layer.provide(httpLayer(reachable)), + ), + ), + ), + ); + // The reachability probe retries on a schedule until a deadline, so an + // unreachable port only resolves once virtual time passes that deadline. + yield* TestClock.adjust("10 seconds"); + const result = yield* Fiber.join(resolving); + return { result, calls: yield* Ref.get(harness.calls) }; + }); + +describe("PreviewPortExposure", () => { + it.effect("keeps a same-machine client on loopback and publishes nothing", () => + Effect.gen(function* () { + const { result, calls } = yield* runResolve({ + port: 5733, + clientBaseUrl: CLIENT_ON_LOOPBACK, + serveStatus: () => "{}", + listeningPorts: [5733], + }); + + assert.deepEqual(result._tag === "Success" ? result.success : null, { + origin: "http://localhost:5733", + strategy: "loopback", + createdExposure: false, + }); + // Nothing was asked of tailscale: a local client never needs the tailnet, + // and publishing here would share a dev server nobody asked to share. + assert.deepEqual(calls, []); + }), + ); + + it.effect("reuses an existing mapping instead of assuming port parity", () => + Effect.gen(function* () { + const { result, calls } = yield* runResolve({ + port: 5733, + clientBaseUrl: CLIENT_ON_TAILNET, + // Published on a different tailnet port, over https — exactly the shape + // the old client-side guess (same port, same scheme) got wrong. + serveStatus: () => serveStatusWith([{ servePort: 45733, localPort: 5733 }]), + listeningPorts: [5733], + }); + + assert.deepEqual(result._tag === "Success" ? result.success : null, { + origin: "https://smart.tail.ts.net:45733", + strategy: "tailnet-serve", + createdExposure: false, + }); + assert.isUndefined(calls.find((call) => call.args.includes("--bg"))); + }), + ); + + it.effect("uses the environment's own address when the port already answers there", () => + Effect.gen(function* () { + const { result, calls } = yield* runResolve({ + port: 5173, + // A WSL / LAN environment, where a dev server bound to a wildcard + // address is genuinely reachable at the host the client already uses. + clientBaseUrl: "http://172.25.85.75:3773/", + serveStatus: () => "{}", + listeningPorts: [5173], + alsoReachable: ["http://172.25.85.75:5173"], + }); + + assert.deepEqual(result._tag === "Success" ? result.success : null, { + origin: "http://172.25.85.75:5173", + strategy: "direct-private-network", + createdExposure: false, + }); + // Nothing published: a route that already works needs no second one. + assert.isUndefined(calls.find((call) => call.args.includes("--bg"))); + }), + ); + + it.effect("publishes a loopback-only port on demand", () => + Effect.gen(function* () { + let published = false; + const { result, calls } = yield* runResolve({ + port: 6545, + clientBaseUrl: CLIENT_ON_TAILNET, + serveStatus: () => + published ? serveStatusWith([{ servePort: 6545, localPort: 6545 }]) : "{}", + listeningPorts: [6545], + onServe: () => { + published = true; + return { code: 0 }; + }, + }); + + assert.deepEqual(result._tag === "Success" ? result.success : null, { + origin: "https://smart.tail.ts.net:6545", + strategy: "tailnet-serve", + createdExposure: true, + }); + // Targets `localhost`, not `127.0.0.1`: Vite's default bind is `::1` only, + // and an IPv4-pinned mapping proxies to nothing and answers 502. + assert.deepEqual(calls.find((call) => call.args.includes("--bg"))?.args, [ + "serve", + "--bg", + "--https=6545", + "http://localhost:6545", + ]); + }), + ); + + it.effect("fails with a remedy when the dev server is not running", () => + Effect.gen(function* () { + const { result } = yield* runResolve({ + port: 6545, + clientBaseUrl: CLIENT_ON_TAILNET, + serveStatus: () => "{}", + listeningPorts: [], + }); + + const error = result._tag === "Failure" ? result.failure : null; + assert.instanceOf(error, PreviewPortUnreachableError); + assert.equal(error?.reason, "not-listening"); + assert.include(error?.message ?? "", "Start the dev server first"); + }), + ); + + it.effect("refuses to take over a tailnet port that routes elsewhere", () => + Effect.gen(function* () { + const { result, calls } = yield* runResolve({ + port: 6545, + clientBaseUrl: CLIENT_ON_TAILNET, + serveStatus: () => + serveStatusWith([ + { servePort: 6545, localPort: 9999 }, + { servePort: 46545, localPort: 9998 }, + ]), + listeningPorts: [6545], + }); + + const error = result._tag === "Failure" ? result.failure : null; + assert.equal(error?.reason, "serve-port-conflict"); + // The pre-existing mapping is left exactly as it was found. + assert.isUndefined(calls.find((call) => call.args.includes("--bg"))); + }), + ); + + it.effect("surfaces a permission failure as an actionable reason", () => + Effect.gen(function* () { + const { result } = yield* runResolve({ + port: 6545, + clientBaseUrl: CLIENT_ON_TAILNET, + serveStatus: () => "{}", + listeningPorts: [6545], + onServe: () => ({ code: 1, stderr: "access denied: must be root" }), + }); + + const error = result._tag === "Failure" ? result.failure : null; + assert.equal(error?.reason, "tailscale-permission-denied"); + // The classified label travels, never the raw stderr. + assert.notInclude(error?.message ?? "", "must be root"); + }), + ); + + it.effect("withdraws a mapping it published but could not reach", () => + Effect.gen(function* () { + let published = false; + const { result, calls } = yield* runResolve({ + port: 6545, + clientBaseUrl: CLIENT_ON_TAILNET, + serveStatus: () => + published ? serveStatusWith([{ servePort: 6545, localPort: 6545 }]) : "{}", + listeningPorts: [6545], + onServe: () => { + published = true; + return { code: 0 }; + }, + neverReachable: true, + }); + + const error = result._tag === "Failure" ? result.failure : null; + assert.equal(error?.reason, "not-reachable"); + // Publishing a port and then leaving it behind would keep a dead route on + // the tailnet, so the failure path has to undo its own mapping. + assert.deepEqual(calls.at(-1)?.args, ["serve", "--https=6545", "off"]); + }), + ); +}); diff --git a/apps/server/src/preview/PortExposure.ts b/apps/server/src/preview/PortExposure.ts new file mode 100644 index 000000000000..66071a7d3841 --- /dev/null +++ b/apps/server/src/preview/PortExposure.ts @@ -0,0 +1,324 @@ +/** + * Resolves a local dev-server port to a URL the *connected client* can open. + * + * The preview surface used to do this on the client by swapping `localhost` for + * the environment's hostname and keeping the port and scheme. That guess is + * wrong whenever the port is not independently published on that hostname — + * which is the normal case, because dev servers bind loopback. The browser then + * showed ERR_CONNECTION_REFUSED, indistinguishable from a broken app. + * + * Only the server can answer this: it is the side that knows what is listening + * locally and what the tailnet actually routes. So it looks up the real + * `tailscale serve` mapping, creates one when the port has none, verifies the + * result answers, and otherwise fails with a reason and a next action instead + * of handing back a URL that cannot work. + */ +import { + PreviewPortUnreachableError, + type PreviewPortResolution, + type PreviewPortResolveRequest, +} from "@t3tools/contracts"; +import * as Net from "@t3tools/shared/Net"; +import { isLoopbackHost } from "@t3tools/shared/preview"; +import { + disableTailscaleServe, + ensureTailscaleServe, + findRootServeMappingForLocalPort, + readTailscaleServeMappings, + type TailscaleServeMapping, +} from "@t3tools/tailscale"; +import * as Context from "effect/Context"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import * as Schedule from "effect/Schedule"; +import { HttpClient, HttpClientRequest } from "effect/unstable/http"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +export class PreviewPortExposure extends Context.Service< + PreviewPortExposure, + { + readonly resolve: ( + request: PreviewPortResolveRequest, + ) => Effect.Effect; + } +>()("t3/preview/PortExposure/PreviewPortExposure") {} + +/** + * A tailnet mapping only carries a dev server correctly when it is offered at + * the site root, so the serve port is the only free variable. Preferring the + * local port number keeps parity with `vp run dev --share`, which makes an + * already-shared dev server resolve to the URL the developer was told about. + */ +const SERVE_PORT_FALLBACK_OFFSET = 40_000; + +const PROBE_TIMEOUT = Duration.seconds(2); +// `tailscale serve` returns before the listener is accepting, and a fresh +// MagicDNS cert can take a beat. Retrying until a deadline turns that race into +// a slower success instead of a spurious "unreachable". The deadline bounds the +// whole loop rather than an attempt count, so a slow attempt cannot multiply +// out into a request the caller waits minutes on. +const PROBE_SCHEDULE = Schedule.spaced(Duration.millis(250)); +const PROBE_DEADLINE = Duration.seconds(5); + +/** + * Route through `localhost` rather than `127.0.0.1`. + * + * Vite's default `--host localhost` binds `::1` only, so a mapping pinned to the + * IPv4 loopback proxies to nothing and answers 502 — reachable, and useless. + * The hostname lets tailscale pick whichever family the dev server actually + * bound. + */ +const SERVE_TARGET_HOST = "localhost"; + +const REMEDY_BY_REASON = { + "tailscale-unavailable": + "This machine has no tailnet identity, so a loopback-only dev server cannot be reached from a remote client. Run the client on this machine, or bring up Tailscale here.", + "tailscale-not-logged-in": "Run `tailscale up` on the environment host, then retry.", + "tailscale-permission-denied": + "The server may not manage tailnet routes. Run `sudo tailscale set --operator=$USER` on the environment host, or publish the port yourself with `tailscale serve`.", + "not-listening": "Start the dev server first, then open the port again.", +} as const; + +const conflictRemedy = (port: number, servePort: number): string => + `Tailnet port ${servePort} already routes somewhere else, so port ${port} cannot be published without taking it over. Free it with \`tailscale serve --https=${servePort} off\`, or publish the port yourself on a spare tailnet port.`; + +const exposureRemedy = (port: number): string => + `Publish it manually with \`tailscale serve --bg --https=${port} http://${SERVE_TARGET_HOST}:${port}\`, or restart the dev server with \`vp run dev --share\`.`; + +const unreachableRemedy = (port: number, origin: string): string => + `${origin} was published but did not answer. Confirm the dev server on port ${port} is serving, and that this client is on the same tailnet.`; + +/** Maps a tailscale CLI failure onto a reason the caller can act on. */ +const reasonForTailscaleError = ( + error: unknown, +): "tailscale-not-logged-in" | "tailscale-permission-denied" | "exposure-failed" => { + const diagnostic = + typeof error === "object" && error !== null && "stderrDiagnostic" in error + ? (error as { readonly stderrDiagnostic?: string }).stderrDiagnostic + : undefined; + if (diagnostic === "not-logged-in") return "tailscale-not-logged-in"; + if (diagnostic === "permission-denied") return "tailscale-permission-denied"; + return "exposure-failed"; +}; + +const originOf = (url: string): string => new URL(url).origin; + +export const make = Effect.gen(function* () { + const net = yield* Net.NetService; + const httpClient = yield* HttpClient.HttpClient; + // Captured once so the service's own signature stays free of process + // plumbing: callers ask for a reachable URL, not for a way to run tailscale. + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + + /** + * Serve ports this process published, so they can be withdrawn again. A + * mapping outlives the process that made it, so leaving them behind would + * keep publishing a port on the tailnet long after its dev server exited. + */ + const created = yield* Ref.make>(new Map()); + + const withdraw = (localPort: number, servePort: number) => + disableTailscaleServe({ servePort }).pipe( + Effect.tap(() => + Effect.logInfo("Withdrew preview tailnet mapping", { localPort, servePort }), + ), + Effect.catch((cause) => + Effect.logWarning("Failed to withdraw preview tailnet mapping", { + cause, + localPort, + servePort, + }), + ), + Effect.andThen( + Ref.update(created, (entries) => { + const next = new Map(entries); + next.delete(localPort); + return next; + }), + ), + ); + + /** + * Drops mappings whose dev server has since exited. Reconciling here rather + * than on a timer keeps the common path free of a background poller: a stale + * mapping is only observable through this service, and every observation + * passes through here first. + */ + const reconcile = Effect.gen(function* () { + const entries = yield* Ref.get(created); + for (const [localPort, servePort] of entries) { + if (yield* net.isPortAvailableOnLoopback(localPort)) { + yield* withdraw(localPort, servePort); + } + } + }); + + const fail = (port: number, reason: PreviewPortUnreachableError["reason"], remedy: string) => + Effect.fail(new PreviewPortUnreachableError({ port, reason, remedy })); + + // Any HTTP answer proves the route works. A dev server is free to 404 its own + // root (an API-only server does), and that is still reachable. + const probeOnce = (origin: string) => + httpClient + .execute(HttpClientRequest.get(origin)) + .pipe(Effect.timeout(PROBE_TIMEOUT), Effect.scoped, Effect.as(true)); + + /** One attempt — used to test a route that either already exists or does not. */ + const isReachable = (origin: string) => probeOnce(origin).pipe(Effect.orElseSucceed(() => false)); + + /** Resolves once a freshly published origin answers. */ + const becomesReachable = (origin: string) => + probeOnce(origin).pipe( + Effect.retry({ schedule: PROBE_SCHEDULE }), + Effect.timeout(PROBE_DEADLINE), + Effect.orElseSucceed(() => false), + ); + + const pickServePort = (port: number, mappings: readonly TailscaleServeMapping[]) => { + const takenBySomethingElse = (candidate: number) => + mappings.some((mapping) => mapping.servePort === candidate && mapping.localPort !== port); + if (!takenBySomethingElse(port)) return port; + const fallback = port + SERVE_PORT_FALLBACK_OFFSET; + if (fallback < 65_536 && !takenBySomethingElse(fallback)) return fallback; + return null; + }; + + const resolve = (request: PreviewPortResolveRequest) => + Effect.gen(function* () { + const { port } = request; + + // A client on the same machine reaches the port directly; publishing it + // on the tailnet would expose a dev server nobody asked to share. + const clientUrl = yield* Effect.try({ + try: () => new URL(request.clientBaseUrl), + catch: () => null, + }).pipe(Effect.orElseSucceed(() => null)); + if (clientUrl !== null && isLoopbackHost(clientUrl.hostname)) { + return { + origin: `http://localhost:${port}`, + strategy: "loopback", + createdExposure: false, + } satisfies PreviewPortResolution; + } + + yield* reconcile; + + if (yield* net.isPortAvailableOnLoopback(port)) { + return yield* fail(port, "not-listening", REMEDY_BY_REASON["not-listening"]); + } + + // Read the tailnet's routes before probing anything. A host without + // tailscale is not an error yet — the port may still answer directly — + // so a failure here only rules out the tailnet branch. + const mappings = yield* readTailscaleServeMappings.pipe( + Effect.catch((cause) => + Effect.logWarning("Failed to read tailnet serve mappings", { cause, port }).pipe( + Effect.as(null), + ), + ), + ); + + const existing = mappings && findRootServeMappingForLocalPort(mappings, port); + if (existing) { + return { + origin: originOf(existing.url), + strategy: "tailnet-serve", + createdExposure: false, + } satisfies PreviewPortResolution; + } + + // A dev server bound to a wildcard or interface address already answers on + // the environment's own address — WSL, a LAN, an SSH tunnel. Publishing a + // tailnet route for it would be redundant, so this is checked before any + // route is created. Verified rather than assumed: whether a listener is + // loopback-only is exactly what the old client-side guess got wrong. + // + // Skipped when a serve mapping already occupies that number for some other + // local port: the probe would find *that* app answering and hand back a URL + // to the wrong thing. + const shadowedByOtherMapping = + mappings?.some((mapping) => mapping.servePort === port && mapping.localPort !== port) ?? + false; + if (clientUrl !== null && !shadowedByOtherMapping) { + const directOrigin = `${clientUrl.protocol}//${clientUrl.hostname}:${port}`; + if (yield* isReachable(directOrigin)) { + return { + origin: directOrigin, + strategy: "direct-private-network", + createdExposure: false, + } satisfies PreviewPortResolution; + } + } + + if (mappings === null) { + return yield* fail( + port, + "tailscale-unavailable", + REMEDY_BY_REASON["tailscale-unavailable"], + ); + } + + const servePort = pickServePort(port, mappings); + if (servePort === null) { + return yield* fail(port, "serve-port-conflict", conflictRemedy(port, port)); + } + + yield* ensureTailscaleServe({ + localPort: port, + servePort, + localHost: SERVE_TARGET_HOST, + }).pipe( + Effect.catch((cause) => + Effect.logWarning("Failed to publish preview port on the tailnet", { + cause, + port, + servePort, + }).pipe(Effect.andThen(fail(port, reasonForTailscaleError(cause), exposureRemedy(port)))), + ), + ); + yield* Ref.update(created, (entries) => new Map(entries).set(port, servePort)); + + const published = yield* readTailscaleServeMappings.pipe( + Effect.map((refreshed) => findRootServeMappingForLocalPort(refreshed, port)), + Effect.orElseSucceed(() => undefined), + ); + if (!published) { + yield* withdraw(port, servePort); + return yield* fail(port, "exposure-failed", exposureRemedy(port)); + } + + const origin = originOf(published.url); + // Verify before answering: a URL that resolves but does not serve is the + // failure this whole path exists to remove. + if (!(yield* becomesReachable(origin))) { + yield* withdraw(port, servePort); + return yield* fail(port, "not-reachable", unreachableRemedy(port, origin)); + } + + yield* Effect.logInfo("Published preview port on the tailnet", { port, servePort, origin }); + return { + origin, + strategy: "tailnet-serve", + createdExposure: true, + } satisfies PreviewPortResolution; + }); + + yield* Effect.addFinalizer(() => + Effect.gen(function* () { + for (const [localPort, servePort] of yield* Ref.get(created)) { + yield* withdraw(localPort, servePort); + } + }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner)), + ); + + return PreviewPortExposure.of({ + resolve: (request) => + resolve(request).pipe( + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + ), + }); +}); + +export const layer = Layer.effect(PreviewPortExposure, make); diff --git a/apps/server/src/processRunner.test.ts b/apps/server/src/processRunner.test.ts index e264ba7849da..8a7267c6ec4b 100644 --- a/apps/server/src/processRunner.test.ts +++ b/apps/server/src/processRunner.test.ts @@ -19,6 +19,8 @@ type ChildProcessCommand = { readonly args: ReadonlyArray; readonly options: { readonly shell?: boolean | string; + readonly env?: NodeJS.ProcessEnv; + readonly extendEnv?: boolean; }; }; @@ -80,6 +82,24 @@ const runWith = ); describe("runProcess", () => { + it.effect("can launch with an exact non-extending environment", () => { + const environment = { PATH: "/project/bin", KEEP: "value" }; + const spawner = makeSpawner((command) => + Effect.sync(() => { + expect(command.options.env).toEqual(environment); + expect(command.options.extendEnv).toBe(false); + return makeHandle({ stdout: "ok" }); + }), + ); + + return runWith(spawner)({ + command: "/project/bin/direnv", + args: ["export", "json"], + env: environment, + extendEnv: false, + }); + }); + it.effect("collects stdout through an injected ChildProcessSpawner", () => Effect.gen(function* () { const spawner = makeSpawner((command) => diff --git a/apps/server/src/processRunner.ts b/apps/server/src/processRunner.ts index 25ed54e44fc6..3427849844f1 100644 --- a/apps/server/src/processRunner.ts +++ b/apps/server/src/processRunner.ts @@ -24,6 +24,7 @@ export interface ProcessRunInput { readonly spawnCwd?: string | undefined; readonly timeout?: Duration.Input | undefined; readonly env?: NodeJS.ProcessEnv | undefined; + readonly extendEnv?: boolean | undefined; readonly stdin?: string | undefined; readonly maxOutputBytes?: number | undefined; readonly outputMode?: "error" | "truncate" | undefined; @@ -290,7 +291,7 @@ const runProcessCore = Effect.fn("processRunner.runProcessCore")(function* ( const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES; const outputMode = input.outputMode ?? "error"; const truncatedMarker = input.truncatedMarker ?? ""; - const extendEnv = input.env !== undefined; + const extendEnv = input.env === undefined ? false : (input.extendEnv ?? true); const spawnCommand = yield* resolveSpawnCommand( input.command, input.args, diff --git a/apps/server/src/project/AgentSessionImporter.test.ts b/apps/server/src/project/AgentSessionImporter.test.ts index 4eb03a5cc036..efeb1c377c82 100644 --- a/apps/server/src/project/AgentSessionImporter.test.ts +++ b/apps/server/src/project/AgentSessionImporter.test.ts @@ -54,6 +54,7 @@ import * as ProviderSessionDirectory from "../provider/Services/ProviderSessionD import { makeAdapterRegistryMock } from "../provider/testUtils/providerAdapterRegistryMock.ts"; import { makeProviderRegistryLayer } from "../provider/testUtils/providerRegistryMock.ts"; import { ServerSettingsService } from "../serverSettings.ts"; +import * as IdentityService from "../identity/IdentityService.ts"; import * as AnalyticsService from "../telemetry/AnalyticsService.ts"; import { TextGeneration } from "../textGeneration/TextGeneration.ts"; import { VcsStatusBroadcaster } from "../vcs/VcsStatusBroadcaster.ts"; @@ -160,6 +161,8 @@ const makeProjectedThread = (input: { : []), ] : [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -575,7 +578,7 @@ const integrationLayer = Layer.mergeAll( Layer.provide(OrchestrationEventStoreLive), Layer.provide(OrchestrationCommandReceiptRepositoryLive), Layer.provide(RepositoryIdentityResolver.layer), - Layer.provide(SqlitePersistenceMemory), + Layer.provideMerge(SqlitePersistenceMemory), Layer.provideMerge(integrationServerConfig), Layer.provideMerge(NodeServices.layer), ); @@ -932,6 +935,7 @@ it.layer(integrationLayer)("AgentSessionImporter integration", (it) => { Layer.provide(Layer.mock(VcsStatusBroadcaster)({})), Layer.provide(Layer.mock(TextGeneration)({})), Layer.provide(ServerSettingsService.layerTest()), + Layer.provide(IdentityService.layerWithPeople([])), ); yield* engine.dispatch({ diff --git a/apps/server/src/project/AgentSessionScanner.test.ts b/apps/server/src/project/AgentSessionScanner.test.ts index c797eab6f550..76c4884c8114 100644 --- a/apps/server/src/project/AgentSessionScanner.test.ts +++ b/apps/server/src/project/AgentSessionScanner.test.ts @@ -62,6 +62,9 @@ const makeProjectionSnapshotQueryLayer = (importedWorkspaceRoots: ReadonlyArray< getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.die("unused"), + getSessionStopContextById: () => Effect.die("unused"), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), }); /** diff --git a/apps/server/src/project/ProjectLifecycleScriptRunner.test.ts b/apps/server/src/project/ProjectLifecycleScriptRunner.test.ts new file mode 100644 index 000000000000..6fee825b22a6 --- /dev/null +++ b/apps/server/src/project/ProjectLifecycleScriptRunner.test.ts @@ -0,0 +1,310 @@ +import { describe, expect, it, vi } from "@effect/vitest"; +import { type OrchestrationProject, ProjectId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import * as ProcessRunner from "../processRunner.ts"; +import * as ProjectLifecycleScriptRunner from "./ProjectLifecycleScriptRunner.ts"; + +const okProcessOutput = ( + overrides: Partial = {}, +): ProcessRunner.ProcessRunOutput => ({ + stdout: "", + stderr: "", + code: ChildProcessSpawner.ExitCode(0), + timedOut: false, + stdoutTruncated: false, + stderrTruncated: false, + stdoutInvalidUtf8: false, + stderrInvalidUtf8: false, + ...overrides, +}); + +const isLifecycleFailed = Schema.is(ProjectLifecycleScriptRunner.ProjectLifecycleScriptFailedError); + +const makeProject = (scripts: OrchestrationProject["scripts"]): OrchestrationProject => ({ + id: ProjectId.make("project-1"), + title: "Project", + workspaceRoot: "/repo/project", + defaultModelSelection: null, + scripts, + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + deletedAt: null, +}); + +const makeProjectionSnapshotQueryLayer = ( + project: OrchestrationProject | null, + options?: { readonly worktreePath?: string }, +) => + Layer.succeed(ProjectionSnapshotQuery.ProjectionSnapshotQuery, { + getUserInputActivity: () => Effect.die("unused"), + getCommandReadModel: () => Effect.die("unused"), + getThreadRuntimeContext: () => Effect.die("unused"), + getTurnStartMessage: () => Effect.die("unused"), + getThreadActivitiesPage: () => Effect.die("unused"), + getSnapshot: () => Effect.die("unused"), + getShellSnapshot: () => + Effect.succeed({ + snapshotSequence: 1, + projects: project ? [project] : [], + threads: + project && options?.worktreePath + ? [ + { + id: "thread-1" as never, + projectId: project.id, + title: "Thread", + modelSelection: { + instanceId: "codex" as never, + model: "gpt", + }, + runtimeMode: "full-access" as never, + interactionMode: "default" as never, + branch: null, + worktreePath: options.worktreePath, + pullRequests: [], + latestTurn: null, + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + archivedAt: null, + settledOverride: null, + settledAt: null, + session: null, + latestUserMessageAt: null, + hasPendingApprovals: false, + hasPendingUserInput: false, + hasActionableProposedPlan: false, + }, + ] + : [], + updatedAt: "2026-01-01T00:00:00.000Z", + }), + getArchivedShellSnapshot: () => Effect.die("unused"), + getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 1 }), + getCounts: () => Effect.die("unused"), + getActiveProjectByWorkspaceRoot: (workspaceRoot) => + Effect.succeed( + project && workspaceRoot === project.workspaceRoot ? Option.some(project) : Option.none(), + ), + getProjectShellById: (projectId) => + Effect.succeed(project && projectId === project.id ? Option.some(project) : Option.none()), + getFirstActiveThreadIdByProjectId: () => Effect.die("unused"), + getImportedAgentSessionSources: () => Effect.die("unused"), + getThreadCheckpointContext: () => Effect.die("unused"), + getFullThreadDiffContext: () => Effect.die("unused"), + getThreadShellById: () => Effect.die("unused"), + getSessionStopContextById: () => Effect.die("unused"), + getThreadDetailById: () => Effect.die("unused"), + getThreadDetailSnapshot: () => Effect.die("unused"), + searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.die("unused"), + getEventReplayStats: () => Effect.die("unused"), + }); + +const makeProcessRunnerLayer = (run: ProcessRunner.ProcessRunner["Service"]["run"]) => + Layer.succeed(ProcessRunner.ProcessRunner, { run }); + +const testLayer = ( + project: OrchestrationProject | null, + run: ProcessRunner.ProcessRunner["Service"]["run"], + options?: { readonly worktreePath?: string }, +) => + ProjectLifecycleScriptRunner.layer.pipe( + Layer.provideMerge(makeProjectionSnapshotQueryLayer(project, options)), + Layer.provideMerge(makeProcessRunnerLayer(run)), + ); + +describe("ProjectLifecycleScriptRunner", () => { + it.effect("returns no-script when no teardown script exists", () => { + const run = vi.fn(() => Effect.die("unexpected run")); + const project = makeProject([]); + + return Effect.gen(function* () { + const runner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + const result = yield* runner.runWorktreeRemove({ + projectCwd: "/repo/project", + worktreePath: "/repo/worktrees/a", + }); + expect(result).toEqual({ status: "no-script" }); + expect(run).not.toHaveBeenCalled(); + }).pipe(Effect.provide(testLayer(project, run))); + }); + + it.effect("returns no-script when no project can be resolved", () => { + const run = vi.fn(() => Effect.die("unexpected run")); + return Effect.gen(function* () { + const runner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + const result = yield* runner.runWorktreeRemove({ + projectCwd: "/missing", + worktreePath: "/repo/worktrees/a", + }); + expect(result).toEqual({ status: "no-script" }); + expect(run).not.toHaveBeenCalled(); + }).pipe(Effect.provide(testLayer(null, run))); + }); + + it.effect("runs the worktree-remove script and waits for a successful exit", () => { + const run = vi.fn(() => Effect.succeed(okProcessOutput({ stdout: "cleaned\n" }))); + const project = makeProject([ + { + id: "teardown", + name: "Teardown", + command: "echo cleaned", + icon: "configure", + runOnWorktreeCreate: false, + runOnWorktreeRemove: true, + }, + ]); + + return Effect.gen(function* () { + const runner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + const result = yield* runner.runWorktreeRemove({ + projectCwd: "/repo/project", + worktreePath: "/repo/worktrees/a", + }); + + expect(result).toMatchObject({ + status: "completed", + scriptId: "teardown", + scriptName: "Teardown", + lifecycle: "worktree-remove", + exitCode: 0, + }); + expect(run).toHaveBeenCalledWith( + expect.objectContaining({ + command: "sh", + args: ["-c", "echo cleaned"], + cwd: "/repo/worktrees/a", + env: expect.objectContaining({ + T3CODE_PROJECT_ROOT: "/repo/project", + T3CODE_WORKTREE_PATH: "/repo/worktrees/a", + T3CODE_LIFECYCLE: "worktree-remove", + }), + }), + ); + }).pipe(Effect.provide(testLayer(project, run))); + }); + + it.effect("fails when the lifecycle script exits non-zero", () => { + const run = vi.fn(() => + Effect.succeed( + okProcessOutput({ + stderr: "still running\n", + code: ChildProcessSpawner.ExitCode(2), + }), + ), + ); + const project = makeProject([ + { + id: "teardown", + name: "Teardown", + command: "exit 2", + icon: "configure", + runOnWorktreeCreate: false, + runOnWorktreeRemove: true, + }, + ]); + + return Effect.gen(function* () { + const runner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + const error = yield* runner + .runWorktreeRemove({ + projectCwd: "/repo/project", + worktreePath: "/repo/worktrees/a", + }) + .pipe(Effect.flip); + + expect(isLifecycleFailed(error)).toBe(true); + if (isLifecycleFailed(error)) { + expect(error.exitCode).toBe(2); + expect(error.scriptName).toBe("Teardown"); + expect(error.stderr).toContain("still running"); + } + }).pipe(Effect.provide(testLayer(project, run))); + }); + + it.effect("runs the pr-merged lifecycle script when requested", () => { + const run = vi.fn(() => Effect.succeed(okProcessOutput())); + const project = makeProject([ + { + id: "merged", + name: "On merge", + command: "echo reaped", + icon: "configure", + runOnWorktreeCreate: false, + runOnPrMerged: true, + }, + ]); + + return Effect.gen(function* () { + const runner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + const result = yield* runner.runPrMerged({ + projectCwd: "/repo/project", + worktreePath: "/repo/worktrees/a", + pr: { + number: 42, + url: "https://github.com/org/repo/pull/42", + title: "Ship it", + baseRef: "main", + headRef: "feature/x", + state: "merged", + }, + }); + expect(result.status).toBe("completed"); + expect(run).toHaveBeenCalledWith( + expect.objectContaining({ + env: expect.objectContaining({ + T3CODE_LIFECYCLE: "pr-merged", + T3CODE_PR: "https://github.com/org/repo/pull/42", + T3CODE_PR_NUMBER: "42", + T3CODE_PR_URL: "https://github.com/org/repo/pull/42", + T3CODE_PR_TITLE: "Ship it", + T3CODE_PR_BASE_REF: "main", + T3CODE_PR_HEAD_REF: "feature/x", + T3CODE_PR_STATE: "merged", + }), + }), + ); + }).pipe(Effect.provide(testLayer(project, run))); + }); + + it.effect( + "resolves the project via thread worktree path when cwd is not the workspace root", + () => { + const run = vi.fn(() => Effect.succeed(okProcessOutput())); + const project = makeProject([ + { + id: "merged", + name: "On merge", + command: "echo reaped", + icon: "configure", + runOnWorktreeCreate: false, + runOnPrMerged: true, + }, + ]); + const worktreePath = "/repo/worktrees/a"; + + return Effect.gen(function* () { + const runner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; + const result = yield* runner.runPrMerged({ + worktreePath, + }); + expect(result.status).toBe("completed"); + expect(run).toHaveBeenCalledWith( + expect.objectContaining({ + cwd: worktreePath, + env: expect.objectContaining({ + T3CODE_PROJECT_ROOT: "/repo/project", + T3CODE_WORKTREE_PATH: worktreePath, + }), + }), + ); + }).pipe(Effect.provide(testLayer(project, run, { worktreePath }))); + }, + ); +}); diff --git a/apps/server/src/project/ProjectLifecycleScriptRunner.ts b/apps/server/src/project/ProjectLifecycleScriptRunner.ts new file mode 100644 index 000000000000..0c15d8a644a1 --- /dev/null +++ b/apps/server/src/project/ProjectLifecycleScriptRunner.ts @@ -0,0 +1,271 @@ +/** + * ProjectLifecycleScriptRunner - runs blocking project lifecycle scripts + * (worktree remove / PR merged) via a real process, waiting for exit before + * the caller continues (e.g. `git worktree remove`). + * + * Unlike setup scripts (fire-and-forget in a terminal), teardown must finish + * and succeed before filesystem teardown proceeds. + * + * @module ProjectLifecycleScriptRunner + */ +import { type ProjectScript, ProjectId } from "@t3tools/contracts"; +import { + prMergedProjectScript, + projectLifecycleRuntimeEnv, + type ProjectLifecycleKind, + type ProjectLifecyclePrAssociation, + worktreeRemoveProjectScript, +} from "@t3tools/shared/projectScripts"; +import { HostProcessEnvironment, HostProcessPlatform } from "@t3tools/shared/hostProcess"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; + +import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import * as ProcessRunner from "../processRunner.ts"; + +const LIFECYCLE_SCRIPT_TIMEOUT = "10 minutes"; +const LIFECYCLE_SCRIPT_MAX_OUTPUT_BYTES = 1_024 * 1_024; + +export interface ProjectLifecycleScriptRunnerResultNoScript { + readonly status: "no-script"; +} + +export interface ProjectLifecycleScriptRunnerResultCompleted { + readonly status: "completed"; + readonly scriptId: string; + readonly scriptName: string; + readonly lifecycle: ProjectLifecycleKind; + readonly exitCode: number | null; + readonly stdout: string; + readonly stderr: string; +} + +export type ProjectLifecycleScriptRunnerResult = + | ProjectLifecycleScriptRunnerResultNoScript + | ProjectLifecycleScriptRunnerResultCompleted; + +export interface ProjectLifecycleScriptRunnerInput { + readonly projectId?: string; + readonly projectCwd?: string; + readonly worktreePath: string; + /** Linked/associated PR or MR for this lifecycle run, when known. */ + readonly pr?: ProjectLifecyclePrAssociation | null; +} + +export class ProjectLifecycleScriptOperationError extends Schema.TaggedError()( + "ProjectLifecycleScriptOperationError", + { + lifecycle: Schema.Literals(["worktree-remove", "pr-merged"]), + projectId: Schema.optional(Schema.String), + projectCwd: Schema.optional(Schema.String), + worktreePath: Schema.String, + operation: Schema.Literals(["resolveProject", "runScript"]), + cause: Schema.Defect(), + }, +) { + override get message(): string { + return `Project lifecycle script operation '${this.operation}' failed for '${this.lifecycle}' in '${this.worktreePath}'.`; + } +} + +export class ProjectLifecycleScriptFailedError extends Schema.TaggedError()( + "ProjectLifecycleScriptFailedError", + { + lifecycle: Schema.Literals(["worktree-remove", "pr-merged"]), + projectId: Schema.optional(Schema.String), + projectCwd: Schema.optional(Schema.String), + worktreePath: Schema.String, + scriptId: Schema.String, + scriptName: Schema.String, + exitCode: Schema.NullOr(Schema.Number), + timedOut: Schema.Boolean, + stdout: Schema.String, + stderr: Schema.String, + }, +) { + override get message(): string { + if (this.timedOut) { + return `Lifecycle script '${this.scriptName}' (${this.lifecycle}) timed out in '${this.worktreePath}'.`; + } + const code = this.exitCode === null ? "unknown" : String(this.exitCode); + return `Lifecycle script '${this.scriptName}' (${this.lifecycle}) exited with code ${code} in '${this.worktreePath}'.`; + } +} + +export const ProjectLifecycleScriptRunnerError = Schema.Union([ + ProjectLifecycleScriptOperationError, + ProjectLifecycleScriptFailedError, +]); +export type ProjectLifecycleScriptRunnerError = typeof ProjectLifecycleScriptRunnerError.Type; + +export class ProjectLifecycleScriptRunner extends Context.Service< + ProjectLifecycleScriptRunner, + { + readonly runWorktreeRemove: ( + input: ProjectLifecycleScriptRunnerInput, + ) => Effect.Effect; + readonly runPrMerged: ( + input: ProjectLifecycleScriptRunnerInput, + ) => Effect.Effect; + } +>()("t3/project/ProjectLifecycleScriptRunner") {} + +const selectScript = ( + lifecycle: ProjectLifecycleKind, + scripts: readonly ProjectScript[], +): ProjectScript | null => + lifecycle === "worktree-remove" + ? worktreeRemoveProjectScript(scripts) + : prMergedProjectScript(scripts); + +export const make = Effect.gen(function* () { + const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery; + const processRunner = yield* ProcessRunner.ProcessRunner; + const platform = yield* HostProcessPlatform; + const hostEnvironment = yield* HostProcessEnvironment; + + const resolveProject = Effect.fn("ProjectLifecycleScriptRunner.resolveProject")(function* ( + input: ProjectLifecycleScriptRunnerInput, + lifecycle: ProjectLifecycleKind, + ) { + const errorContext = { + lifecycle, + worktreePath: input.worktreePath, + ...(input.projectId === undefined ? {} : { projectId: input.projectId }), + ...(input.projectCwd === undefined ? {} : { projectCwd: input.projectCwd }), + }; + const mapResolveError = (cause: unknown) => + new ProjectLifecycleScriptOperationError({ + ...errorContext, + operation: "resolveProject", + cause, + }); + + if (input.projectId) { + const projectById = yield* projectionSnapshotQuery + .getProjectShellById(ProjectId.make(input.projectId)) + .pipe(Effect.map(Option.getOrUndefined), Effect.mapError(mapResolveError)); + if (projectById) { + return projectById; + } + } + + const candidateRoots = [input.projectCwd, input.worktreePath].filter( + (value): value is string => typeof value === "string" && value.length > 0, + ); + for (const root of candidateRoots) { + const projectByRoot = yield* projectionSnapshotQuery + .getActiveProjectByWorkspaceRoot(root) + .pipe(Effect.map(Option.getOrUndefined), Effect.mapError(mapResolveError)); + if (projectByRoot) { + return projectByRoot; + } + } + + // Status cwd is often a worktree path that is not the project workspace root. + // Resolve via thread shells that link this path. + const shell = yield* projectionSnapshotQuery + .getShellSnapshot() + .pipe(Effect.mapError(mapResolveError)); + const thread = shell.threads.find( + (entry) => entry.worktreePath !== null && entry.worktreePath === input.worktreePath, + ); + if (!thread) { + return null; + } + return ( + shell.projects.find((project) => project.id === thread.projectId) ?? + (yield* projectionSnapshotQuery + .getProjectShellById(thread.projectId) + .pipe(Effect.map(Option.getOrUndefined), Effect.mapError(mapResolveError))) + ); + }); + + const runLifecycle = Effect.fn("ProjectLifecycleScriptRunner.runLifecycle")(function* ( + input: ProjectLifecycleScriptRunnerInput, + lifecycle: ProjectLifecycleKind, + ) { + const errorContext = { + lifecycle, + worktreePath: input.worktreePath, + ...(input.projectId === undefined ? {} : { projectId: input.projectId }), + ...(input.projectCwd === undefined ? {} : { projectCwd: input.projectCwd }), + }; + + const project = yield* resolveProject(input, lifecycle); + if (!project) { + // Bare VCS removes (no T3 project) skip lifecycle scripts rather than failing. + return { status: "no-script" } as const; + } + const script = selectScript(lifecycle, project.scripts); + if (!script) { + return { status: "no-script" } as const; + } + + const lifecycleEnv = projectLifecycleRuntimeEnv({ + project: { cwd: project.workspaceRoot }, + worktreePath: input.worktreePath, + lifecycle, + pr: input.pr ?? null, + }); + const env: NodeJS.ProcessEnv = { + ...hostEnvironment, + ...lifecycleEnv, + }; + + const isWindows = platform === "win32"; + const output = yield* processRunner + .run({ + command: isWindows ? "cmd.exe" : "sh", + args: isWindows ? ["/d", "/s", "/c", script.command] : ["-c", script.command], + cwd: input.worktreePath, + env, + timeout: LIFECYCLE_SCRIPT_TIMEOUT, + outputMode: "truncate", + maxOutputBytes: LIFECYCLE_SCRIPT_MAX_OUTPUT_BYTES, + truncatedMarker: "\n…[truncated]\n", + }) + .pipe( + Effect.mapError( + (cause) => + new ProjectLifecycleScriptOperationError({ + ...errorContext, + operation: "runScript", + cause, + }), + ), + ); + + if (output.timedOut || output.code === null || output.code !== 0) { + return yield* new ProjectLifecycleScriptFailedError({ + ...errorContext, + scriptId: script.id, + scriptName: script.name, + exitCode: output.code, + timedOut: output.timedOut, + stdout: output.stdout, + stderr: output.stderr, + }); + } + + return { + status: "completed", + scriptId: script.id, + scriptName: script.name, + lifecycle, + exitCode: output.code, + stdout: output.stdout, + stderr: output.stderr, + } as const; + }); + + return ProjectLifecycleScriptRunner.of({ + runWorktreeRemove: (input) => runLifecycle(input, "worktree-remove"), + runPrMerged: (input) => runLifecycle(input, "pr-merged"), + }); +}); + +export const layer = Layer.effect(ProjectLifecycleScriptRunner, make); diff --git a/apps/server/src/project/ProjectSetupScriptRunner.test.ts b/apps/server/src/project/ProjectSetupScriptRunner.test.ts index 3a8c3ad71e69..38c50254f128 100644 --- a/apps/server/src/project/ProjectSetupScriptRunner.test.ts +++ b/apps/server/src/project/ProjectSetupScriptRunner.test.ts @@ -29,6 +29,7 @@ const makeProjectionSnapshotQueryLayer = (project: OrchestrationProject) => Layer.succeed(ProjectionSnapshotQuery.ProjectionSnapshotQuery, { getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("unused"), + getThreadActivitiesPage: () => Effect.die("unused"), getSnapshot: () => Effect.die("unused"), getShellSnapshot: () => Effect.die("unused"), getArchivedShellSnapshot: () => Effect.die("unused"), @@ -48,9 +49,11 @@ const makeProjectionSnapshotQueryLayer = (project: OrchestrationProject) => getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.die("unused"), + getSessionStopContextById: () => Effect.die("unused"), getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadLifecycleById: () => Effect.die("unused"), }); const makeTerminalManagerLayer = ( diff --git a/apps/server/src/project/RepositoryIdentityResolver.test.ts b/apps/server/src/project/RepositoryIdentityResolver.test.ts index ac1cbfb44d0e..7bff6a2884f3 100644 --- a/apps/server/src/project/RepositoryIdentityResolver.test.ts +++ b/apps/server/src/project/RepositoryIdentityResolver.test.ts @@ -245,6 +245,35 @@ it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => { }).pipe(Effect.provide(RepositoryIdentityResolver.layer)), ); + it.effect("reports every configured remote, not just the primary one", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const cwd = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-repository-identity-all-remotes-test-", + }); + + yield* git(cwd, ["init"]); + yield* git(cwd, ["remote", "add", "origin", "git@github.com:example-user/example-repo.git"]); + yield* git(cwd, ["remote", "add", "upstream", "git@github.com:T3Tools/t3code.git"]); + + const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver; + const identity = yield* resolver.resolve(cwd); + + expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code"); + expect( + identity?.remotes?.map((remote) => [remote.remoteName, remote.canonicalKey]).toSorted(), + ).toEqual([ + ["origin", "github.com/example-user/example-repo"], + ["upstream", "github.com/t3tools/t3code"], + ]); + expect(identity?.remotes?.every((remote) => remote.provider === "github")).toBe(true); + expect(identity?.remotes?.find((remote) => remote.remoteName === "origin")).toMatchObject({ + owner: "example-user", + name: "example-repo", + }); + }).pipe(Effect.provide(RepositoryIdentityResolver.layer)), + ); + it.effect("uses the last remote path segment as the repository name for nested groups", () => Effect.gen(function* () { const fileSystem = yield* FileSystem.FileSystem; diff --git a/apps/server/src/project/RepositoryIdentityResolver.ts b/apps/server/src/project/RepositoryIdentityResolver.ts index 755008f6ded1..159d369eb7d3 100644 --- a/apps/server/src/project/RepositoryIdentityResolver.ts +++ b/apps/server/src/project/RepositoryIdentityResolver.ts @@ -1,4 +1,4 @@ -import type { RepositoryIdentity } from "@t3tools/contracts"; +import type { RepositoryIdentity, RepositoryIdentityRemote } from "@t3tools/contracts"; import { detectSourceControlProviderFromGitRemoteUrl, normalizeGitRemoteUrl, @@ -63,30 +63,56 @@ function pickPrimaryRemote( return remoteName && remoteUrl ? { remoteName, remoteUrl } : null; } -function buildRepositoryIdentity(input: { +function repositoryPathOf(canonicalKey: string): string { + return canonicalKey.split("/").slice(1).join("/"); +} + +function describeRemote(input: { readonly remoteName: string; readonly remoteUrl: string; - readonly rootPath: string; -}): RepositoryIdentity { +}): RepositoryIdentityRemote { const canonicalKey = normalizeGitRemoteUrl(input.remoteUrl); const sourceControlProvider = detectSourceControlProviderFromGitRemoteUrl(input.remoteUrl); - const repositoryPath = canonicalKey.split("/").slice(1).join("/"); - const repositoryPathSegments = repositoryPath.split("/").filter((segment) => segment.length > 0); + const repositoryPathSegments = repositoryPathOf(canonicalKey) + .split("/") + .filter((segment) => segment.length > 0); const [owner] = repositoryPathSegments; const repositoryName = repositoryPathSegments.at(-1); return { + remoteName: input.remoteName, + remoteUrl: input.remoteUrl, canonicalKey, + ...(sourceControlProvider ? { provider: sourceControlProvider.kind } : {}), + ...(owner ? { owner } : {}), + ...(repositoryName ? { name: repositoryName } : {}), + }; +} + +function buildRepositoryIdentity(input: { + readonly remoteName: string; + readonly remoteUrl: string; + readonly rootPath: string; + readonly remotes: ReadonlyMap; +}): RepositoryIdentity { + const primary = describeRemote(input); + const repositoryPath = repositoryPathOf(primary.canonicalKey); + + return { + canonicalKey: primary.canonicalKey, locator: { source: "git-remote", - remoteName: input.remoteName, - remoteUrl: input.remoteUrl, + remoteName: primary.remoteName, + remoteUrl: primary.remoteUrl, }, rootPath: input.rootPath, ...(repositoryPath ? { displayName: repositoryPath } : {}), - ...(sourceControlProvider ? { provider: sourceControlProvider.kind } : {}), - ...(owner ? { owner } : {}), - ...(repositoryName ? { name: repositoryName } : {}), + ...(primary.provider ? { provider: primary.provider } : {}), + ...(primary.owner ? { owner: primary.owner } : {}), + ...(primary.name ? { name: primary.name } : {}), + remotes: [...input.remotes].map(([remoteName, remoteUrl]) => + describeRemote({ remoteName, remoteUrl }), + ), }; } @@ -129,8 +155,9 @@ const resolveRepositoryIdentityFromCacheKey = Effect.fn( return null; } - const remote = pickPrimaryRemote(parseRemoteFetchUrls(remoteResult.value.stdout)); - return remote ? buildRepositoryIdentity({ ...remote, rootPath: cacheKey }) : null; + const remotes = parseRemoteFetchUrls(remoteResult.value.stdout); + const remote = pickPrimaryRemote(remotes); + return remote ? buildRepositoryIdentity({ ...remote, rootPath: cacheKey, remotes }) : null; }); export const make = Effect.fn("RepositoryIdentityResolver.make")(function* ( diff --git a/apps/server/src/provider/DirenvEnvironment.test.ts b/apps/server/src/provider/DirenvEnvironment.test.ts new file mode 100644 index 000000000000..809896857918 --- /dev/null +++ b/apps/server/src/provider/DirenvEnvironment.test.ts @@ -0,0 +1,238 @@ +import { describe, expect, it, vi } from "@effect/vitest"; +import { NodeServices } from "@effect/platform-node"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; +import { ChildProcessSpawner } from "effect/unstable/process"; + +import * as ProcessRunner from "../processRunner.ts"; +import { DirenvEnvironment, DirenvEnvironmentError, layer } from "./DirenvEnvironment.ts"; + +const successfulOutput = ( + stdout: string, + stderr = "", + code = 0, +): ProcessRunner.ProcessRunOutput => ({ + stdout, + stderr, + code: ChildProcessSpawner.ExitCode(code), + timedOut: false, + stdoutTruncated: false, + stderrTruncated: false, + stdoutInvalidUtf8: false, + stderrInvalidUtf8: false, +}); + +function testLayer(run: ProcessRunner.ProcessRunner["Service"]["run"]) { + return layer.pipe( + Layer.provide(Layer.succeed(ProcessRunner.ProcessRunner, { run })), + Layer.provideMerge(NodeServices.layer), + ); +} + +const makeDirenvExecutable = Effect.fn("makeDirenvExecutable")(function* (directory: string) { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const binDirectory = path.join(directory, "bin"); + const executable = path.join(binDirectory, "direnv"); + yield* fileSystem.makeDirectory(binDirectory, { recursive: true }); + yield* fileSystem.writeFileString(executable, "#!/bin/sh\nexit 0\n"); + yield* fileSystem.chmod(executable, 0o755); + return { binDirectory, executable }; +}); + +/** A temp project with an `.envrc` and a fake direnv on PATH. */ +const setupDirenvProject = Effect.fn("setupDirenvProject")(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-direnv-" }); + const envrcPath = path.join(cwd, ".envrc"); + yield* fileSystem.writeFileString(envrcPath, "export VALUE=next\n"); + const { binDirectory, executable } = yield* makeDirenvExecutable(cwd); + return { cwd, envrcPath, binDirectory, executable }; +}); + +describe("DirenvEnvironment", () => { + describe("new worktree approval", () => { + it.effect("approves the exact .envrc in a newly created worktree", () => { + const run = vi.fn(() => + Effect.succeed(successfulOutput("")), + ); + return Effect.gen(function* () { + const { cwd, envrcPath, binDirectory, executable } = yield* setupDirenvProject(); + const environment = { PATH: binDirectory, KEEP: "value" }; + const direnvEnvironment = yield* DirenvEnvironment; + + yield* direnvEnvironment.allow({ cwd, environment }); + + expect(run).toHaveBeenCalledOnce(); + expect(run.mock.calls[0]?.[0]).toMatchObject({ + command: executable, + args: ["allow", envrcPath], + cwd, + env: environment, + extendEnv: false, + }); + }).pipe(Effect.provide(testLayer(run))); + }); + + it.effect("does not approve an ancestor .envrc outside the new worktree", () => { + const run = vi.fn(); + return Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const parent = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-direnv-worktree-parent-", + }); + const cwd = path.join(parent, "worktree"); + yield* fileSystem.makeDirectory(cwd); + yield* fileSystem.writeFileString(path.join(parent, ".envrc"), "export VALUE=parent\n"); + const direnvEnvironment = yield* DirenvEnvironment; + + yield* direnvEnvironment.allow({ cwd, environment: { PATH: "/not-used" } }); + + expect(run).not.toHaveBeenCalled(); + }).pipe(Effect.provide(testLayer(run))); + }); + }); + + it.effect( + "returns the environment unchanged without inspecting PATH when no .envrc exists", + () => { + const run = vi.fn(); + return Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-direnv-none-" }); + const environment = { PATH: "/not-used", KEEP: "value" }; + const resolver = yield* DirenvEnvironment; + + expect(yield* resolver.resolve({ cwd, environment })).toBe(environment); + expect(run).not.toHaveBeenCalled(); + }).pipe(Effect.provide(testLayer(run))); + }, + ); + + it.effect("discovers a parent-directory .envrc and runs direnv in the requested cwd", () => { + const run = vi.fn(() => + Effect.succeed(successfulOutput("{}")), + ); + return Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-direnv-parent-" }); + const cwd = path.join(root, "nested", "project"); + yield* fileSystem.makeDirectory(cwd, { recursive: true }); + yield* fileSystem.writeFileString(path.join(root, ".envrc"), "export PROJECT=parent\n"); + const { binDirectory, executable } = yield* makeDirenvExecutable(root); + const environment = { PATH: binDirectory }; + const resolver = yield* DirenvEnvironment; + + expect(yield* resolver.resolve({ cwd, environment })).toEqual(environment); + expect(run).toHaveBeenCalledOnce(); + expect(run.mock.calls[0]?.[0]).toMatchObject({ + command: executable, + args: ["export", "json"], + cwd, + env: environment, + extendEnv: false, + }); + }).pipe(Effect.provide(testLayer(run))); + }); + + it.effect( + "returns the environment unchanged when .envrc exists but direnv is unavailable", + () => { + const run = vi.fn(); + return Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-direnv-missing-" }); + yield* fileSystem.writeFileString(path.join(cwd, ".envrc"), "export VALUE=next\n"); + const environment = { PATH: "", KEEP: "value" }; + const resolver = yield* DirenvEnvironment; + + expect(yield* resolver.resolve({ cwd, environment })).toBe(environment); + expect(run).not.toHaveBeenCalled(); + }).pipe(Effect.provide(testLayer(run))); + }, + ); + + it.effect("applies additions, overrides, and removals from a successful export", () => { + const run = vi.fn(() => + Effect.succeed( + successfulOutput(JSON.stringify({ ADDED: "new", OVERRIDDEN: "direnv", REMOVED: null })), + ), + ); + return Effect.gen(function* () { + const { cwd, binDirectory } = yield* setupDirenvProject(); + const resolver = yield* DirenvEnvironment; + + expect( + yield* resolver.resolve({ + cwd, + environment: { + PATH: binDirectory, + OVERRIDDEN: "provider-instance", + REMOVED: "host", + PRESERVED: "yes", + }, + }), + ).toEqual({ + PATH: binDirectory, + ADDED: "new", + OVERRIDDEN: "direnv", + PRESERVED: "yes", + }); + }).pipe(Effect.provide(testLayer(run))); + }); + + it.effect("returns actionable stderr for a blocked .envrc", () => { + const run = vi.fn(() => + Effect.succeed( + successfulOutput( + "", + "secret-environment-value: .envrc is blocked. Run `direnv allow` to approve", + 1, + ), + ), + ); + return Effect.gen(function* () { + const { cwd, binDirectory } = yield* setupDirenvProject(); + const resolver = yield* DirenvEnvironment; + const error = yield* resolver + .resolve({ + cwd, + environment: { PATH: binDirectory, SECRET: "secret-environment-value" }, + }) + .pipe(Effect.flip); + + expect(error).toBeInstanceOf(DirenvEnvironmentError); + expect(error.stage).toBe("execution"); + expect(error.message).toContain("direnv allow"); + expect(error.message).not.toContain("secret-environment-value"); + }).pipe(Effect.provide(testLayer(run))); + }); + + it.effect("rejects malformed or structurally invalid output without exposing stdout", () => { + let stdout = ""; + const run = vi.fn(() => + Effect.succeed(successfulOutput(stdout)), + ); + return Effect.gen(function* () { + const { cwd, binDirectory } = yield* setupDirenvProject(); + const resolver = yield* DirenvEnvironment; + + for (const rawStdout of ["not-json secret-value", '{"SAFE":"value","INVALID":42}']) { + stdout = rawStdout; + const error = yield* resolver + .resolve({ cwd, environment: { PATH: binDirectory } }) + .pipe(Effect.flip); + + expect(error.stage).toBe("invalid-output"); + expect(error.message).not.toContain(rawStdout); + expect(error.cause).toBeUndefined(); + } + }).pipe(Effect.provide(testLayer(run))); + }); +}); diff --git a/apps/server/src/provider/DirenvEnvironment.ts b/apps/server/src/provider/DirenvEnvironment.ts new file mode 100644 index 000000000000..9fae5cd9b0fe --- /dev/null +++ b/apps/server/src/provider/DirenvEnvironment.ts @@ -0,0 +1,249 @@ +import { resolveCommandPath } from "@t3tools/shared/shell"; +import { decodeJsonResult } from "@t3tools/shared/schemaJson"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; +import * as Result from "effect/Result"; +import * as Schema from "effect/Schema"; + +import * as ProcessRunner from "../processRunner.ts"; +import { ProviderAdapterProcessError } from "./Errors.ts"; + +const DIRENV_MAX_OUTPUT_BYTES = 64 * 1024; +const DIRENV_TIMEOUT = "30 seconds"; +const STDERR_DETAIL_MAX_LENGTH = 2_048; +// `decodeJsonResult` diagnostics deliberately exclude the raw values, so a +// failure here never leaks direnv stdout across process and UI boundaries. +const decodeDirenvPatch = decodeJsonResult( + Schema.Record(Schema.String, Schema.NullOr(Schema.String)), +); + +export class DirenvEnvironmentError extends Schema.TaggedError()( + "DirenvEnvironmentError", + { + stage: Schema.Literals(["inspection", "execution", "invalid-output"]), + detail: Schema.String, + cause: Schema.optional(Schema.Defect()), + }, +) { + override get message(): string { + return `Failed to resolve direnv environment during ${this.stage}: ${this.detail}`; + } +} + +export class DirenvEnvironment extends Context.Service< + DirenvEnvironment, + { + readonly allow: (input: { + readonly cwd: string; + readonly environment: NodeJS.ProcessEnv; + }) => Effect.Effect; + readonly resolve: (input: { + readonly cwd: string; + readonly environment: NodeJS.ProcessEnv; + }) => Effect.Effect; + } +>()("t3/provider/DirenvEnvironment") {} + +export const identityDirenvEnvironmentResolver: DirenvEnvironment["Service"]["resolve"] = (input) => + Effect.succeed(input.environment); + +export const noopDirenvEnvironmentAllow: DirenvEnvironment["Service"]["allow"] = () => Effect.void; + +/** + * Resolves a provider session environment through the optional direnv + * resolver, mapping failures into the adapter error domain. Adapters that + * are constructed without a resolver (tests) keep the base environment. + */ +export const resolveProviderSessionEnvironment = (input: { + readonly resolve: DirenvEnvironment["Service"]["resolve"] | undefined; + readonly provider: string; + readonly threadId: string; + readonly cwd: string; + readonly environment: NodeJS.ProcessEnv; +}): Effect.Effect => + input.resolve === undefined + ? Effect.succeed(input.environment) + : input.resolve({ cwd: input.cwd, environment: input.environment }).pipe( + Effect.mapError( + (cause) => + new ProviderAdapterProcessError({ + provider: input.provider, + threadId: input.threadId, + detail: cause.message, + cause, + }), + ), + ); + +function conciseStderr(stderr: string, environment: NodeJS.ProcessEnv): string | undefined { + let redacted = stderr; + const environmentValues = Array.from( + new Set( + Object.values(environment).filter( + (value): value is string => typeof value === "string" && value.length >= 4, + ), + ), + ).sort((left, right) => right.length - left.length); + for (const value of environmentValues) { + redacted = redacted.split(value).join("[redacted]"); + } + + const normalized = redacted.replace(/\s+/g, " ").trim(); + if (normalized.length === 0) return undefined; + if (normalized.length <= STDERR_DETAIL_MAX_LENGTH) return normalized; + return `${normalized.slice(0, STDERR_DETAIL_MAX_LENGTH)}…`; +} + +export const make = Effect.fn("DirenvEnvironment.make")(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const processRunner = yield* ProcessRunner.ProcessRunner; + + const envrcExists = (candidate: string) => + fileSystem.exists(candidate).pipe( + Effect.mapError( + (cause) => + new DirenvEnvironmentError({ + stage: "inspection", + detail: `Could not inspect '${candidate}'.`, + cause, + }), + ), + ); + + // Cached per PATH value for the lifetime of the service: sessions in the + // same environment would otherwise re-scan PATH on every start. + const direnvPathCache = new Map(); + const findDirenv = Effect.fn("DirenvEnvironment.findDirenv")(function* ( + environment: NodeJS.ProcessEnv, + ) { + const cacheKey = environment.PATH ?? ""; + if (direnvPathCache.has(cacheKey)) return direnvPathCache.get(cacheKey); + const direnvPath = yield* resolveCommandPath("direnv", { env: environment }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + Effect.catchTag("CommandResolutionError", () => Effect.void), + ); + direnvPathCache.set(cacheKey, direnvPath ?? undefined); + return direnvPath ?? undefined; + }); + + /** Runs direnv, or returns `undefined` when direnv is not installed. */ + const runDirenv = Effect.fn("DirenvEnvironment.runDirenv")(function* (input: { + readonly commandLabel: string; + readonly args: ReadonlyArray; + readonly cwd: string; + readonly environment: NodeJS.ProcessEnv; + }) { + const direnvPath = yield* findDirenv(input.environment); + if (direnvPath === undefined) return undefined; + + const output = yield* processRunner + .run({ + command: direnvPath, + args: input.args, + cwd: input.cwd, + env: input.environment, + extendEnv: false, + maxOutputBytes: DIRENV_MAX_OUTPUT_BYTES, + timeout: DIRENV_TIMEOUT, + }) + .pipe( + Effect.mapError( + (cause) => + new DirenvEnvironmentError({ + stage: "execution", + detail: `Could not execute ${input.commandLabel}.`, + cause, + }), + ), + ); + + if (output.code !== 0) { + const stderr = conciseStderr(output.stderr, input.environment); + return yield* new DirenvEnvironmentError({ + stage: "execution", + detail: stderr + ? `${input.commandLabel} exited unsuccessfully: ${stderr}` + : `${input.commandLabel} exited unsuccessfully.`, + }); + } + return output; + }); + + /** Approves only the `.envrc` at the root of a worktree T3 just created. */ + const allow: DirenvEnvironment["Service"]["allow"] = Effect.fn("DirenvEnvironment.allow")( + function* (input) { + const cwd = path.resolve(input.cwd); + const envrcPath = path.join(cwd, ".envrc"); + if (!(yield* envrcExists(envrcPath))) return; + yield* runDirenv({ + commandLabel: "direnv allow", + args: ["allow", envrcPath], + cwd, + environment: input.environment, + }); + }, + ); + + const findNearestEnvrc = Effect.fn("DirenvEnvironment.findNearestEnvrc")(function* ( + cwd: string, + ): Effect.fn.Return { + let directory = path.resolve(cwd); + while (true) { + const candidate = path.join(directory, ".envrc"); + if (yield* envrcExists(candidate)) return candidate; + + const parent = path.dirname(directory); + if (parent === directory) return undefined; + directory = parent; + } + }); + + const resolve: DirenvEnvironment["Service"]["resolve"] = Effect.fn("DirenvEnvironment.resolve")( + function* (input) { + const envrcPath = yield* findNearestEnvrc(input.cwd); + if (envrcPath === undefined) return input.environment; + + const output = yield* runDirenv({ + commandLabel: "direnv", + args: ["export", "json"], + cwd: input.cwd, + environment: input.environment, + }); + if (output === undefined) return input.environment; + + const decoded = decodeDirenvPatch(output.stdout); + if (Result.isFailure(decoded)) { + return yield* new DirenvEnvironmentError({ + stage: "invalid-output", + detail: "direnv returned an invalid environment patch.", + }); + } + + const resolvedEnvironment = { ...input.environment }; + for (const [name, value] of Object.entries(decoded.success)) { + if (value === null) { + delete resolvedEnvironment[name]; + } else { + resolvedEnvironment[name] = value; + } + } + return resolvedEnvironment; + }, + ); + + return DirenvEnvironment.of({ allow, resolve }); +}); + +export const layer = Layer.effect(DirenvEnvironment, make()); + +export const layerLive = layer.pipe(Layer.provide(ProcessRunner.layer)); + +export const layerNoop = Layer.succeed(DirenvEnvironment, { + allow: noopDirenvEnvironmentAllow, + resolve: identityDirenvEnvironmentResolver, +}); diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index 324284a3a4c7..9f5fd05f5627 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -28,6 +28,7 @@ import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; import { ServerConfig } from "../../config.ts"; import { expandHomePath } from "../../pathExpansion.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; +import { DirenvEnvironment } from "../DirenvEnvironment.ts"; import { ProviderDriverError } from "../Errors.ts"; import { makeClaudeAdapter } from "../Layers/ClaudeAdapter.ts"; import { makeClaudeScopedLimitNames } from "../Layers/claudeUsageLimits.ts"; @@ -88,6 +89,7 @@ export type ClaudeDriverEnv = | BackgroundPolicy.BackgroundPolicy | ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto + | DirenvEnvironment | FileSystem.FileSystem | HttpClient.HttpClient | ModelManifest.ModelManifest @@ -113,6 +115,7 @@ export const ClaudeDriver: ProviderDriver = { const httpClient = yield* HttpClient.HttpClient; const serverSettings = yield* ServerSettingsService; const eventLoggers = yield* ProviderEventLoggers; + const direnvEnvironment = yield* DirenvEnvironment; const modelManifest = yield* ModelManifest.ModelManifest; const modelCatalog = modelManifest.current.pipe(Effect.map(resolveClaudeModelCatalog)); const processEnv = mergeProviderInstanceEnvironment(environment); @@ -150,6 +153,7 @@ export const ClaudeDriver: ProviderDriver = { const adapterOptions = { instanceId, environment: processEnv, + resolveEnvironment: direnvEnvironment.resolve, modelCatalog, scopedLimitNames, ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), diff --git a/apps/server/src/provider/Drivers/CodexDriver.test.ts b/apps/server/src/provider/Drivers/CodexDriver.test.ts index bac34db452fd..e819dad8d588 100644 --- a/apps/server/src/provider/Drivers/CodexDriver.test.ts +++ b/apps/server/src/provider/Drivers/CodexDriver.test.ts @@ -20,6 +20,7 @@ import { ServerSettingsService } from "../../serverSettings.ts"; import { layerTest as codexResetCreditLayerTest } from "../Layers/codexResetCredit.ts"; import { NoOpProviderEventLoggers, ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts"; import * as ModelManifest from "../ModelManifest.ts"; +import * as DirenvEnvironment from "../DirenvEnvironment.ts"; import { createProviderVersionAdvisory, ProviderVersionCache, @@ -31,6 +32,7 @@ const testLayer = ServerConfig.layerTest(process.cwd(), { prefix: "t3-codex-driver-maintenance-", }).pipe( Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(DirenvEnvironment.layerNoop), Layer.provideMerge(ServerSettingsService.layerTest()), Layer.provideMerge(ModelManifest.layerTest), Layer.provideMerge(codexResetCreditLayerTest), diff --git a/apps/server/src/provider/Drivers/CodexDriver.ts b/apps/server/src/provider/Drivers/CodexDriver.ts index 071fb20674a8..1a29408cfef7 100644 --- a/apps/server/src/provider/Drivers/CodexDriver.ts +++ b/apps/server/src/provider/Drivers/CodexDriver.ts @@ -35,6 +35,7 @@ import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; import { ServerConfig } from "../../config.ts"; import { expandHomePath } from "../../pathExpansion.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; +import { DirenvEnvironment } from "../DirenvEnvironment.ts"; import { ProviderDriverError } from "../Errors.ts"; import { makeCodexAdapter } from "../Layers/CodexAdapter.ts"; import { @@ -108,6 +109,7 @@ export type CodexDriverEnv = | ChildProcessSpawner.ChildProcessSpawner | CodexResetCreditCoordinator | Crypto.Crypto + | DirenvEnvironment | FileSystem.FileSystem | HttpClient.HttpClient | ModelManifest.ModelManifest @@ -133,6 +135,7 @@ export const CodexDriver: ProviderDriver = { const httpClient = yield* HttpClient.HttpClient; const serverSettings = yield* ServerSettingsService; const eventLoggers = yield* ProviderEventLoggers; + const direnvEnvironment = yield* DirenvEnvironment; const modelManifest = yield* ModelManifest.ModelManifest; const processEnv = mergeProviderInstanceEnvironment(environment); const homeLayout = yield* resolveCodexHomeLayout(config); @@ -184,6 +187,7 @@ export const CodexDriver: ProviderDriver = { const adapter = yield* makeCodexAdapter(effectiveConfig, { instanceId, environment: processEnv, + resolveEnvironment: direnvEnvironment.resolve, ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), }); const textGeneration = yield* makeCodexTextGeneration(effectiveConfig, processEnv); diff --git a/apps/server/src/provider/Drivers/CursorDriver.test.ts b/apps/server/src/provider/Drivers/CursorDriver.test.ts index 4b9dc529c117..b2171fcab0b7 100644 --- a/apps/server/src/provider/Drivers/CursorDriver.test.ts +++ b/apps/server/src/provider/Drivers/CursorDriver.test.ts @@ -15,12 +15,14 @@ import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; import { ServerConfig } from "../../config.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { NoOpProviderEventLoggers, ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts"; +import * as DirenvEnvironment from "../DirenvEnvironment.ts"; import { CursorDriver } from "./CursorDriver.ts"; const testLayer = ServerConfig.layerTest(process.cwd(), { prefix: "t3-cursor-driver-copy-command-", }).pipe( Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(DirenvEnvironment.layerNoop), Layer.provideMerge(ServerSettingsService.layerTest()), Layer.provideMerge( Layer.mock(BackgroundPolicy.BackgroundPolicy)({ diff --git a/apps/server/src/provider/Drivers/CursorDriver.ts b/apps/server/src/provider/Drivers/CursorDriver.ts index 5466af802e50..68bd75dc6e53 100644 --- a/apps/server/src/provider/Drivers/CursorDriver.ts +++ b/apps/server/src/provider/Drivers/CursorDriver.ts @@ -25,6 +25,7 @@ import { ServerConfig } from "../../config.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { makeCursorTextGeneration } from "../../textGeneration/CursorTextGeneration.ts"; import { ProviderDriverError } from "../Errors.ts"; +import { DirenvEnvironment } from "../DirenvEnvironment.ts"; import { makeCursorAdapter } from "../Layers/CursorAdapter.ts"; import { buildInitialCursorProviderSnapshot, @@ -82,6 +83,7 @@ export type CursorDriverEnv = | BackgroundPolicy.BackgroundPolicy | ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto + | DirenvEnvironment | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path @@ -106,6 +108,7 @@ export const CursorDriver: ProviderDriver = { const httpClient = yield* HttpClient.HttpClient; const serverSettings = yield* ServerSettingsService; const eventLoggers = yield* ProviderEventLoggers; + const direnvEnvironment = yield* DirenvEnvironment; const processEnv = mergeProviderInstanceEnvironment(environment); const continuationIdentity = defaultProviderContinuationIdentity({ driverKind: DRIVER_KIND, @@ -132,6 +135,7 @@ export const CursorDriver: ProviderDriver = { const adapter = yield* makeCursorAdapter(effectiveConfig, { environment: processEnv, + resolveEnvironment: direnvEnvironment.resolve, ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), instanceId, }); diff --git a/apps/server/src/provider/Drivers/GrokDriver.ts b/apps/server/src/provider/Drivers/GrokDriver.ts index 066d0a6b63a8..ceca72492df1 100644 --- a/apps/server/src/provider/Drivers/GrokDriver.ts +++ b/apps/server/src/provider/Drivers/GrokDriver.ts @@ -12,6 +12,7 @@ import { ServerConfig } from "../../config.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { makeGrokTextGeneration } from "../../textGeneration/GrokTextGeneration.ts"; import { ProviderDriverError } from "../Errors.ts"; +import { DirenvEnvironment } from "../DirenvEnvironment.ts"; import { makeGrokAdapter } from "../Layers/GrokAdapter.ts"; import { buildInitialGrokProviderSnapshot, @@ -46,6 +47,7 @@ export type GrokDriverEnv = | BackgroundPolicy.BackgroundPolicy | ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto + | DirenvEnvironment | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path @@ -69,6 +71,7 @@ export const GrokDriver: ProviderDriver = { const serverSettings = yield* ServerSettingsService; const { cwd } = yield* ServerConfig; const eventLoggers = yield* ProviderEventLoggers; + const direnvEnvironment = yield* DirenvEnvironment; const processEnv = mergeProviderInstanceEnvironment(environment); const continuationIdentity = defaultProviderContinuationIdentity({ driverKind: DRIVER_KIND, @@ -84,6 +87,7 @@ export const GrokDriver: ProviderDriver = { const effectiveConfig = { ...config, enabled } satisfies GrokSettings; const adapter = yield* makeGrokAdapter(effectiveConfig, { environment: processEnv, + resolveEnvironment: direnvEnvironment.resolve, ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), instanceId, }); diff --git a/apps/server/src/provider/Drivers/GrokKimiHome.ts b/apps/server/src/provider/Drivers/GrokKimiHome.ts new file mode 100644 index 000000000000..3d1863c637f0 --- /dev/null +++ b/apps/server/src/provider/Drivers/GrokKimiHome.ts @@ -0,0 +1,34 @@ +/** + * Home-directory resolution for the Grok and Kimi CLIs. + * + * Neither CLI's T3 settings carry a `homePath` the way Claude's and Codex's + * do, and neither honours an override env var, so both are read from their + * fixed default location under the OS home — which is also what Grok records + * as `grok_home` in its own session summaries. + * + * @module GrokKimiHome + */ +import * as NodeOS from "node:os"; + +import * as Effect from "effect/Effect"; +import * as Path from "effect/Path"; + +/** `~/.grok` — Grok's state directory. */ +export const resolveGrokHomePath = Effect.fn("resolveGrokHomePath")(function* (): Effect.fn.Return< + string, + never, + Path.Path +> { + const path = yield* Path.Path; + return path.join(NodeOS.homedir(), ".grok"); +}); + +/** `~/.kimi` — Kimi's state directory. */ +export const resolveKimiHomePath = Effect.fn("resolveKimiHomePath")(function* (): Effect.fn.Return< + string, + never, + Path.Path +> { + const path = yield* Path.Path; + return path.join(NodeOS.homedir(), ".kimi"); +}); diff --git a/apps/server/src/provider/Drivers/KimiDriver.ts b/apps/server/src/provider/Drivers/KimiDriver.ts new file mode 100644 index 000000000000..90f32d9990f7 --- /dev/null +++ b/apps/server/src/provider/Drivers/KimiDriver.ts @@ -0,0 +1,191 @@ +import { KimiSettings, ProviderDriverKind, type ServerProvider } from "@t3tools/contracts"; +import * as Crypto from "effect/Crypto"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; +import { HttpClient } from "effect/unstable/http"; +import { ChildProcessSpawner } from "effect/unstable/process"; + +import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; +import { ServerConfig } from "../../config.ts"; +import { ServerSettingsService } from "../../serverSettings.ts"; +import { makeAcpTextGeneration } from "../../textGeneration/CursorTextGeneration.ts"; +import { ProviderDriverError } from "../Errors.ts"; +import { applyKimiAcpModelSelection, makeKimiAcpRuntime } from "../acp/KimiAcpSupport.ts"; +import { makeKimiAdapter } from "../Layers/KimiAdapter.ts"; +import { + buildInitialKimiProviderSnapshot, + checkKimiProviderStatus, + enrichKimiSnapshot, +} from "../Layers/KimiProvider.ts"; +import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts"; +import { makeManagedServerProvider } from "../makeManagedServerProvider.ts"; +import { + defaultProviderContinuationIdentity, + type ProviderDriver, + type ProviderInstance, +} from "../ProviderDriver.ts"; +import type { ServerProviderDraft } from "../providerSnapshot.ts"; +import { mergeProviderInstanceEnvironment } from "../ProviderInstanceEnvironment.ts"; +import { + makeCachedProviderMaintenanceResolution, + makePackageManagedProviderMaintenanceResolver, + normalizeCommandPath, + resolveProviderMaintenanceCapabilitiesEffect, +} from "../providerMaintenance.ts"; +import { + haveProviderSnapshotSettingsChanged, + makeProviderSnapshotSettingsSource, + type ProviderSnapshotSettings, +} from "../providerUpdateSettings.ts"; + +const decodeSettings = Schema.decodeSync(KimiSettings); +const DRIVER_KIND = ProviderDriverKind.make("kimi"); +const SNAPSHOT_REFRESH_INTERVAL = Duration.minutes(5); + +function isKimiNativeCommandPath(commandPath: string): boolean { + const normalized = normalizeCommandPath(commandPath); + return normalized.endsWith("/kimi") || normalized.endsWith("/kimi.exe"); +} + +const UPDATE = makePackageManagedProviderMaintenanceResolver({ + provider: DRIVER_KIND, + npmPackageName: "@moonshot-ai/kimi-code", + nativeUpdate: { + args: ["upgrade"], + isCommandPath: isKimiNativeCommandPath, + }, +}); + +export type KimiDriverEnv = + | BackgroundPolicy.BackgroundPolicy + | ChildProcessSpawner.ChildProcessSpawner + | Crypto.Crypto + | FileSystem.FileSystem + | HttpClient.HttpClient + | Path.Path + | ProviderEventLoggers + | ServerConfig + | ServerSettingsService; + +const withInstanceIdentity = + (input: { + readonly instanceId: ProviderInstance["instanceId"]; + readonly displayName: string | undefined; + readonly accentColor: string | undefined; + readonly continuationGroupKey: string; + }) => + (snapshot: ServerProviderDraft): ServerProvider => ({ + ...snapshot, + instanceId: input.instanceId, + driver: DRIVER_KIND, + ...(input.displayName ? { displayName: input.displayName } : {}), + ...(input.accentColor ? { accentColor: input.accentColor } : {}), + continuation: { groupKey: input.continuationGroupKey }, + }); + +export const KimiDriver: ProviderDriver = { + driverKind: DRIVER_KIND, + metadata: { displayName: "Kimi Code", supportsMultipleInstances: true }, + configSchema: KimiSettings, + defaultConfig: (): KimiSettings => decodeSettings({}), + create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => + Effect.gen(function* () { + const crypto = yield* Crypto.Crypto; + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const httpClient = yield* HttpClient.HttpClient; + const serverSettings = yield* ServerSettingsService; + const eventLoggers = yield* ProviderEventLoggers; + const processEnv = mergeProviderInstanceEnvironment(environment); + const continuationIdentity = defaultProviderContinuationIdentity({ + driverKind: DRIVER_KIND, + instanceId, + }); + const stampIdentity = withInstanceIdentity({ + instanceId, + displayName, + accentColor, + continuationGroupKey: continuationIdentity.continuationKey, + }); + const effectiveConfig = { ...config, enabled } satisfies KimiSettings; + const resolveMaintenance = yield* makeCachedProviderMaintenanceResolution( + resolveProviderMaintenanceCapabilitiesEffect(UPDATE, { + binaryPath: effectiveConfig.binaryPath, + env: processEnv, + }).pipe( + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, pathService), + ), + ); + const adapter = yield* makeKimiAdapter(effectiveConfig, { + environment: processEnv, + ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), + instanceId, + }); + const textGeneration = yield* makeAcpTextGeneration( + effectiveConfig, + { + providerName: "Kimi Code", + makeRuntime: (settings, input) => makeKimiAcpRuntime(settings, input), + applyModelSelection: applyKimiAcpModelSelection, + }, + processEnv, + ); + const checkProvider = checkKimiProviderStatus(effectiveConfig, processEnv).pipe( + Effect.map(stampIdentity), + Effect.provideService(Crypto.Crypto, crypto), + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + ); + const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings); + const snapshot = yield* makeManagedServerProvider>({ + resolveMaintenance, + getSettings: snapshotSettings.getSettings, + streamSettings: snapshotSettings.streamSettings, + haveSettingsChanged: haveProviderSnapshotSettingsChanged, + initialSnapshot: (settings) => + buildInitialKimiProviderSnapshot(settings.provider).pipe(Effect.map(stampIdentity)), + checkProvider, + enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) => + resolveMaintenance().pipe( + Effect.flatMap((maintenanceCapabilities) => + enrichKimiSnapshot({ + settings: settings.provider, + snapshot: currentSnapshot, + maintenanceCapabilities, + enableProviderUpdateChecks: settings.enableProviderUpdateChecks, + publishSnapshot, + stampIdentity, + httpClient, + }), + ), + ), + refreshInterval: SNAPSHOT_REFRESH_INTERVAL, + }).pipe( + Effect.mapError( + (cause) => + new ProviderDriverError({ + driver: DRIVER_KIND, + instanceId, + detail: `Failed to build Kimi snapshot: ${cause.message ?? String(cause)}`, + cause, + }), + ), + ); + return { + instanceId, + driverKind: DRIVER_KIND, + continuationIdentity, + displayName, + accentColor, + enabled, + snapshot, + adapter, + textGeneration, + } satisfies ProviderInstance; + }), +}; diff --git a/apps/server/src/provider/Drivers/OpenCodeDriver.ts b/apps/server/src/provider/Drivers/OpenCodeDriver.ts index 72c1c0683de5..b5f8299c068e 100644 --- a/apps/server/src/provider/Drivers/OpenCodeDriver.ts +++ b/apps/server/src/provider/Drivers/OpenCodeDriver.ts @@ -26,6 +26,7 @@ import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; import { ServerConfig } from "../../config.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { ProviderDriverError } from "../Errors.ts"; +import { DirenvEnvironment } from "../DirenvEnvironment.ts"; import { makeOpenCodeAdapter } from "../Layers/OpenCodeAdapter.ts"; import { checkOpenCodeProviderStatus, @@ -80,6 +81,7 @@ export type OpenCodeDriverEnv = | BackgroundPolicy.BackgroundPolicy | ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto + | DirenvEnvironment | FileSystem.FileSystem | HttpClient.HttpClient | OpenCodeRuntime @@ -106,6 +108,7 @@ export const OpenCodeDriver: ProviderDriver const httpClient = yield* HttpClient.HttpClient; const serverSettings = yield* ServerSettingsService; const eventLoggers = yield* ProviderEventLoggers; + const direnvEnvironment = yield* DirenvEnvironment; const processEnv = mergeProviderInstanceEnvironment(environment); const continuationIdentity = defaultProviderContinuationIdentity({ driverKind: DRIVER_KIND, @@ -133,6 +136,7 @@ export const OpenCodeDriver: ProviderDriver const adapter = yield* makeOpenCodeAdapter(effectiveConfig, { instanceId, environment: processEnv, + resolveEnvironment: direnvEnvironment.resolve, ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), }); const serverOwner = yield* OpenCodeServerOwner.make({ diff --git a/apps/server/src/provider/Layers/AntigravityAdapter.test.ts b/apps/server/src/provider/Layers/AntigravityAdapter.test.ts index 4bd0bb3e1010..584a10de19fd 100644 --- a/apps/server/src/provider/Layers/AntigravityAdapter.test.ts +++ b/apps/server/src/provider/Layers/AntigravityAdapter.test.ts @@ -396,9 +396,9 @@ it.layer(layer)("AntigravityAdapter", (it) => { expect(requests.some((request) => request.method === "session/load")).toBe(false); expect( requests - .filter((request) => request.method === "session/set_config_option") + .filter((request) => request.method === "session/set_mode") .map((request) => request.params), - ).toContainEqual({ sessionId: "mock-session-1", configId: "mode", value: "auto_edit" }); + ).toContainEqual({ sessionId: "mock-session-1", modeId: "auto_edit" }); }), ); diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts index c4136156df10..d019eff7874f 100644 --- a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts +++ b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts @@ -23,7 +23,7 @@ import { ProviderInstanceId, } from "@t3tools/contracts"; import { createModelSelection } from "@t3tools/shared/model"; -import { assert, describe, it } from "@effect/vitest"; +import { assert, describe, it, vi } from "@effect/vitest"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; import * as Deferred from "effect/Deferred"; @@ -168,6 +168,7 @@ function makeHarness(config?: { readonly baseDir?: string; readonly claudeConfig?: Partial; readonly instanceId?: ProviderInstanceId; + readonly resolveEnvironment?: ClaudeAdapterLiveOptions["resolveEnvironment"]; readonly scopedLimitNames?: ClaudeAdapterLiveOptions["scopedLimitNames"]; readonly environment?: ClaudeAdapterLiveOptions["environment"]; }) { @@ -182,6 +183,8 @@ function makeHarness(config?: { const adapterOptions: ClaudeAdapterLiveOptions = { ...(config?.environment ? { environment: config.environment } : {}), ...(config?.instanceId ? { instanceId: config.instanceId } : {}), + ...(config?.environment ? { environment: config.environment } : {}), + ...(config?.resolveEnvironment ? { resolveEnvironment: config.resolveEnvironment } : {}), ...(config?.scopedLimitNames ? { scopedLimitNames: config.scopedLimitNames } : {}), modelCatalog: Effect.succeed(SYNTHETIC_CLAUDE_MODEL_CATALOG), createQuery: (input) => { @@ -310,6 +313,42 @@ const RESUME_THREAD_ID = ThreadId.make("thread-claude-resume"); const SYNTHETIC_SUBAGENT_MODEL = "claude-synthetic-subagent[expanded]"; describe("ClaudeAdapterLive", () => { + it.effect("passes the resolved environment to the SDK after applying Claude invariants", () => { + const claudeConfigDir = "/tmp/t3-claude-direnv-home"; + const resolveEnvironment = vi.fn((_input: { readonly cwd: string }) => + Effect.succeed({ + PATH: process.env.PATH, + PROVIDER_VALUE: "from-direnv", + CLAUDE_CONFIG_DIR: "/tmp/direnv-must-not-win", + }), + ); + const harness = makeHarness({ + claudeConfig: { homePath: claudeConfigDir }, + environment: { PATH: process.env.PATH, PROVIDER_VALUE: "configured" }, + resolveEnvironment, + }); + return Effect.gen(function* () { + const adapter = yield* ClaudeAdapter; + yield* adapter.startSession({ + threadId: ThreadId.make("thread-claude-direnv"), + provider: ProviderDriverKind.make("claudeAgent"), + cwd: ".", + runtimeMode: "full-access", + }); + + assert.equal(resolveEnvironment.mock.calls[0]?.[0].cwd, process.cwd()); + assert.deepEqual(harness.getLastCreateQueryInput()?.options.env, { + PATH: process.env.PATH, + PROVIDER_VALUE: "from-direnv", + CLAUDE_CONFIG_DIR: claudeConfigDir, + }); + assert.equal(harness.getLastCreateQueryInput()?.options.cwd, process.cwd()); + }).pipe( + Effect.provideService(Random.Random, makeDeterministicRandomService()), + Effect.provide(harness.layer), + ); + }); + it.effect("returns validation error for non-claude provider on startSession", () => { const harness = makeHarness(); return Effect.gen(function* () { @@ -3225,6 +3264,8 @@ describe("ClaudeAdapterLive", () => { totalProcessedTokens: 550, inputTokens: 180, outputTokens: 20, + lastInputTokens: 180, + lastOutputTokens: 20, maxTokens: 200000, }); } @@ -5017,7 +5058,9 @@ describe("ClaudeAdapterLive", () => { usedTokens: 24542, lastUsedTokens: 24542, inputTokens: 23863, + lastInputTokens: 23863, outputTokens: 679, + lastOutputTokens: 679, maxTokens: 200000, }, }); diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.ts b/apps/server/src/provider/Layers/ClaudeAdapter.ts index 981e183414f1..ead8cf829e45 100644 --- a/apps/server/src/provider/Layers/ClaudeAdapter.ts +++ b/apps/server/src/provider/Layers/ClaudeAdapter.ts @@ -108,6 +108,7 @@ import { type ProviderAdapterError, } from "../Errors.ts"; import { type ClaudeAdapterShape } from "../Services/ClaudeAdapter.ts"; +import { type DirenvEnvironment, resolveProviderSessionEnvironment } from "../DirenvEnvironment.ts"; import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const decodeUnknownJsonStringExit = Schema.decodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); @@ -346,6 +347,7 @@ interface ClaudeQueryRuntime extends AsyncIterable { export interface ClaudeAdapterLiveOptions { readonly instanceId?: ProviderInstanceId; readonly environment?: NodeJS.ProcessEnv; + readonly resolveEnvironment?: DirenvEnvironment["Service"]["resolve"]; readonly createQuery?: (input: { readonly prompt: AsyncIterable; readonly options: ClaudeQueryOptions; @@ -648,8 +650,12 @@ function makeClaudeTokenUsageSnapshot(input: { ...(totalProcessedTokens !== undefined && totalProcessedTokens > usedTokens ? { totalProcessedTokens } : {}), - ...(inputTokens !== undefined && inputTokens > 0 ? { inputTokens } : {}), - ...(outputTokens !== undefined && outputTokens > 0 ? { outputTokens } : {}), + ...(inputTokens !== undefined && inputTokens > 0 + ? { inputTokens, lastInputTokens: inputTokens } + : {}), + ...(outputTokens !== undefined && outputTokens > 0 + ? { outputTokens, lastOutputTokens: outputTokens } + : {}), ...(maxTokens !== undefined ? { maxTokens } : {}), ...(input.compactsAutomatically !== undefined ? { compactsAutomatically: input.compactsAutomatically } @@ -1927,7 +1933,8 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( const path = yield* Path.Path; const serverConfig = yield* ServerConfig; const crypto = yield* Crypto.Crypto; - const claudeEnvironment = yield* makeClaudeEnvironment(claudeSettings, options?.environment).pipe( + const baseEnvironment = options?.environment ?? process.env; + const claudeEnvironment = yield* makeClaudeEnvironment(claudeSettings, baseEnvironment).pipe( Effect.provideService(Path.Path, path), ); const claudeSdkExecutablePath = yield* resolveClaudeSdkExecutablePath( @@ -4179,6 +4186,28 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( }); } + if (input.cwd !== undefined && !input.cwd.trim()) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "startSession", + issue: "cwd must be non-empty when provided.", + }); + } + const cwd = input.cwd === undefined ? undefined : path.resolve(input.cwd.trim()); + const sessionEnvironment = + cwd === undefined + ? claudeEnvironment + : yield* resolveProviderSessionEnvironment({ + resolve: options?.resolveEnvironment, + provider: PROVIDER, + threadId: input.threadId, + cwd, + environment: baseEnvironment, + }).pipe( + Effect.flatMap((environment) => makeClaudeEnvironment(claudeSettings, environment)), + Effect.provideService(Path.Path, path), + ); + const existingContext = sessions.get(input.threadId); if (existingContext) { yield* Effect.logWarning("claude.session.replacing", { @@ -4674,12 +4703,11 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( // the paths ProviderService injects into the turn text, without an // approval prompt. It is a leaf directory holding only attachment // files; siblings like secrets/ and state.sqlite stay ungranted. - const additionalDirectories = [ - ...(input.cwd ? [input.cwd] : []), - serverConfig.attachmentsDir, - ]; + // `cwd` (resolved/trimmed), not the raw `input.cwd`: the grant has to + // name the same path the query actually runs in. + const additionalDirectories = [...(cwd ? [cwd] : []), serverConfig.attachmentsDir]; const queryOptions: ClaudeQueryOptions = { - ...(input.cwd ? { cwd: input.cwd } : {}), + ...(cwd ? { cwd } : {}), ...(apiModelId ? { model: apiModelId } : {}), pathToClaudeCodeExecutable: claudeBinaryPath, systemPrompt: { @@ -4707,7 +4735,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( canUseTool, onUserDialog, supportedDialogKinds: ["resume_return"], - env: McpProviderSession.withAgentDeviceEnvironment(claudeEnvironment, mcpSession), + env: McpProviderSession.withAgentDeviceEnvironment(sessionEnvironment, mcpSession), additionalDirectories, ...(Object.keys(extraArgs).length > 0 ? { extraArgs } : {}), ...(mcpSession @@ -4735,7 +4763,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( "claude.resume.session_id": existingResumeSessionId ?? "", "claude.resume.session_at": resumeState?.resumeSessionAt ?? "", "claude.resume.turn_count": resumeState?.turnCount ?? -1, - "claude.query.cwd": input.cwd ?? "", + "claude.query.cwd": cwd ?? "", "claude.query.model": apiModelId ?? "", "claude.query.effort": effectiveEffort ?? "", "claude.query.permission_mode": permissionMode ?? "", @@ -4771,7 +4799,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( providerInstanceId: boundInstanceId, status: "ready", runtimeMode: input.runtimeMode, - ...(input.cwd ? { cwd: input.cwd } : {}), + ...(cwd ? { cwd } : {}), ...(modelSelection?.model ? { model: modelSelection.model } : {}), ...(threadId ? { threadId } : {}), resumeCursor: { @@ -5039,6 +5067,27 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( }, ); + /** + * Manual compact: enqueue the `/compact` local command on the live SDK + * session. Claude emits `compact_boundary` + token-usage updates when done. + */ + const compactSession: ClaudeAdapterShape["compactSession"] = Effect.fn("compactSession")( + function* (threadId) { + const context = yield* requireSession(threadId); + // Close a stale synthetic turn so compact is not blocked behind one. + if (context.turnState?.synthetic === true) { + yield* completeTurn(context, "completed"); + } + const message = buildUserMessage({ + sdkContent: [{ type: "text", text: "/compact" }], + }); + yield* Queue.offer(context.promptQueue, { + type: "message", + message, + }).pipe(Effect.mapError((cause) => toRequestError(threadId, "compact/start", cause))); + }, + ); + const readThread: ClaudeAdapterShape["readThread"] = Effect.fn("readThread")( function* (threadId) { const context = yield* requireSession(threadId); @@ -5145,6 +5194,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( startSession, sendTurn, interruptTurn, + compactSession, readThread, rollbackThread, respondToRequest, diff --git a/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts b/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts index 232b8cc02d00..0fd7f7acab90 100644 --- a/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts +++ b/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts @@ -1,9 +1,6 @@ // @effect-diagnostics nodeBuiltinImport:off - cleanup uses Node's retrying rm, which the FileSystem service does not expose. import * as ClaudeSdk from "@anthropic-ai/claude-agent-sdk"; import { vi } from "vite-plus/test"; -import * as Deferred from "effect/Deferred"; -import * as Fiber from "effect/Fiber"; -import * as TestClock from "effect/testing/TestClock"; import { ClaudeSettings } from "@t3tools/contracts"; import * as NodeFSP from "node:fs/promises"; import * as NodeServices from "@effect/platform-node/NodeServices"; @@ -189,9 +186,8 @@ it.layer(NodeServices.layer)("Claude capability probe SDK boundary", (it) => { ); }); -it.effect("preserves initialized capabilities when optional usage times out", () => +it.live("preserves initialized capabilities when optional usage times out", () => Effect.gen(function* () { - const usageStarted = yield* Deferred.make(); let abortSignal: AbortSignal | undefined; const query = vi.spyOn(ClaudeSdk, "query").mockImplementation(({ options }) => { abortSignal = options?.abortController?.signal; @@ -200,19 +196,13 @@ it.effect("preserves initialized capabilities when optional usage times out", () account: { email: "dev@example.com", subscriptionType: "pro", tokenSource: "oauth" }, commands: [{ name: "review", description: "Review changes", argumentHint: "[path]" }], }), - usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: () => { - Deferred.doneUnsafe(usageStarted, Effect.void); - return new Promise(() => {}); - }, + usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: () => new Promise(() => {}), } as ReturnType; }); yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore())); - const probe = yield* probeClaudeCapabilities( + const capabilities = yield* probeClaudeCapabilities( decodeClaudeSettings({ binaryPath: "claude" }), - ).pipe(Effect.forkChild); - yield* Deferred.await(usageStarted); - yield* TestClock.adjust("4 seconds"); - const capabilities = yield* Fiber.join(probe); + ); assert.equal(capabilities?.email, "dev@example.com"); assert.equal(capabilities?.subscriptionType, "pro"); assert.equal(capabilities?.tokenSource, "oauth"); diff --git a/apps/server/src/provider/Layers/ClaudeProvider.ts b/apps/server/src/provider/Layers/ClaudeProvider.ts index 62d7444c6968..4452387dcb17 100644 --- a/apps/server/src/provider/Layers/ClaudeProvider.ts +++ b/apps/server/src/provider/Layers/ClaudeProvider.ts @@ -57,6 +57,7 @@ const CLAUDE_PRESENTATION = { showInteractionModeToggle: true, reportsContextWindow: true, } as const; + function toTitleCaseWords(value: string): string { const parts: Array = []; for (const part of value.split(/[\s_-]+/g)) { diff --git a/apps/server/src/provider/Layers/CodexAdapter.test.ts b/apps/server/src/provider/Layers/CodexAdapter.test.ts index f7c6036885d9..816abe4c65ec 100644 --- a/apps/server/src/provider/Layers/CodexAdapter.test.ts +++ b/apps/server/src/provider/Layers/CodexAdapter.test.ts @@ -38,6 +38,7 @@ import * as CodexErrors from "effect-codex-app-server/errors"; import { ServerConfig } from "../../config.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { ProviderAdapterValidationError } from "../Errors.ts"; +import { DirenvEnvironmentError } from "../DirenvEnvironment.ts"; import type { CodexAdapterShape } from "../Services/CodexAdapter.ts"; import { ProviderSessionDirectory } from "../Services/ProviderSessionDirectory.ts"; import { @@ -90,6 +91,8 @@ class FakeCodexRuntime implements CodexSessionRuntimeShape { Promise.resolve(undefined), ); + public readonly compactSessionImpl = vi.fn((): Promise => Promise.resolve(undefined)); + public readonly readThreadImpl = vi.fn((): Promise => Promise.resolve({ threadId: "provider-thread-1", @@ -140,6 +143,10 @@ class FakeCodexRuntime implements CodexSessionRuntimeShape { return Effect.promise(() => this.interruptTurnImpl(turnId)); } + get compactSession() { + return Effect.promise(() => this.compactSessionImpl()); + } + readThread = Effect.promise(() => this.readThreadImpl()); rollbackThread(numTurns: number) { @@ -319,6 +326,78 @@ const sessionErrorLayer = it.layer( ); sessionErrorLayer("CodexAdapterLive session errors", (it) => { + it.effect( + "uses the resolved environment and preserves an existing session on resolver failure", + () => { + const runtimeFactory = makeRuntimeFactory(); + let shouldFail = false; + const resolvedEnvironment = { + PATH: process.env.PATH, + PROVIDER_VALUE: "from-direnv", + T3CODE_CODEX_LAUNCH_ARGS: "--enable direnv-feature", + }; + const resolveEnvironment = vi.fn((_input: { readonly cwd: string }) => + shouldFail + ? Effect.fail( + new DirenvEnvironmentError({ + stage: "execution", + detail: "direnv allow is required.", + }), + ) + : Effect.succeed(resolvedEnvironment), + ); + const layer = Layer.effect( + CodexAdapter, + Effect.gen(function* () { + const codexConfig = decodeCodexSettings({}); + return yield* makeCodexAdapter(codexConfig, { + environment: { PATH: process.env.PATH, PROVIDER_VALUE: "configured" }, + resolveEnvironment, + makeRuntime: runtimeFactory.factory, + }); + }), + ).pipe( + Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())), + Layer.provideMerge(ServerSettingsService.layerTest()), + Layer.provideMerge(providerSessionDirectoryTestLayer), + Layer.provideMerge(NodeServices.layer), + ); + + return Effect.gen(function* () { + const adapter = yield* CodexAdapter; + const threadId = asThreadId("sess-direnv-preserve"); + yield* adapter.startSession({ + provider: ProviderDriverKind.make("codex"), + threadId, + cwd: ".", + runtimeMode: "full-access", + }); + + const runtime = runtimeFactory.lastRuntime; + NodeAssert.ok(runtime); + NodeAssert.strictEqual(runtime.options.environment, resolvedEnvironment); + NodeAssert.equal(runtime.options.launchArgs, "--enable direnv-feature"); + NodeAssert.equal(resolveEnvironment.mock.calls[0]?.[0].cwd, process.cwd()); + + shouldFail = true; + const error = yield* adapter + .startSession({ + provider: ProviderDriverKind.make("codex"), + threadId, + cwd: ".", + runtimeMode: "full-access", + }) + .pipe(Effect.flip); + + NodeAssert.equal(error._tag, "ProviderAdapterProcessError"); + NodeAssert.match(error.detail, /direnv allow/u); + NodeAssert.equal(runtimeFactory.factory.mock.calls.length, 1); + NodeAssert.equal(runtime.closeImpl.mock.calls.length, 0); + NodeAssert.equal((yield* adapter.listSessions()).length, 1); + }).pipe(Effect.provide(layer)); + }, + ); + it.effect("maps missing adapter sessions to ProviderAdapterSessionNotFoundError", () => Effect.gen(function* () { const adapter = yield* CodexAdapter; @@ -670,6 +749,50 @@ function codexTurnEvent(method: "turn/started" | "turn/completed", turnId: strin } lifecycleLayer("CodexAdapterLive lifecycle", (it) => { + it.effect("keeps forwarding events after the start-session caller exits", () => + Effect.gen(function* () { + const adapter = yield* CodexAdapter; + const threadId = asThreadId("thread-short-lived-start-caller"); + const startCaller = yield* adapter + .startSession({ + provider: ProviderDriverKind.make("codex"), + threadId, + runtimeMode: "full-access", + }) + .pipe(Effect.forkChild); + yield* Fiber.join(startCaller); + + const runtime = lifecycleRuntimeFactory.lastRuntime; + NodeAssert.ok(runtime); + const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild); + + yield* runtime.emit({ + id: asEventId("evt-after-start-caller-exited"), + kind: "notification", + provider: ProviderDriverKind.make("codex"), + createdAt: "2026-01-01T00:00:00.000Z", + method: "turn/started", + threadId, + turnId: asTurnId("turn-after-start-caller-exited"), + payload: { + threadId: "provider-thread-1", + turn: { + id: "turn-after-start-caller-exited", + status: "inProgress", + items: [], + error: null, + }, + }, + } satisfies ProviderEvent); + + const firstEvent = yield* Fiber.join(firstEventFiber).pipe(Effect.timeout("1 second")); + NodeAssert.equal(firstEvent._tag, "Some"); + if (firstEvent._tag !== "Some") return; + NodeAssert.equal(firstEvent.value.type, "turn.started"); + NodeAssert.equal(firstEvent.value.turnId, "turn-after-start-caller-exited"); + }), + ); + it.effect("calculates one Codex turn total from cumulative counters", () => Effect.gen(function* () { const { adapter, runtime } = yield* startLifecycleRuntime(); diff --git a/apps/server/src/provider/Layers/CodexAdapter.ts b/apps/server/src/provider/Layers/CodexAdapter.ts index b43755736ca3..d799ac72816f 100644 --- a/apps/server/src/provider/Layers/CodexAdapter.ts +++ b/apps/server/src/provider/Layers/CodexAdapter.ts @@ -37,6 +37,7 @@ import * as Crypto from "effect/Crypto"; import * as Exit from "effect/Exit"; import * as Fiber from "effect/Fiber"; import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; import * as Queue from "effect/Queue"; import * as Schema from "effect/Schema"; import * as Scope from "effect/Scope"; @@ -58,6 +59,7 @@ import { type ProviderAdapterError, } from "../Errors.ts"; import { type CodexAdapterShape } from "../Services/CodexAdapter.ts"; +import { type DirenvEnvironment, resolveProviderSessionEnvironment } from "../DirenvEnvironment.ts"; import { resolveAttachmentPath } from "../../attachmentStore.ts"; import { ServerConfig } from "../../config.ts"; import { @@ -89,6 +91,7 @@ const PROVIDER = ProviderDriverKind.make("codex"); export interface CodexAdapterLiveOptions { readonly instanceId?: ProviderInstanceId; readonly environment?: NodeJS.ProcessEnv; + readonly resolveEnvironment?: DirenvEnvironment["Service"]["resolve"]; readonly makeRuntime?: ( options: CodexSessionRuntimeOptions, ) => Effect.Effect< @@ -2219,6 +2222,7 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* ( ) { const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("codex"); const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; const crypto = yield* Crypto.Crypto; const serverConfig = yield* Effect.service(ServerConfig); @@ -2245,6 +2249,25 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* ( }); } + if (input.cwd !== undefined && !input.cwd.trim()) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "startSession", + issue: "cwd must be non-empty when provided.", + }); + } + const cwd = input.cwd === undefined ? process.cwd() : path.resolve(input.cwd.trim()); + const environment = + input.cwd === undefined + ? options?.environment + : yield* resolveProviderSessionEnvironment({ + resolve: options?.resolveEnvironment, + provider: PROVIDER, + threadId: input.threadId, + cwd, + environment: options?.environment ?? process.env, + }); + const existing = sessions.get(input.threadId); if (existing && !existing.stopped) { yield* Effect.suspend(() => stopSessionInternal(existing)); @@ -2258,10 +2281,10 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* ( const runtimeInput: CodexSessionRuntimeOptions = { threadId: input.threadId, providerInstanceId: boundInstanceId, - cwd: input.cwd ?? process.cwd(), + cwd, binaryPath: codexConfig.binaryPath, - launchArgs: resolveCodexLaunchArgs(codexConfig.launchArgs, options?.environment), - ...(options?.environment ? { environment: options.environment } : {}), + launchArgs: resolveCodexLaunchArgs(codexConfig.launchArgs, environment), + ...(environment ? { environment } : {}), ...(codexConfig.homePath ? { homePath: codexConfig.homePath } : {}), ...(isCodexResumeCursorSchema(input.resumeCursor) ? { resumeCursor: input.resumeCursor } @@ -2275,7 +2298,7 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* ( ? { environment: { ...McpProviderSession.withAgentDeviceEnvironment( - options?.environment ?? process.env, + environment ?? options?.environment ?? process.env, mcpSession, ), T3_MCP_BEARER_TOKEN: mcpSession.authorizationHeader.replace(/^Bearer\s+/, ""), @@ -2573,6 +2596,16 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* ( ); }); + const compactSession: CodexAdapterShape["compactSession"] = (threadId) => + requireSession(threadId).pipe( + Effect.flatMap((session) => session.runtime.compactSession), + Effect.mapError((cause) => + cause._tag === "ProviderAdapterSessionNotFoundError" + ? cause + : mapCodexRuntimeError(threadId, "thread/compact/start", cause), + ), + ); + const readThread: CodexAdapterShape["readThread"] = (threadId) => requireSession(threadId).pipe( Effect.flatMap((session) => session.runtime.readThread), @@ -2720,6 +2753,7 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* ( sendTurn, compaction: { type: "native", start: compactThread }, interruptTurn, + compactSession, readThread, rollbackThread, uploadFeedback, diff --git a/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts b/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts index 02b7a45f33ad..1d7adab2287c 100644 --- a/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts +++ b/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts @@ -547,6 +547,7 @@ describe("CodexSessionRuntime collab integration", () => { Effect.sync(() => { NodeFS.rmSync(scriptPath, { force: true }); NodeFS.rmSync(interruptsPath, { force: true }); + NodeFS.rmSync(`${scriptPath}.turns`, { force: true }); }), ); @@ -613,6 +614,10 @@ describe("CodexSessionRuntime collab integration", () => { rootThreadId: ROOT, holdTurnOpen: true, onlyFirstTurnStarts: true, + // The fork steers the running turn first; rejecting the steer is what + // sends the follow-up back through turn/start, which is the path + // whose response carries the queued turn id. + rejectSteer: true, turnIds: [activeTurnId, queuedTurnId], expectedActiveTurnId: activeTurnId, notifications: [], @@ -625,6 +630,7 @@ describe("CodexSessionRuntime collab integration", () => { Effect.sync(() => { NodeFS.rmSync(scriptPath, { force: true }); NodeFS.rmSync(interruptsPath, { force: true }); + NodeFS.rmSync(`${scriptPath}.turns`, { force: true }); }), ); @@ -653,6 +659,61 @@ describe("CodexSessionRuntime collab integration", () => { yield* runtime.close; }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), ); + it.live("Stop targets the steered turn when Codex accepts a mid-turn follow-up", () => + Effect.gen(function* () { + const activeTurnId = "019fe3e8-f908-7f31-8d51-283f4a47897a"; + const script = { + rootThreadId: ROOT, + holdTurnOpen: true, + onlyFirstTurnStarts: true, + turnIds: [activeTurnId], + expectedActiveTurnId: activeTurnId, + notifications: [], + }; + // @effect-diagnostics-next-line preferSchemaOverJson:off + NodeFS.writeFileSync(scriptPath, JSON.stringify(script), "utf8"); + const interruptsPath = `${scriptPath}.interrupts`; + NodeFS.rmSync(interruptsPath, { force: true }); + yield* Effect.addFinalizer(() => + Effect.sync(() => { + NodeFS.rmSync(scriptPath, { force: true }); + NodeFS.rmSync(interruptsPath, { force: true }); + NodeFS.rmSync(`${scriptPath}.turns`, { force: true }); + }), + ); + + const turnsPath = `${scriptPath}.turns`; + NodeFS.rmSync(turnsPath, { force: true }); + + const runtime = yield* makeCodexSessionRuntime({ + threadId: ThreadId.make("thread-codex-steered-stop"), + binaryPath: peerPath, + cwd: "/tmp", + runtimeMode: "full-access", + environment: { ...process.env, T3_CODEX_COLLAB_SCRIPT: scriptPath }, + }); + + yield* runtime.start(); + yield* runtime.sendTurn({ input: "keep working" }); + // Steered, not a second turn: the follow-up never opens a new turn id. + yield* runtime.sendTurn({ input: "steered follow-up" }); + yield* runtime.interruptTurn(); + + const interrupts = NodeFS.readFileSync(interruptsPath, "utf8") + .trim() + .split("\n") + .map((line) => JSON.parse(line) as { threadId?: string; turnId?: string }); + assert.deepEqual(interrupts.at(-1), { + threadId: ROOT, + turnId: activeTurnId, + }); + // An accepted steer must not open a second provider turn. + const turns = NodeFS.readFileSync(turnsPath, "utf8").trim().split("\n"); + assert.equal(turns.length, 1); + + yield* runtime.close; + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); const elicitationCases = [ { diff --git a/apps/server/src/provider/Layers/CodexSessionRuntime.test.ts b/apps/server/src/provider/Layers/CodexSessionRuntime.test.ts index 3385137a2dae..d6517e5083b9 100644 --- a/apps/server/src/provider/Layers/CodexSessionRuntime.test.ts +++ b/apps/server/src/provider/Layers/CodexSessionRuntime.test.ts @@ -758,6 +758,18 @@ describe("isRecoverableThreadResumeError", () => { ); }); + it("matches codex invalid params resume failures", () => { + NodeAssert.equal( + isRecoverableThreadResumeError( + new CodexErrors.CodexAppServerRequestError({ + code: -32602, + errorMessage: "Invalid params", + }), + ), + true, + ); + }); + it("ignores unrelated missing-resource errors that do not mention threads", () => { NodeAssert.equal( isRecoverableThreadResumeError( @@ -919,6 +931,52 @@ describe("openCodexThread", () => { }), ); + it.effect("falls back to thread/start when resume returns invalid params", () => + Effect.gen(function* () { + const calls: Array<{ method: "thread/start" | "thread/resume"; payload: unknown }> = []; + const started = makeThreadOpenResponse("fresh-thread"); + const client = { + request: ( + method: M, + payload: CodexRpc.ClientRequestParamsByMethod[M], + ) => { + calls.push({ method, payload }); + return Effect.succeed(started as CodexRpc.ClientRequestResponsesByMethod[M]); + }, + raw: { + request: ( + method: "thread/resume", + payload: CodexRpc.ClientRequestParamsByMethod["thread/resume"], + ) => { + calls.push({ method, payload }); + return Effect.fail( + new CodexErrors.CodexAppServerRequestError({ + code: -32602, + errorMessage: "Invalid params", + }), + ); + }, + }, + }; + + const opened = yield* openCodexThread({ + client, + threadId: ThreadId.make("thread-1"), + runtimeMode: "full-access", + cwd: "/tmp/project", + requestedModel: "gpt-5.3-codex", + serviceTier: undefined, + resumeThreadId: "019f3320-ed49-7e52-9a21-057c3b3820ed", + }); + + NodeAssert.equal(opened.thread.id, "fresh-thread"); + NodeAssert.deepStrictEqual( + calls.map((call) => call.method), + ["thread/resume", "thread/start"], + ); + }), + ); + it.effect("propagates non-recoverable resume failures", () => Effect.gen(function* () { const client = { diff --git a/apps/server/src/provider/Layers/CodexSessionRuntime.ts b/apps/server/src/provider/Layers/CodexSessionRuntime.ts index bd9a6b6f34a8..6664b3b5ade0 100644 --- a/apps/server/src/provider/Layers/CodexSessionRuntime.ts +++ b/apps/server/src/provider/Layers/CodexSessionRuntime.ts @@ -87,6 +87,7 @@ const CodexUserInputAnswerObject = Schema.Struct({ }); const isCodexResumeCursorSchema = Schema.is(CodexResumeCursorSchema); const isCodexUserInputAnswerObject = Schema.is(CodexUserInputAnswerObject); +const isCodexAppServerRequestError = Schema.is(CodexErrors.CodexAppServerRequestError); const NullableMcpElicitationString = Schema.NullOr(Schema.String); const McpElicitationMetadata = Schema.Struct({ app: Schema.optionalKey(NullableMcpElicitationString), @@ -213,6 +214,7 @@ export interface CodexSessionRuntimeShape { ) => Effect.Effect; readonly compactThread: Effect.Effect; readonly interruptTurn: (turnId?: TurnId) => Effect.Effect; + readonly compactSession: Effect.Effect; readonly readThread: Effect.Effect; readonly rollbackThread: ( numTurns: number, @@ -684,6 +686,14 @@ function classifyCodexStderrLine(rawLine: string): { readonly message: string } } export function isRecoverableThreadResumeError(error: unknown): boolean { + if ( + isCodexAppServerRequestError(error) && + error.code === -32602 && + error.errorMessage.toLowerCase() === "invalid params" + ) { + return true; + } + const message = (error instanceof Error ? error.message : String(error)).toLowerCase(); if (!message.includes("thread")) { return false; @@ -2372,6 +2382,52 @@ export const makeCodexSessionRuntime = ( options.mcpCapabilities, ), }); + + // Steer the active turn via the protocol-native `turn/steer` — + // appending input mid-turn instead of opening a second provider + // turn while the first is still settling. The `expectedTurnId` + // precondition fails when the turn just ended or is not steerable + // (e.g. review/compact); only a server rejection of the request + // itself (operation "receive-response" — the steer was NOT + // applied) falls back to a fresh `turn/start`. Decode failures on + // an accepted steer's response, and transport/protocol failures, + // propagate: the input may already be appended, and retrying via + // turn/start would duplicate it. + const activeSession = yield* Ref.get(sessionRef); + if (activeSession.status === "running" && activeSession.activeTurnId !== undefined) { + const steeredTurnId = yield* client + .request("turn/steer", { + threadId: providerThreadId, + expectedTurnId: activeSession.activeTurnId, + input: params.input, + }) + .pipe( + Effect.map((steerResponse) => TurnId.make(steerResponse.turnId)), + Effect.catchIf( + (cause): cause is CodexErrors.CodexAppServerRequestError => + cause._tag === "CodexAppServerRequestError" && + cause.operation === "receive-response", + (cause) => + Effect.as( + Effect.logDebug("Codex turn/steer rejected; falling back to turn/start.", { + cause, + }), + null, + ), + ), + ); + if (steeredTurnId !== null) { + const steeredProviderThreadId = currentProviderThreadId(yield* Ref.get(sessionRef)); + return { + threadId: options.threadId, + turnId: steeredTurnId, + ...(steeredProviderThreadId + ? { resumeCursor: { threadId: steeredProviderThreadId } } + : {}), + } satisfies ProviderTurnStartResult; + } + } + const rawResponse = yield* client.raw.request("turn/start", params); const response = yield* decodeV2TurnStartResponse(rawResponse).pipe( Effect.mapError((error) => @@ -2433,6 +2489,12 @@ export const makeCodexSessionRuntime = ( turnId: effectiveTurnId, }); }), + compactSession: Effect.gen(function* () { + const providerThreadId = yield* readProviderThreadId; + yield* client.request("thread/compact/start", { + threadId: providerThreadId, + }); + }), readThread: Effect.gen(function* () { const providerThreadId = yield* readProviderThreadId; const response = yield* client.request("thread/read", { diff --git a/apps/server/src/provider/Layers/CursorAdapter.test.ts b/apps/server/src/provider/Layers/CursorAdapter.test.ts index 0c192ce7e114..26cdf9ef2729 100644 --- a/apps/server/src/provider/Layers/CursorAdapter.test.ts +++ b/apps/server/src/provider/Layers/CursorAdapter.test.ts @@ -5,7 +5,7 @@ import * as NodeFSP from "node:fs/promises"; import * as NodeURL from "node:url"; import * as NodeServices from "@effect/platform-node/NodeServices"; -import { assert, it } from "@effect/vitest"; +import { assert, it, vi } from "@effect/vitest"; import * as Context from "effect/Context"; import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; @@ -29,6 +29,7 @@ import { ServerConfig } from "../../config.ts"; import { buildRuntimeInstructions } from "../RuntimeInstructions.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import type { CursorAdapterShape } from "../Services/CursorAdapter.ts"; +import { pollUntil } from "../testUtils/pollUntil.ts"; import { makeCursorAdapter } from "./CursorAdapter.ts"; import { execScriptSource, writeFakeCli } from "../../testUtils/fakeCli.ts"; import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; @@ -91,36 +92,33 @@ async function readJsonLines(filePath: string) { .split("\n") .map((line) => line.trim()) .filter((line) => line.length > 0) - .map((line) => JSON.parse(line) as Record); + .flatMap((line) => { + // A poll can observe the mock child halfway through appending its final + // line. The next poll will see the complete JSON record. + try { + return [JSON.parse(line) as Record]; + } catch { + return []; + } + }); } -async function waitForFileContent(filePath: string, attempts = 40) { - for (let attempt = 0; attempt < attempts; attempt += 1) { - try { - const raw = await NodeFSP.readFile(filePath, "utf8"); - if (raw.trim().length > 0) { - return raw; - } - } catch {} - await Effect.runPromise(Effect.yieldNow); - } - throw new Error(`Timed out waiting for file content at ${filePath}`); +function waitForFileContent(filePath: string) { + return pollUntil({ + poll: Effect.promise(() => NodeFSP.readFile(filePath, "utf8").catch(() => "")), + until: (raw) => raw.trim().length > 0, + description: `file content at ${filePath}`, + }); } function waitForJsonLogMatch( filePath: string, predicate: (entry: Record) => boolean, - attempts = 40, ) { - return Effect.gen(function* () { - for (let attempt = 0; attempt < attempts; attempt += 1) { - const requests = yield* Effect.promise(() => readJsonLines(filePath)); - if (requests.some(predicate)) { - return requests; - } - yield* Effect.yieldNow; - } - return yield* Effect.promise(() => readJsonLines(filePath)); + return pollUntil({ + poll: Effect.promise(() => readJsonLines(filePath)), + until: (entries) => entries.some(predicate), + description: `a matching json log entry in ${filePath}`, }); } @@ -162,6 +160,41 @@ const cursorAdapterTestLayer = it.layer( ); cursorAdapterTestLayer("CursorAdapterLive", (it) => { + it.effect("passes the resolved complete environment to the Cursor ACP child", () => + Effect.gen(function* () { + const tempDirectory = yield* Effect.promise(() => + NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "cursor-direnv-")), + ); + const requestLogPath = NodePath.join(tempDirectory, "requests.jsonl"); + const wrapperPath = yield* Effect.promise(() => makeMockAgentWrapper()); + const resolveEnvironment = vi.fn((input) => + Effect.succeed({ + ...input.environment, + PROVIDER_VALUE: "from-direnv", + T3_ACP_REQUEST_LOG_PATH: requestLogPath, + }), + ); + const adapter = yield* makeCursorAdapter(decodeCursorSettings({ binaryPath: wrapperPath }), { + environment: { ...process.env, PROVIDER_VALUE: "configured" }, + resolveEnvironment, + }); + const threadId = ThreadId.make("cursor-direnv-thread"); + + yield* adapter.startSession({ + threadId, + provider: ProviderDriverKind.make("cursor"), + cwd: ".", + runtimeMode: "full-access", + }); + + assert.equal(resolveEnvironment.mock.calls[0]?.[0].cwd, process.cwd()); + // The wait only succeeds once the child saw the resolved environment + // (the request log path only exists inside it). + yield* waitForJsonLogMatch(requestLogPath, (entry) => entry.method === "initialize"); + yield* adapter.stopSession(threadId); + }), + ); + it.effect("rejects a Cursor transport error returned as a successful assistant answer", () => Effect.gen(function* () { const adapter = yield* CursorAdapter; @@ -207,7 +240,9 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { const wrapperPath = yield* Effect.promise(() => makeMockAgentWrapper()); yield* settings.updateSettings({ providers: { cursor: { binaryPath: wrapperPath } } }); - const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).pipe( + const runtimeEventsFiber = yield* adapter.streamEvents.pipe( + Stream.filter((event) => event.threadId === threadId), + Stream.takeUntil((event) => event.type === "turn.completed"), Stream.runCollect, Effect.forkChild, ); @@ -258,6 +293,8 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { assert.isDefined(delta); if (delta?.type === "content.delta") { assert.equal(delta.payload.delta, "hello from mock"); + // The middle segment is a per-run id: it keeps a resumed session from + // reusing the item ids of its earlier runs. assert.match(String(delta.itemId), /^assistant:mock-session-1:runtime:[^:]+:segment:0$/); } @@ -320,7 +357,16 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { [ { prompt: [{ type: "text", text: "please /review this" }], - result: { stopReason: "end_turn" }, + result: { + stopReason: "end_turn", + usage: { + cachedReadTokens: 200, + inputTokens: 1000, + outputTokens: 400, + thoughtTokens: 100, + totalTokens: 1500, + }, + }, }, ], ], @@ -446,7 +492,7 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { yield* adapter.stopSession(threadId); - const exitLog = yield* Effect.promise(() => waitForFileContent(exitLogPath)); + const exitLog = yield* waitForFileContent(exitLogPath); assert.include(exitLog, "SIGTERM"); }), ); @@ -498,7 +544,7 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { yield* adapter.stopSession(threadId); - const exitLog = yield* Effect.promise(() => waitForFileContent(exitLogPath)); + const exitLog = yield* waitForFileContent(exitLogPath); assert.equal(exitLog.match(/SIGTERM/g)?.length ?? 0, 2); }), ); @@ -609,7 +655,7 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { modelSelection, }); - yield* Effect.promise(() => waitForFileContent(requestLogPath)); + yield* waitForFileContent(requestLogPath); const requestsAfterStart = yield* Effect.promise(() => readJsonLines(requestLogPath)); const configIdsAfterStart = requestsAfterStart.flatMap((entry) => @@ -618,13 +664,16 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { ? [String((entry.params as Record).configId)] : [], ); - assert.deepStrictEqual(configIdsAfterStart, [ - "model", - "reasoning", - "context", - "fast", - "mode", - ]); + assert.deepStrictEqual(configIdsAfterStart, ["model", "reasoning", "context", "fast"]); + const modeIdsAfterStart = requestsAfterStart + .filter((entry) => entry.method === "session/set_mode") + .map((entry) => { + const params = entry.params as Record | undefined; + return typeof params?.modeId === "string" ? params.modeId : undefined; + }) + .filter((modeId): modeId is string => modeId !== undefined); + assert.isAbove(modeIdsAfterStart.length, 0); + assert.include(["code", "agent", "default", "chat", "implement"], modeIdsAfterStart[0]); yield* adapter.sendTurn({ threadId, @@ -642,7 +691,16 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { ? [String((entry.params as Record).configId)] : [], ); - assert.deepStrictEqual(finalConfigIds, ["model", "reasoning", "context", "fast", "mode"]); + assert.deepStrictEqual(finalConfigIds, ["model", "reasoning", "context", "fast"]); + const finalModeIds = finalRequests + .filter((entry) => entry.method === "session/set_mode") + .map((entry) => { + const params = entry.params as Record | undefined; + return typeof params?.modeId === "string" ? params.modeId : undefined; + }) + .filter((modeId): modeId is string => modeId !== undefined); + // Mode is applied once at startSession; first sendTurn is a no-op when already set. + assert.deepStrictEqual(finalModeIds, modeIdsAfterStart); assert.equal(finalRequests.filter((entry) => entry.method === "session/prompt").length, 1); }), ); @@ -780,6 +838,8 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { if (contentDelta?.type === "content.delta") { assert.equal(String(contentDelta.turnId), String(turn.turnId)); assert.equal(contentDelta.payload.delta, "hello from mock"); + // The middle segment is a per-run id: it keeps a resumed session + // from reusing the item ids of its earlier runs. assert.match( String(contentDelta.itemId), /^assistant:mock-session-1:runtime:[^:]+:segment:0$/, @@ -1143,6 +1203,44 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => { yield* adapter.stopSession(threadId); }), ); + + it.effect("removes the session and emits session.exited when the ACP process dies", () => + Effect.gen(function* () { + const adapter = yield* CursorAdapter; + const serverSettings = yield* ServerSettingsService; + const threadId = ThreadId.make("cursor-process-exit"); + const wrapperPath = yield* Effect.promise(() => + makeMockAgentWrapper({ T3_ACP_EXIT_AFTER_PROMPT: "1" }), + ); + yield* serverSettings.updateSettings({ providers: { cursor: { binaryPath: wrapperPath } } }); + + const sessionExited = yield* Deferred.make(); + yield* Stream.runForEach(adapter.streamEvents, (event) => + String(event.threadId) === String(threadId) && event.type === "session.exited" + ? Deferred.succeed(sessionExited, event).pipe(Effect.ignore) + : Effect.void, + ).pipe(Effect.forkChild); + + yield* adapter.startSession({ + threadId, + provider: ProviderDriverKind.make("cursor"), + cwd: process.cwd(), + runtimeMode: "approval-required", + modelSelection: { instanceId: ProviderInstanceId.make("cursor"), model: "default" }, + }); + + yield* adapter + .sendTurn({ threadId, input: "exit now", attachments: [] }) + .pipe(Effect.exit, Effect.timeout("5 seconds")); + const event = yield* Deferred.await(sessionExited).pipe(Effect.timeout("5 seconds")); + + assert.equal(event.type, "session.exited"); + if (event.type === "session.exited") { + assert.equal(event.payload.exitKind, "error"); + } + assert.equal(yield* adapter.hasSession(threadId), false); + }), + ); it.effect("stopping a session settles pending approval waits", () => Effect.gen(function* () { const adapter = yield* CursorAdapter; diff --git a/apps/server/src/provider/Layers/CursorAdapter.ts b/apps/server/src/provider/Layers/CursorAdapter.ts index b19d46112fde..dbe3da77dd3c 100644 --- a/apps/server/src/provider/Layers/CursorAdapter.ts +++ b/apps/server/src/provider/Layers/CursorAdapter.ts @@ -1,5 +1,5 @@ /** - * CursorAdapterLive — Cursor CLI (`agent acp`) via ACP. + * Shared adapter for ACP-backed CLI providers. * * @module CursorAdapterLive */ @@ -24,6 +24,7 @@ import { import * as DateTime from "effect/DateTime"; import * as Crypto from "effect/Crypto"; import * as Deferred from "effect/Deferred"; +import type * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; import * as Fiber from "effect/Fiber"; @@ -58,7 +59,10 @@ import { makeAcpPlanUpdatedEvent, makeAcpRequestOpenedEvent, makeAcpRequestResolvedEvent, + makeAcpTokenUsageUpdatedEvent, makeAcpToolCallEvent, + normalizeAcpPromptUsage, + normalizeAcpUsageUpdate, } from "../acp/AcpCoreRuntimeEvents.ts"; import { type AcpSessionMode, @@ -66,7 +70,11 @@ import { parsePermissionRequest, } from "../acp/AcpRuntimeModel.ts"; import { makeAcpNativeLoggerFactory } from "../acp/AcpNativeLogging.ts"; -import { applyCursorAcpModelSelection, makeCursorAcpRuntime } from "../acp/CursorAcpSupport.ts"; +import { + applyCursorAcpModelSelection, + makeCursorAcpRuntime, + type CursorAcpRuntimeInput, +} from "../acp/CursorAcpSupport.ts"; import { CursorTransportFailure } from "../acp/CursorTransportFailure.ts"; import { CursorAskQuestionRequest, @@ -77,6 +85,7 @@ import { extractTodosAsPlan, } from "../acp/CursorAcpExtension.ts"; import { type CursorAdapterShape } from "../Services/CursorAdapter.ts"; +import { type DirenvEnvironment, resolveProviderSessionEnvironment } from "../DirenvEnvironment.ts"; import { resolveCursorAcpBaseModelId } from "./CursorProvider.ts"; import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; import { @@ -86,7 +95,6 @@ import { } from "../Drivers/CursorSkills.ts"; const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); -const PROVIDER = ProviderDriverKind.make("cursor"); const CURSOR_RESUME_VERSION = 1 as const; const ACP_PLAN_MODE_ALIASES = ["plan", "architect"]; const ACP_IMPLEMENT_MODE_ALIASES = ["code", "agent", "default", "chat", "implement"]; @@ -97,8 +105,45 @@ function encodeJsonStringForDiagnostics(input: unknown): string | undefined { return Exit.isSuccess(result) ? result.value : undefined; } -export interface CursorAdapterLiveOptions { +interface AcpCliAdapterSettings { + readonly binaryPath: string; +} + +type AcpRuntimeInput = Omit; + +interface AcpModelSelectionErrorContext { + readonly cause: EffectAcpErrors.AcpError; + readonly step: "set-config-option" | "set-model"; + readonly configId?: string; +} + +export interface AcpCliAdapterDefinition { + readonly provider: ProviderDriverKind; + readonly providerName: string; + readonly defaultInstanceId: ProviderInstanceId; + readonly makeRuntime: ( + settings: Settings, + input: AcpRuntimeInput, + ) => Effect.Effect< + AcpSessionRuntime.AcpSessionRuntime["Service"], + EffectAcpErrors.AcpError, + Crypto.Crypto | Scope.Scope + >; + readonly applyModelSelection: (input: { + readonly runtime: AcpSessionRuntime.AcpSessionRuntime["Service"]; + readonly model: string | null | undefined; + readonly selections: ReadonlyArray | null | undefined; + readonly mapError: (context: AcpModelSelectionErrorContext) => E; + }) => Effect.Effect; + readonly resolveModelId: (model: string | null | undefined) => string; + readonly registerCursorExtensions?: boolean; + /** Wait for agents that deliver final session updates after `session/prompt` resolves. */ + readonly turnCompletionSettleDelay?: Duration.Input; +} + +export interface AcpCliAdapterOptions { readonly environment?: NodeJS.ProcessEnv; + readonly resolveEnvironment?: DirenvEnvironment["Service"]["resolve"]; readonly nativeEventLogPath?: string; readonly nativeEventLogger?: EventNdjsonLogger; /** @@ -117,7 +162,16 @@ export interface CursorAdapterLiveOptions { * swap `binaryPath` to a mock ACP wrapper — pass a resolver that reads * the latest snapshot so the closure isn't stale. */ - readonly resolveSettings?: Effect.Effect; + readonly resolveSettings?: Effect.Effect; +} + +export interface CursorAdapterLiveOptions extends AcpCliAdapterOptions {} + +export function settleAcpTurnCompletion( + runtime: Pick, + delay: Duration.Input, +): Effect.Effect { + return Effect.sleep(delay).pipe(Effect.andThen(runtime.drainEvents)); } interface PendingApproval { @@ -147,6 +201,8 @@ interface CursorSessionContext { promptsInFlight: number; assistantReply: CursorTransportFailure; stopped: boolean; + /** Last `usedTokens` emitted so repeated `_meta.totalTokens` updates do not flood activities. */ + lastEmittedUsedTokens: number | undefined; } function settlePendingApprovalsAsCancelled( @@ -264,6 +320,7 @@ function applyRequestedSessionConfiguration(input: { readonly options?: ReadonlyArray | null | undefined; } | undefined; + readonly applyModelSelection: AcpCliAdapterDefinition["applyModelSelection"]; readonly mapError: (context: { readonly cause: import("effect-acp/errors").AcpError; readonly method: "session/set_config_option" | "session/set_mode"; @@ -271,7 +328,7 @@ function applyRequestedSessionConfiguration(input: { }): Effect.Effect { return Effect.gen(function* () { if (input.modelSelection) { - yield* applyCursorAcpModelSelection({ + yield* input.applyModelSelection({ runtime: input.runtime, model: input.modelSelection.model, selections: input.modelSelection.options, @@ -319,12 +376,14 @@ function selectAutoApprovedPermissionOption( return undefined; } -export function makeCursorAdapter( - cursorSettings: CursorSettings, - options?: CursorAdapterLiveOptions, +export function makeAcpCliAdapter( + initialSettings: Settings, + definition: AcpCliAdapterDefinition, + options?: AcpCliAdapterOptions, ) { return Effect.gen(function* () { - const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("cursor"); + const PROVIDER = definition.provider; + const boundInstanceId = options?.instanceId ?? definition.defaultInstanceId; const fileSystem = yield* FileSystem.FileSystem; const path = yield* Path.Path; const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; @@ -352,7 +411,7 @@ export function makeCursorAdapter( new ProviderAdapterRequestError({ provider: PROVIDER, method: "crypto/randomUUIDv4", - detail: "Failed to generate Cursor runtime identifier.", + detail: `Failed to generate ${definition.providerName} runtime identifier.`, cause, }), ), @@ -364,7 +423,7 @@ export function makeCursorAdapter( Effect.mapError( (cause) => new EffectAcpErrors.AcpTransportError({ - detail: "Failed to process Cursor ACP extension event.", + detail: `Failed to process ${definition.providerName} ACP extension event.`, cause, }), ), @@ -485,6 +544,45 @@ export function makeCursorAdapter( }); }); + const handleUnexpectedProcessExit = Effect.fn("handleUnexpectedAcpProcessExit")(function* ( + ctx: CursorSessionContext, + exitCode: number | undefined, + ) { + yield* withThreadLock( + ctx.threadId, + Effect.gen(function* () { + if (ctx.stopped) return; + ctx.stopped = true; + yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals); + yield* settlePendingUserInputsAsEmptyAnswers(ctx.pendingUserInputs); + sessions.delete(ctx.threadId); + const reason = + exitCode === undefined + ? `${definition.providerName} ACP process exited unexpectedly.` + : `${definition.providerName} ACP process exited unexpectedly with code ${exitCode}.`; + yield* offerRuntimeEvent({ + type: "runtime.error", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: ctx.threadId, + turnId: ctx.activeTurnId, + payload: { message: reason, class: "transport_error" }, + }); + yield* offerRuntimeEvent({ + type: "session.exited", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: ctx.threadId, + turnId: ctx.activeTurnId, + payload: { reason, recoverable: true, exitKind: "error" }, + }); + // Events must be published before closing the scope because this + // watcher is itself owned by the session scope. + yield* Scope.close(ctx.scope, Exit.void); + }), + ); + }); + const startSession: CursorAdapterShape["startSession"] = (input) => withThreadLock( input.threadId, @@ -505,7 +603,24 @@ export function makeCursorAdapter( } const cwd = path.resolve(input.cwd.trim()); - const cursorModelSelection = + const environment = yield* resolveProviderSessionEnvironment({ + resolve: options?.resolveEnvironment, + provider: PROVIDER, + threadId: input.threadId, + cwd, + environment: options?.environment ?? process.env, + }).pipe( + Effect.mapError( + (cause) => + new ProviderAdapterProcessError({ + provider: definition.provider, + threadId: input.threadId, + detail: cause.message, + cause, + }), + ), + ); + const providerModelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : undefined; const existing = sessions.get(input.threadId); if (existing && !existing.stopped) { @@ -536,150 +651,152 @@ export function makeCursorAdapter( // snapshot from `ServerSettingsService` so that mid-suite // `updateSettings({ providers: { cursor: { binaryPath } } })` calls // actually take effect when the next session spawns. - const effectiveCursorSettings = options?.resolveSettings + const effectiveSettings = options?.resolveSettings ? yield* options.resolveSettings - : cursorSettings; + : initialSettings; const mcpSession = McpProviderSession.readMcpProviderSession(input.threadId); - const acp = yield* makeCursorAcpRuntime({ - cursorSettings: effectiveCursorSettings, - ...(options?.environment || mcpSession?.agentDeviceEnvironment - ? { - environment: McpProviderSession.withAgentDeviceEnvironment( - options?.environment ?? process.env, - mcpSession, - ), - } - : {}), - childProcessSpawner, - cwd, - runtimeMode: input.runtimeMode, - ...(resumeSessionId ? { resumeSessionId } : {}), - clientInfo: { name: "t3-code", version: "0.0.0" }, - ...(mcpSession - ? { - mcpServers: [ - { - type: "http" as const, - name: "t3-code", - url: mcpSession.endpoint, - headers: [ - { - name: "Authorization", - value: mcpSession.authorizationHeader, - }, - ], - }, - ], - } - : {}), - ...acpNativeLoggers, - }).pipe( - Effect.provideService(Crypto.Crypto, crypto), - Effect.provideService(Scope.Scope, sessionScope), - Effect.mapError( - (cause) => - new ProviderAdapterProcessError({ - provider: PROVIDER, - threadId: input.threadId, - detail: cause.message, - cause, - }), - ), - ); - const started = yield* Effect.gen(function* () { - yield* acp.handleExtRequest("cursor/ask_question", CursorAskQuestionRequest, (params) => - mapExtensionFailure( - Effect.gen(function* () { - yield* logNative( - input.threadId, - "cursor/ask_question", - params, - "acp.cursor.extension", - ); - const requestId = ApprovalRequestId.make(yield* randomUUIDv4); - const runtimeRequestId = RuntimeRequestId.make(requestId); - const answers = yield* Deferred.make(); - pendingUserInputs.set(requestId, { answers }); - yield* offerRuntimeEvent({ - type: "user-input.requested", - ...(yield* makeEventStamp()), - provider: PROVIDER, - threadId: input.threadId, - turnId: ctx?.activeTurnId, - requestId: runtimeRequestId, - payload: { questions: extractAskQuestions(params) }, - raw: { - source: "acp.cursor.extension", - method: "cursor/ask_question", - payload: params, - }, - }); - const resolved = yield* Deferred.await(answers); - pendingUserInputs.delete(requestId); - yield* offerRuntimeEvent({ - type: "user-input.resolved", - ...(yield* makeEventStamp()), - provider: PROVIDER, - threadId: input.threadId, - turnId: ctx?.activeTurnId, - requestId: runtimeRequestId, - payload: { answers: resolved }, - }); - return { answers: resolved }; - }), + const acp = yield* definition + .makeRuntime(effectiveSettings, { + environment: McpProviderSession.withAgentDeviceEnvironment( + environment ?? options?.environment ?? process.env, + mcpSession, ), - ); - yield* acp.handleExtRequest("cursor/create_plan", CursorCreatePlanRequest, (params) => - mapExtensionFailure( - Effect.gen(function* () { - yield* logNative( - input.threadId, - "cursor/create_plan", - params, - "acp.cursor.extension", - ); - yield* offerRuntimeEvent({ - type: "turn.proposed.completed", - ...(yield* makeEventStamp()), + childProcessSpawner, + cwd, + runtimeMode: input.runtimeMode, + ...(resumeSessionId ? { resumeSessionId } : {}), + clientInfo: { name: "t3-code", version: "0.0.0" }, + ...(mcpSession + ? { + mcpServers: [ + { + type: "http" as const, + name: "t3-code", + url: mcpSession.endpoint, + headers: [ + { + name: "Authorization", + value: mcpSession.authorizationHeader, + }, + ], + }, + ], + } + : {}), + ...acpNativeLoggers, + }) + .pipe( + Effect.provideService(Crypto.Crypto, crypto), + Effect.provideService(Scope.Scope, sessionScope), + Effect.mapError( + (cause) => + new ProviderAdapterProcessError({ provider: PROVIDER, threadId: input.threadId, - turnId: ctx?.activeTurnId, - payload: { planMarkdown: extractPlanMarkdown(params) }, - raw: { - source: "acp.cursor.extension", - method: "cursor/create_plan", - payload: params, - }, - }); - return { accepted: true } as const; - }), + detail: cause.message, + cause, + }), ), ); - yield* acp.handleExtNotification( - "cursor/update_todos", - CursorUpdateTodosRequest, - (params) => + const started = yield* Effect.gen(function* () { + if (definition.registerCursorExtensions) { + yield* acp.handleExtRequest( + "cursor/ask_question", + CursorAskQuestionRequest, + (params) => + mapExtensionFailure( + Effect.gen(function* () { + yield* logNative( + input.threadId, + "cursor/ask_question", + params, + "acp.cursor.extension", + ); + const requestId = ApprovalRequestId.make(yield* randomUUIDv4); + const runtimeRequestId = RuntimeRequestId.make(requestId); + const answers = yield* Deferred.make(); + pendingUserInputs.set(requestId, { answers }); + yield* offerRuntimeEvent({ + type: "user-input.requested", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + turnId: ctx?.activeTurnId, + requestId: runtimeRequestId, + payload: { questions: extractAskQuestions(params) }, + raw: { + source: "acp.cursor.extension", + method: "cursor/ask_question", + payload: params, + }, + }); + const resolved = yield* Deferred.await(answers); + pendingUserInputs.delete(requestId); + yield* offerRuntimeEvent({ + type: "user-input.resolved", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + turnId: ctx?.activeTurnId, + requestId: runtimeRequestId, + payload: { answers: resolved }, + }); + return { answers: resolved }; + }), + ), + ); + yield* acp.handleExtRequest("cursor/create_plan", CursorCreatePlanRequest, (params) => mapExtensionFailure( Effect.gen(function* () { yield* logNative( input.threadId, - "cursor/update_todos", + "cursor/create_plan", params, "acp.cursor.extension", ); - if (ctx) { - yield* emitPlanUpdate( - ctx, - extractTodosAsPlan(params), + yield* offerRuntimeEvent({ + type: "turn.proposed.completed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + turnId: ctx?.activeTurnId, + payload: { planMarkdown: extractPlanMarkdown(params) }, + raw: { + source: "acp.cursor.extension", + method: "cursor/create_plan", + payload: params, + }, + }); + return { accepted: true } as const; + }), + ), + ); + yield* acp.handleExtNotification( + "cursor/update_todos", + CursorUpdateTodosRequest, + (params) => + mapExtensionFailure( + Effect.gen(function* () { + yield* logNative( + input.threadId, + "cursor/update_todos", params, "acp.cursor.extension", - "cursor/update_todos", ); - } - }), - ), - ); + if (ctx) { + yield* emitPlanUpdate( + ctx, + extractTodosAsPlan(params), + params, + "acp.cursor.extension", + "cursor/update_todos", + ); + } + }), + ), + ); + } yield* acp.handleRequestPermission((params) => mapExtensionFailure( Effect.gen(function* () { @@ -762,7 +879,8 @@ export function makeCursorAdapter( runtime: acp, runtimeMode: input.runtimeMode, interactionMode: undefined, - modelSelection: cursorModelSelection, + modelSelection: providerModelSelection, + applyModelSelection: definition.applyModelSelection, mapError: ({ cause, method }) => mapAcpToAdapterError(PROVIDER, input.threadId, method, cause), }); @@ -774,7 +892,7 @@ export function makeCursorAdapter( status: "ready", runtimeMode: input.runtimeMode, cwd, - model: cursorModelSelection?.model, + model: providerModelSelection?.model, threadId: input.threadId, resumeCursor: { schemaVersion: CURSOR_RESUME_VERSION, @@ -799,8 +917,14 @@ export function makeCursorAdapter( promptsInFlight: 0, assistantReply: new CursorTransportFailure(), stopped: false, + lastEmittedUsedTokens: undefined, }; + yield* acp.processExit.pipe( + Effect.flatMap((exitCode) => handleUnexpectedProcessExit(ctx, exitCode)), + Effect.forkIn(sessionScope), + ); + const nf = yield* Stream.runDrain( Stream.mapEffect(acp.getEvents(), (event) => Effect.gen(function* () { @@ -888,12 +1012,44 @@ export function makeCursorAdapter( }), ); return; + case "UsageUpdated": { + yield* logNative( + ctx.threadId, + "session/update", + event.rawPayload, + "acp.jsonrpc", + ); + const usage = normalizeAcpUsageUpdate({ + used: event.used, + ...(event.size !== undefined ? { size: event.size } : {}), + }); + if (usage !== undefined && usage.usedTokens !== ctx.lastEmittedUsedTokens) { + ctx.lastEmittedUsedTokens = usage.usedTokens; + yield* offerRuntimeEvent( + makeAcpTokenUsageUpdatedEvent({ + stamp: yield* makeEventStamp(), + provider: PROVIDER, + threadId: ctx.threadId, + turnId: ctx.activeTurnId, + usage, + method: "session/update", + rawPayload: event.rawPayload, + }), + ); + } + return; + } } }), ), ).pipe( Effect.catch((cause) => - Effect.logError("Failed to process Cursor runtime notification.", { cause }), + Effect.logError( + `Failed to process ${definition.providerName} runtime notification.`, + { + cause, + }, + ), ), // Fork into the session scope, not the calling fiber. `forkChild` // makes this a child of `startSession`, and Effect interrupts a @@ -920,7 +1076,7 @@ export function makeCursorAdapter( ...(yield* makeEventStamp()), provider: PROVIDER, threadId: input.threadId, - payload: { state: "ready", reason: "Cursor ACP session ready" }, + payload: { state: "ready", reason: `${definition.providerName} ACP session ready` }, }); yield* offerRuntimeEvent({ type: "thread.started", @@ -951,7 +1107,7 @@ export function makeCursorAdapter( const turnModelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : undefined; const model = turnModelSelection?.model ?? ctx.session.model; - const resolvedModel = resolveCursorAcpBaseModelId(model); + const resolvedModel = definition.resolveModelId(model); yield* applyRequestedSessionConfiguration({ runtime: ctx.acp, runtimeMode: ctx.session.runtimeMode, @@ -963,6 +1119,7 @@ export function makeCursorAdapter( model, options: turnModelSelection?.options, }, + applyModelSelection: definition.applyModelSelection, mapError: ({ cause, method }) => mapAcpToAdapterError(PROVIDER, input.threadId, method, cause), }); @@ -1098,10 +1255,36 @@ export function makeCursorAdapter( model: resolvedModel, }; + // Some agents resolve `session/prompt` before their final session updates arrive. + // Keep the turn running through the provider-specific settlement window, then + // drain every queued update before publishing completion. + if (result.stopReason !== "cancelled") { + if (definition.turnCompletionSettleDelay !== undefined) { + yield* settleAcpTurnCompletion(ctx.acp, definition.turnCompletionSettleDelay); + } else { + yield* ctx.acp.drainEvents; + } + } + // Only the last remaining prompt settles the turn — a steer- // superseded prompt resolving (usually cancelled) while another is // in flight or pending must leave the merged turn running. if (ctx.promptsInFlight === 1) { + const promptUsage = normalizeAcpPromptUsage(result.usage); + if (promptUsage !== undefined) { + ctx.lastEmittedUsedTokens = promptUsage.usedTokens; + yield* offerRuntimeEvent( + makeAcpTokenUsageUpdatedEvent({ + stamp: yield* makeEventStamp(), + provider: PROVIDER, + threadId: input.threadId, + turnId, + usage: promptUsage, + method: "session/prompt", + rawPayload: result, + }), + ); + } yield* offerRuntimeEvent({ type: "turn.completed", ...(yield* makeEventStamp()), @@ -1111,6 +1294,9 @@ export function makeCursorAdapter( payload: { state: result.stopReason === "cancelled" ? "cancelled" : "completed", stopReason: result.stopReason ?? null, + ...(result.usage !== undefined && result.usage !== null + ? { usage: result.usage } + : {}), }, }); } @@ -1172,7 +1358,9 @@ export function makeCursorAdapter( if (!pending) { return yield* new ProviderAdapterRequestError({ provider: PROVIDER, - method: "cursor/ask_question", + method: definition.registerCursorExtensions + ? "cursor/ask_question" + : "session/request_permission", detail: `Unknown pending user-input request: ${requestId}`, }); } @@ -1224,7 +1412,9 @@ export function makeCursorAdapter( yield* Effect.addFinalizer(() => Effect.forEach(sessions.values(), stopSessionInternal, { discard: true }).pipe( Effect.catch((cause) => - Effect.logError("Failed to emit Cursor session shutdown event.", { cause }), + Effect.logError(`Failed to emit ${definition.providerName} session shutdown event.`, { + cause, + }), ), Effect.tap(() => PubSub.shutdown(runtimeEventPubSub)), Effect.tap(() => managedNativeEventLogger?.close() ?? Effect.void), @@ -1252,3 +1442,23 @@ export function makeCursorAdapter( } satisfies CursorAdapterShape; }); } + +export function makeCursorAdapter( + cursorSettings: CursorSettings, + options?: CursorAdapterLiveOptions, +) { + return makeAcpCliAdapter( + cursorSettings, + { + provider: ProviderDriverKind.make("cursor"), + providerName: "Cursor", + defaultInstanceId: ProviderInstanceId.make("cursor"), + makeRuntime: (settings, input) => + makeCursorAcpRuntime({ ...input, cursorSettings: settings }), + applyModelSelection: applyCursorAcpModelSelection, + resolveModelId: resolveCursorAcpBaseModelId, + registerCursorExtensions: true, + }, + options, + ); +} diff --git a/apps/server/src/provider/Layers/CursorProvider.ts b/apps/server/src/provider/Layers/CursorProvider.ts index cf4f00ac967a..7d6d035846a1 100644 --- a/apps/server/src/provider/Layers/CursorProvider.ts +++ b/apps/server/src/provider/Layers/CursorProvider.ts @@ -11,6 +11,7 @@ import type { import type * as EffectAcpSchema from "effect-acp/schema"; import { causeErrorTag } from "@t3tools/shared/observability"; import * as Cache from "effect/Cache"; +import * as Cause from "effect/Cause"; import * as Duration from "effect/Duration"; import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; @@ -1112,8 +1113,39 @@ export const checkCursorProviderStatus = Effect.fn("checkCursorProviderStatus")( ).pipe(Effect.timeoutOption(CURSOR_ACP_MODEL_DISCOVERY_TIMEOUT_MS)), ); if (Exit.isFailure(discoveryExit)) { + const _dumpCauseChain = (root: unknown): string => { + const seen = new Set(); + const parts: Array = []; + let node: unknown = root; + let depth = 0; + while (node && typeof node === "object" && !seen.has(node) && depth < 12) { + seen.add(node); + const n = node as Record; + const keys = [ + "_tag", + "message", + "code", + "exitCode", + "operation", + "method", + "pid", + "reason", + "detail", + ]; + const flat: Record = {}; + for (const k of keys) { + if (k in n && k !== "reason" && k !== "cause") flat[k] = n[k]; + } + parts.push(JSON.stringify(flat)); + node = n["reason"] ?? n["cause"]; + depth++; + } + return parts.join(" -> "); + }; yield* Effect.logWarning("Cursor ACP model discovery failed", { errorTag: causeErrorTag(discoveryExit.cause), + causeChain: _dumpCauseChain(Cause.squash(discoveryExit.cause)), + causeDetail: Cause.pretty(discoveryExit.cause), }); discoveryWarning = CURSOR_ACP_MODEL_DISCOVERY_FAILED_MESSAGE; } else if (Option.isNone(discoveryExit.value)) { diff --git a/apps/server/src/provider/Layers/GrokAdapter.test.ts b/apps/server/src/provider/Layers/GrokAdapter.test.ts index 41fa6ed0f60a..2ae959c4ba5f 100644 --- a/apps/server/src/provider/Layers/GrokAdapter.test.ts +++ b/apps/server/src/provider/Layers/GrokAdapter.test.ts @@ -246,13 +246,31 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => { [ { prompt: [{ type: "text", text: "First prompt" }], - result: { stopReason: "end_turn" }, + result: { + stopReason: "end_turn", + usage: { + cachedReadTokens: 200, + inputTokens: 1000, + outputTokens: 400, + thoughtTokens: 100, + totalTokens: 1500, + }, + }, }, ], [ { prompt: [{ type: "text", text: "Second prompt" }], - result: { stopReason: "end_turn" }, + result: { + stopReason: "end_turn", + usage: { + cachedReadTokens: 200, + inputTokens: 1000, + outputTokens: 400, + thoughtTokens: 100, + totalTokens: 1500, + }, + }, }, ], ], @@ -518,9 +536,13 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => { }); yield* Deferred.await(turnCompleted); - for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) { + for (let yieldAttempt = 0; yieldAttempt < 32; yieldAttempt += 1) { yield* Effect.yieldNow; } + // The mock writes "mock" after prompt_complete on the same stdout + // burst. Under CI load the JSON-RPC reader can lag the settlement + // fiber; wait live so that last chunk is applied before we assert. + yield* Effect.sleep("50 millis").pipe(TestClock.withLive); const readySessions = yield* adapter.listSessions(); const readySession = readySessions.find((session) => session.threadId === threadId); const turnCompletedEvent = runtimeEvents.find( @@ -934,9 +956,9 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => { }), ); const adapter = yield* makeTestAdapter(wrapperPath); - const contentDelta = yield* Deferred.make(); + const turnCompleted = yield* Deferred.make(); const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) => - event.type === "content.delta" ? Deferred.succeed(contentDelta, undefined) : Effect.void, + event.type === "turn.completed" ? Deferred.succeed(turnCompleted, undefined) : Effect.void, ).pipe(Effect.forkChild); yield* adapter.startSession({ @@ -955,10 +977,11 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => { }) .pipe(Effect.forkChild); - yield* Deferred.await(contentDelta); - for (let yieldAttempt = 0; yieldAttempt < 6; yieldAttempt += 1) { - yield* Effect.yieldNow; - } + // First content.delta is written before prompt_complete. Interrupting + // there races the fallback: under CI load the JSON-RPC reader can still + // be behind, promptRpcSucceeded is false, and the ensuring path drops + // the transcript. Wait for turn.completed — that is prompt success. + yield* Deferred.await(turnCompleted).pipe(Effect.timeout("2 seconds"), TestClock.withLive); yield* Fiber.interrupt(sendTurnFiber); for (let yieldAttempt = 0; yieldAttempt < 4; yieldAttempt += 1) { yield* Effect.yieldNow; diff --git a/apps/server/src/provider/Layers/GrokAdapter.ts b/apps/server/src/provider/Layers/GrokAdapter.ts index a2f78a0d72d1..d9c5c25a9567 100644 --- a/apps/server/src/provider/Layers/GrokAdapter.ts +++ b/apps/server/src/provider/Layers/GrokAdapter.ts @@ -56,17 +56,21 @@ import { makeAcpPlanUpdatedEvent, makeAcpRequestOpenedEvent, makeAcpRequestResolvedEvent, + makeAcpTokenUsageUpdatedEvent, makeAcpToolCallEvent, + normalizeAcpUsageUpdate, } from "../acp/AcpCoreRuntimeEvents.ts"; import { parsePermissionRequest } from "../acp/AcpRuntimeModel.ts"; import { makeAcpNativeLoggerFactory } from "../acp/AcpNativeLogging.ts"; import { applyGrokAcpModelSelection, + applyGrokAcpSessionMode, currentGrokModelIdFromSessionSetup, currentGrokReasoningEffortFromSessionSetup, makeGrokAcpRuntime, normalizeGrokReasoningEffort, resolveGrokAcpBaseModelId, + resolveGrokReasoningEffortFromModelSelection, } from "../acp/GrokAcpSupport.ts"; import { extractGrokPlanMarkdownFromToolCallData, @@ -80,12 +84,15 @@ import { XAiExitPlanModeRequest, } from "../acp/XAiAcpExtension.ts"; import { type GrokAdapterShape } from "../Services/GrokAdapter.ts"; +import { type DirenvEnvironment, resolveProviderSessionEnvironment } from "../DirenvEnvironment.ts"; import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const PROVIDER = ProviderDriverKind.make("grok"); const GROK_RESUME_VERSION = 1 as const; +/** 128 + signal: SIGINT (130) and SIGTERM (143) mean the child was signalled down with us. */ +const SIGNAL_TERMINATION_EXIT_CODES = new Set([130, 143]); const NANOS_PER_MILLI = 1_000_000n; // ACP does not expose Grok's private `streaming_reasoning` phase. Once it has // emitted standard ACP progress, ten silent minutes is long enough to avoid @@ -103,6 +110,7 @@ function encodeJsonStringForDiagnostics(input: unknown): string | undefined { export interface GrokAdapterLiveOptions { readonly environment?: NodeJS.ProcessEnv; + readonly resolveEnvironment?: DirenvEnvironment["Service"]["resolve"]; readonly nativeEventLogPath?: string; readonly nativeEventLogger?: EventNdjsonLogger; readonly instanceId?: ProviderInstanceId; @@ -171,6 +179,7 @@ interface GrokSessionContext { currentModelId: string | undefined; currentReasoningEffort: string | undefined; stopped: boolean; + lastEmittedUsedTokens: number | undefined; } function settlePendingApprovalsAsCancelled( @@ -943,6 +952,72 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte }); }); + // Surface an unexpected grok-child exit instead of leaving the thread stuck + // in a silent "running" state. Without this the notification stream simply + // starves — no error, no completion — and the UI shows a live-looking thread + // that never advances. Mirrors CursorAdapter.handleUnexpectedProcessExit. + const handleUnexpectedProcessExit = Effect.fn("handleUnexpectedGrokProcessExit")(function* ( + ctx: GrokSessionContext, + exitCode: number | undefined, + ) { + yield* withThreadLock( + ctx.threadId, + Effect.gen(function* () { + if (ctx.stopped) return; + ctx.stopped = true; + if (exitCode !== undefined && SIGNAL_TERMINATION_EXIT_CODES.has(exitCode)) { + yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals); + yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs); + if (ctx.notificationFiber) { + yield* Fiber.interrupt(ctx.notificationFiber); + } + sessions.delete(ctx.threadId); + yield* offerRuntimeEvent({ + type: "session.exited", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: ctx.threadId, + ...(ctx.activeTurnId !== undefined ? { turnId: ctx.activeTurnId } : {}), + payload: { + reason: "Grok ACP process terminated by signal.", + recoverable: true, + exitKind: "graceful", + }, + }); + yield* Effect.ignore(Scope.close(ctx.scope, Exit.void)); + return; + } + yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals); + yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs); + if (ctx.notificationFiber) { + yield* Fiber.interrupt(ctx.notificationFiber); + } + sessions.delete(ctx.threadId); + const reason = + exitCode === undefined + ? "Grok ACP process exited unexpectedly." + : `Grok ACP process exited unexpectedly with code ${exitCode}.`; + yield* offerRuntimeEvent({ + type: "runtime.error", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: ctx.threadId, + turnId: ctx.activeTurnId, + payload: { message: reason, class: "transport_error" }, + }); + yield* offerRuntimeEvent({ + type: "session.exited", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: ctx.threadId, + turnId: ctx.activeTurnId, + payload: { reason, recoverable: true, exitKind: "error" }, + }); + yield* Effect.ignore(Scope.close(ctx.scope, Exit.void)); + }), + ); + }); + const startSession: GrokAdapterShape["startSession"] = (input) => withThreadLock( input.threadId, @@ -963,6 +1038,13 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte } const cwd = path.resolve(input.cwd.trim()); + const environment = yield* resolveProviderSessionEnvironment({ + resolve: options?.resolveEnvironment, + provider: PROVIDER, + threadId: input.threadId, + cwd, + environment: options?.environment ?? process.env, + }); const grokModelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : undefined; const existing = sessions.get(input.threadId); @@ -987,20 +1069,19 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte }); const mcpSession = McpProviderSession.readMcpProviderSession(input.threadId); + const startReasoningEffort = + resolveGrokReasoningEffortFromModelSelection(grokModelSelection); const acp = yield* makeGrokAcpRuntime({ grokSettings, - ...(options?.environment || mcpSession?.agentDeviceEnvironment - ? { - environment: McpProviderSession.withAgentDeviceEnvironment( - options?.environment ?? process.env, - mcpSession, - ), - } - : {}), + environment: McpProviderSession.withAgentDeviceEnvironment( + environment ?? options?.environment ?? process.env, + mcpSession, + ), childProcessSpawner, cwd, runtimeMode: input.runtimeMode, ...(resumeSessionId ? { resumeSessionId } : {}), + ...(startReasoningEffort ? { reasoningEffort: startReasoningEffort } : {}), clientInfo: { name: "t3-code", version: "0.0.0" }, ...(mcpSession ? { @@ -1259,6 +1340,14 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte mapError: (cause) => mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_model", cause), }); + // Sessions start in Build by default; pin Grok to agent mode so it + // does not remain in ask. Plan mode is applied per sendTurn. + yield* applyGrokAcpSessionMode({ + runtime: acp, + interactionMode: "default", + mapError: (cause) => + mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_mode", cause), + }); const now = yield* nowIso; const session: ProviderSession = { @@ -1309,8 +1398,14 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte ? normalizeGrokReasoningEffort(requestedStartReasoningEffort) : currentStartReasoningEffort, stopped: false, + lastEmittedUsedTokens: undefined, }; + yield* acp.processExit.pipe( + Effect.flatMap((exitCode) => handleUnexpectedProcessExit(ctx, exitCode)), + Effect.forkIn(sessionScope), + ); + const nf = yield* Stream.runDrain( Stream.mapEffect(acp.getEvents(), (event) => Effect.gen(function* () { @@ -1321,6 +1416,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte if ( event._tag === "PlanUpdated" || event._tag === "ToolCallUpdated" || + event._tag === "UsageUpdated" || event._tag === "ContentDelta" ) { yield* logNative(ctx.threadId, "session/update", event.rawPayload); @@ -1418,6 +1514,27 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte } return; } + case "UsageUpdated": { + const usage = normalizeAcpUsageUpdate({ + used: event.used, + ...(event.size !== undefined ? { size: event.size } : {}), + }); + if (usage !== undefined && usage.usedTokens !== ctx.lastEmittedUsedTokens) { + ctx.lastEmittedUsedTokens = usage.usedTokens; + yield* offerRuntimeEvent( + makeAcpTokenUsageUpdatedEvent({ + stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId: notificationTurnId, + usage, + method: "session/update", + rawPayload: event.rawPayload, + }), + ); + } + return; + } case "ContentDelta": yield* offerRuntimeEvent( makeAcpContentDeltaEvent({ @@ -1583,6 +1700,12 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_model", cause), }); ctx.currentModelId = currentModelId; + yield* applyGrokAcpSessionMode({ + runtime: ctx.acp, + interactionMode: input.interactionMode, + mapError: (cause) => + mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_mode", cause), + }); if (requestedTurnReasoningEffort !== undefined) { ctx.currentReasoningEffort = normalizeGrokReasoningEffort( requestedTurnReasoningEffort, diff --git a/apps/server/src/provider/Layers/GrokProvider.test.ts b/apps/server/src/provider/Layers/GrokProvider.test.ts index c751919b189a..bcdb7b126ff3 100644 --- a/apps/server/src/provider/Layers/GrokProvider.test.ts +++ b/apps/server/src/provider/Layers/GrokProvider.test.ts @@ -7,7 +7,7 @@ import { describe, expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Schema from "effect/Schema"; -import { GrokSettings } from "@t3tools/contracts"; +import { GROK_DEFAULT_MODEL, GrokSettings } from "@t3tools/contracts"; import { buildGrokModelCapabilities, @@ -281,6 +281,7 @@ describe("buildInitialGrokProviderSnapshot", () => { expect(snapshot.status).toBe("warning"); expect(snapshot.version).toBeNull(); expect(snapshot.message).toContain("Checking Grok"); + // Grok ACP accepts session/set_model mid-session. expect(snapshot.requiresNewThreadForModelChange).toBeUndefined(); }), ); @@ -433,7 +434,7 @@ it.layer(NodeServices.layer)("checkGrokProviderStatus", (it) => { expect(snapshot.installed).toBe(true); expect(snapshot.auth.status).toBe("authenticated"); expect(snapshot.models.map((model) => [model.slug, model.isDefault ?? false])).toEqual([ - ["grok-4.6", true], + [GROK_DEFAULT_MODEL, true], ["grok-4.5", false], ]); expect(snapshot.message).toContain("ACP initialize failed"); @@ -464,3 +465,31 @@ it.layer(NodeServices.layer)("checkGrokProviderStatus", (it) => { }), ); }); + +describe("buildGrokModelsFromSessionModelState current-model edge cases", () => { + const modelState = (currentModelId: string | undefined) => ({ + ...(currentModelId === undefined ? {} : { currentModelId }), + availableModels: [ + { modelId: GROK_DEFAULT_MODEL, name: "Grok 4.6" }, + { modelId: "grok-4.5", name: "Grok 4.5" }, + ], + }); + + it("marks the model a fresh session starts on as the picker default", () => { + const models = buildGrokModelsFromSessionModelState(modelState("grok-4.5") as never); + + expect(models.map((model) => model.slug)).toEqual([GROK_DEFAULT_MODEL, "grok-4.5"]); + expect(models.find((model) => model.slug === "grok-4.5")?.isDefault).toBe(true); + expect(models.find((model) => model.slug === GROK_DEFAULT_MODEL)?.isDefault).toBeUndefined(); + }); + + it("leaves the default unmarked when Grok reports no current model", () => { + const models = buildGrokModelsFromSessionModelState(modelState(undefined) as never); + + expect(models.some((model) => model.isDefault)).toBe(false); + }); + + it("returns nothing when there is no model state to read", () => { + expect(buildGrokModelsFromSessionModelState(null)).toEqual([]); + }); +}); diff --git a/apps/server/src/provider/Layers/GrokProvider.ts b/apps/server/src/provider/Layers/GrokProvider.ts index 493e46d44352..221a66b208cb 100644 --- a/apps/server/src/provider/Layers/GrokProvider.ts +++ b/apps/server/src/provider/Layers/GrokProvider.ts @@ -1,4 +1,5 @@ import { + GROK_DEFAULT_MODEL, type CustomModelSetting, type GrokSettings, type ModelCapabilities, @@ -8,6 +9,7 @@ import { } from "@t3tools/contracts"; import type * as EffectAcpSchema from "effect-acp/schema"; import { causeErrorTag } from "@t3tools/shared/observability"; +import * as Cause from "effect/Cause"; import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; import * as Effect from "effect/Effect"; @@ -21,6 +23,7 @@ import { resolveSpawnCommand } from "@t3tools/shared/shell"; import { AUTH_PROBE_TIMEOUT_MS, + buildSelectOptionDescriptor, buildServerProvider, COMPACT_SLASH_COMMAND, isCommandMissingCause, @@ -34,7 +37,6 @@ import { type ProviderMaintenanceCapabilities, } from "../providerMaintenance.ts"; import { - GROK_DEFAULT_MODEL_SLUG, isValidGrokReasoningEffortToken, makeGrokAcpRuntime, resolveGrokAcpBaseModelId, @@ -42,29 +44,172 @@ import { import { sessionModelStateFromInitialize } from "../acp/AcpRuntimeModel.ts"; import { discoverGrokSkills } from "../Drivers/GrokSkills.ts"; +// No `requiresNewThreadForModelChange`: Grok's ACP accepts `session/set_model` +// mid-session, and the adapter re-applies the requested model on every turn +// (`applyGrokAcpModelSelection`). const GROK_PRESENTATION = { displayName: "Grok", badgeLabel: "Early Access", - showInteractionModeToggle: false, + showInteractionModeToggle: true, } as const; const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({ optionDescriptors: [], }); +/** Fallback effort menu when ACP model meta is unavailable but Grok still supports effort. */ +const GROK_FALLBACK_REASONING_EFFORTS: ReadonlyArray<{ + value: string; + label: string; + isDefault?: boolean; +}> = [ + { value: "high", label: "High", isDefault: true }, + { value: "medium", label: "Medium" }, + { value: "low", label: "Low" }, +]; + +export function buildGrokReasoningEffortCapabilities( + efforts: ReadonlyArray<{ value: string; label: string; isDefault?: boolean }>, +): ModelCapabilities { + if (efforts.length === 0) { + return EMPTY_CAPABILITIES; + } + return createModelCapabilities({ + optionDescriptors: [ + buildSelectOptionDescriptor({ + id: "reasoningEffort", + label: "Reasoning", + options: efforts, + }), + ], + }); +} + const VERSION_PROBE_TIMEOUT_MS = 4_000; // `initialize` is a single local round trip, so this is generous even on slow machines. const GROK_ACP_INITIALIZE_TIMEOUT_MS = 8_000; const GROK_API_KEY_ENV = "XAI_API_KEY"; +// Shown until ACP model discovery answers (and whenever it fails). Grok 1.0.3 +// rejects the old `grok-build` slug with "unknown model id", so offering it +// here only produced sessions that could not start. const GROK_BUILT_IN_MODELS: ReadonlyArray = [ { - slug: GROK_DEFAULT_MODEL_SLUG, - name: "Grok Build", + slug: GROK_DEFAULT_MODEL, + name: "Grok 4.6", + isCustom: false, + isDefault: true, + capabilities: buildGrokReasoningEffortCapabilities(GROK_FALLBACK_REASONING_EFFORTS), + }, + { + slug: "grok-4.5", + name: "Grok 4.5", isCustom: false, - capabilities: EMPTY_CAPABILITIES, + capabilities: buildGrokReasoningEffortCapabilities(GROK_FALLBACK_REASONING_EFFORTS), }, ]; +function asRecord(value: unknown): Record | null { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return null; + } + return value as Record; +} + +function effortLabel(raw: string): string { + const trimmed = raw.trim(); + if (!trimmed) return trimmed; + return trimmed.replace(/\s*effort\s*$/iu, "").trim() || trimmed; +} + +/** + * Builds reasoning-effort option descriptors from Grok ACP model `_meta`. + * Grok advertises `supportsReasoningEffort`, `reasoningEffort` (current/default), + * and `reasoningEfforts` (menu entries) on each available model. + */ +export function buildGrokCapabilitiesFromModelMeta( + meta: EffectAcpSchema.ModelInfo["_meta"] | null | undefined, +): ModelCapabilities { + const record = asRecord(meta); + if (!record) { + return EMPTY_CAPABILITIES; + } + + const supports = + record.supportsReasoningEffort === true || + record.supports_reasoning_effort === true || + Array.isArray(record.reasoningEfforts) || + Array.isArray(record.reasoning_efforts); + + if (!supports) { + return EMPTY_CAPABILITIES; + } + + const rawEfforts = Array.isArray(record.reasoningEfforts) + ? record.reasoningEfforts + : Array.isArray(record.reasoning_efforts) + ? record.reasoning_efforts + : null; + + const defaultEffortRaw = + typeof record.reasoningEffort === "string" + ? record.reasoningEffort.trim() + : typeof record.reasoning_effort === "string" + ? record.reasoning_effort.trim() + : undefined; + + const efforts: Array<{ value: string; label: string; isDefault?: boolean }> = []; + const seen = new Set(); + + if (rawEfforts) { + for (const entry of rawEfforts) { + const item = asRecord(entry); + if (!item) continue; + const value = + (typeof item.value === "string" && item.value.trim()) || + (typeof item.id === "string" && item.id.trim()) || + ""; + if (!value || seen.has(value)) continue; + seen.add(value); + const label = + (typeof item.label === "string" && item.label.trim()) || + (typeof item.name === "string" && item.name.trim()) || + value; + const isDefault = + item.default === true || (defaultEffortRaw !== undefined && defaultEffortRaw === value); + efforts.push({ + value, + label: effortLabel(label), + ...(isDefault ? { isDefault: true } : {}), + }); + } + } + + if (efforts.length === 0) { + // Catalog claims support but did not list levels — use the known Grok menu. + return buildGrokReasoningEffortCapabilities( + GROK_FALLBACK_REASONING_EFFORTS.map((effort) => + defaultEffortRaw && effort.value === defaultEffortRaw + ? { ...effort, isDefault: true } + : defaultEffortRaw + ? { value: effort.value, label: effort.label } + : effort, + ), + ); + } + + // Ensure exactly one default: prefer catalog default flag, else advertised current, else first. + if (!efforts.some((effort) => effort.isDefault)) { + const preferred = + (defaultEffortRaw && efforts.find((effort) => effort.value === defaultEffortRaw)) || + efforts[0]; + if (preferred) { + preferred.isDefault = true; + } + } + + return buildGrokReasoningEffortCapabilities(efforts); +} + export function buildInitialGrokProviderSnapshot( grokSettings: GrokSettings, ): Effect.Effect { @@ -216,8 +361,12 @@ export function buildGrokModelsFromSessionModelState( if (!modelState || modelState.availableModels.length === 0) { return []; } - const currentModelId = modelState.currentModelId.trim(); + const currentModelId = modelState.currentModelId?.trim() ?? ""; const seen = new Set(); + // Grok reports which model a fresh session starts on; mark it default so the + // picker agrees with what a new thread would actually run, rather than + // whichever model happens to come first in the ACP list. + const currentSlug = currentModelId ? resolveGrokAcpBaseModelId(currentModelId) : undefined; return modelState.availableModels.flatMap((model): ServerProviderModel[] => { const slug = resolveGrokAcpBaseModelId(model.modelId); if (!slug || seen.has(slug)) { @@ -229,7 +378,7 @@ export function buildGrokModelsFromSessionModelState( slug, name: model.name.trim() || slug, isCustom: false, - ...(model.modelId.trim() === currentModelId ? { isDefault: true } : {}), + ...(slug === currentSlug ? { isDefault: true } : {}), capabilities: buildGrokModelCapabilities(model), }, ]; @@ -469,6 +618,7 @@ export const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(func if (acpFailed) { yield* Effect.logWarning("Grok ACP initialize probe failed or timed out.", { errorTag: Exit.isFailure(acpExit) ? causeErrorTag(acpExit.cause) : "Timeout", + ...(Exit.isFailure(acpExit) ? { causeDetail: Cause.pretty(acpExit.cause) } : {}), }); } diff --git a/apps/server/src/provider/Layers/KimiAdapter.test.ts b/apps/server/src/provider/Layers/KimiAdapter.test.ts new file mode 100644 index 000000000000..94772958f159 --- /dev/null +++ b/apps/server/src/provider/Layers/KimiAdapter.test.ts @@ -0,0 +1,29 @@ +import { it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Ref from "effect/Ref"; +import * as TestClock from "effect/testing/TestClock"; +import { describe, expect } from "vite-plus/test"; + +import { settleAcpTurnCompletion } from "./CursorAdapter.ts"; +import { KIMI_TURN_COMPLETION_SETTLE_DELAY } from "./KimiAdapter.ts"; + +describe("Kimi ACP turn completion", () => { + it.effect("waits for late session updates before draining and completing", () => + Effect.gen(function* () { + const drained = yield* Ref.make(false); + const fiber = yield* settleAcpTurnCompletion( + { drainEvents: Ref.set(drained, true) }, + KIMI_TURN_COMPLETION_SETTLE_DELAY, + ).pipe(Effect.forkChild); + + yield* Effect.yieldNow; + yield* TestClock.adjust("1999 millis"); + expect(yield* Ref.get(drained)).toBe(false); + + yield* TestClock.adjust("1 millis"); + yield* Fiber.join(fiber); + expect(yield* Ref.get(drained)).toBe(true); + }), + ); +}); diff --git a/apps/server/src/provider/Layers/KimiAdapter.ts b/apps/server/src/provider/Layers/KimiAdapter.ts new file mode 100644 index 000000000000..506c63a70a7d --- /dev/null +++ b/apps/server/src/provider/Layers/KimiAdapter.ts @@ -0,0 +1,26 @@ +import { type KimiSettings, ProviderDriverKind, ProviderInstanceId } from "@t3tools/contracts"; + +import { applyKimiAcpModelSelection, makeKimiAcpRuntime } from "../acp/KimiAcpSupport.ts"; +import { makeAcpCliAdapter, type AcpCliAdapterOptions } from "./CursorAdapter.ts"; + +const PROVIDER = ProviderDriverKind.make("kimi"); +export const KIMI_TURN_COMPLETION_SETTLE_DELAY = "2 seconds"; + +export function makeKimiAdapter( + settings: KimiSettings, + options?: AcpCliAdapterOptions, +) { + return makeAcpCliAdapter( + settings, + { + provider: PROVIDER, + providerName: "Kimi Code", + defaultInstanceId: ProviderInstanceId.make("kimi"), + makeRuntime: (currentSettings, input) => makeKimiAcpRuntime(currentSettings, input), + applyModelSelection: applyKimiAcpModelSelection, + resolveModelId: (model) => model?.trim() ?? "", + turnCompletionSettleDelay: KIMI_TURN_COMPLETION_SETTLE_DELAY, + }, + options, + ); +} diff --git a/apps/server/src/provider/Layers/KimiProvider.test.ts b/apps/server/src/provider/Layers/KimiProvider.test.ts new file mode 100644 index 000000000000..ea788b0fd4a4 --- /dev/null +++ b/apps/server/src/provider/Layers/KimiProvider.test.ts @@ -0,0 +1,65 @@ +import type * as EffectAcpSchema from "effect-acp/schema"; +import { describe, expect, it } from "vite-plus/test"; + +import { buildKimiModelsFromConfigOptions } from "./KimiProvider.ts"; + +const configOptions: ReadonlyArray = [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "kimi-code/k3", + options: [ + { + group: "current", + name: "Current", + options: [{ value: "kimi-code/k3", name: "Kimi K3" }], + }, + { + group: "legacy", + name: "Legacy", + options: [ + { value: "kimi-code/k2.5", name: "Kimi K2.5" }, + { value: "kimi-code/k3", name: "duplicate" }, + ], + }, + ], + }, + { + id: "mode", + name: "Mode", + category: "mode", + type: "select", + currentValue: "default", + options: [{ value: "default", name: "Default" }], + }, + { + id: "thinking", + name: "Thinking", + category: "thought_level", + type: "select", + currentValue: "on", + options: [ + { value: "off", name: "Off" }, + { value: "on", name: "On" }, + ], + }, +]; + +describe("buildKimiModelsFromConfigOptions", () => { + it("maps the ACP model catalog and negotiated options", () => { + const models = buildKimiModelsFromConfigOptions(configOptions); + expect(models.map(({ slug, name }) => ({ slug, name }))).toEqual([ + { slug: "kimi-code/k3", name: "Kimi K3" }, + { slug: "kimi-code/k2.5", name: "Kimi K2.5" }, + ]); + expect(models[0]?.capabilities?.optionDescriptors).toEqual([ + expect.objectContaining({ + id: "thinking", + type: "select", + currentValue: "on", + }), + ]); + }); +}); diff --git a/apps/server/src/provider/Layers/KimiProvider.ts b/apps/server/src/provider/Layers/KimiProvider.ts new file mode 100644 index 000000000000..545a4b7855ce --- /dev/null +++ b/apps/server/src/provider/Layers/KimiProvider.ts @@ -0,0 +1,304 @@ +import { + type KimiSettings, + type ModelCapabilities, + type ProviderOptionDescriptor, + type ServerProvider, + type ServerProviderModel, +} from "@t3tools/contracts"; +import { createModelCapabilities } from "@t3tools/shared/model"; +import { causeErrorTag } from "@t3tools/shared/observability"; +import { resolveSpawnCommand } from "@t3tools/shared/shell"; +import * as Cause from "effect/Cause"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Option from "effect/Option"; +import * as Result from "effect/Result"; +import { HttpClient } from "effect/unstable/http"; +import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; +import type * as EffectAcpSchema from "effect-acp/schema"; + +import { makeKimiAcpRuntime } from "../acp/KimiAcpSupport.ts"; +import { + buildBooleanOptionDescriptor, + buildSelectOptionDescriptor, + buildServerProvider, + isCommandMissingCause, + parseGenericCliVersion, + providerModelsFromSettings, + spawnAndCollect, + type ServerProviderDraft, +} from "../providerSnapshot.ts"; +import { + enrichProviderSnapshotWithVersionAdvisory, + type ProviderMaintenanceCapabilities, +} from "../providerMaintenance.ts"; + +const PRESENTATION = { + displayName: "Kimi Code", + badgeLabel: "Early Access", + showInteractionModeToggle: true, +} as const; +const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({ optionDescriptors: [] }); +const VERSION_TIMEOUT_MS = 4_000; +const DISCOVERY_TIMEOUT_MS = 15_000; + +function flattenSelectOptions(option: EffectAcpSchema.SessionConfigOption) { + if (option.type !== "select") return []; + return option.options.flatMap((entry) => ("value" in entry ? [entry] : entry.options)); +} + +function buildCapabilities( + configOptions: ReadonlyArray, +): ModelCapabilities { + const optionDescriptors: Array = []; + for (const option of configOptions) { + const id = option.id.trim(); + if (!id || id === "model" || id === "mode") continue; + if (option.type === "boolean") { + optionDescriptors.push( + buildBooleanOptionDescriptor({ + id, + label: option.name.trim() || id, + currentValue: option.currentValue, + ...(option.description ? { description: option.description } : {}), + }), + ); + continue; + } + const choices = flattenSelectOptions(option) + .filter((choice) => choice.value.trim().length > 0) + .map((choice) => ({ + value: choice.value.trim(), + label: choice.name.trim() || choice.value.trim(), + isDefault: choice.value === option.currentValue, + })); + if (choices.length > 0) { + optionDescriptors.push( + buildSelectOptionDescriptor({ + id, + label: option.name.trim() || id, + options: choices, + ...(option.description ? { description: option.description } : {}), + }), + ); + } + } + return createModelCapabilities({ optionDescriptors }); +} + +export function buildKimiModelsFromConfigOptions( + configOptions: ReadonlyArray, +): ReadonlyArray { + const modelOption = configOptions.find( + (option) => option.type === "select" && option.id.trim().toLowerCase() === "model", + ); + if (!modelOption) return []; + const capabilities = buildCapabilities(configOptions); + const seen = new Set(); + return flattenSelectOptions(modelOption).flatMap((model) => { + const slug = model.value.trim(); + if (!slug || seen.has(slug)) return []; + seen.add(slug); + return [ + { + slug, + name: model.name.trim() || slug, + isCustom: false, + capabilities, + } satisfies ServerProviderModel, + ]; + }); +} + +function modelsFromSettings( + settings: Pick, + builtInModels: ReadonlyArray = [], +) { + return providerModelsFromSettings(builtInModels, settings.customModels, EMPTY_CAPABILITIES); +} + +export function buildInitialKimiProviderSnapshot( + settings: KimiSettings, +): Effect.Effect { + return Effect.map(DateTime.now, (now) => + buildServerProvider({ + presentation: PRESENTATION, + enabled: settings.enabled, + checkedAt: DateTime.formatIso(now), + models: modelsFromSettings(settings), + probe: settings.enabled + ? { + installed: true, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Checking Kimi Code CLI availability...", + } + : { + installed: false, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Kimi Code is disabled in T3 Code settings.", + }, + }), + ); +} + +const runVersionCommand = (settings: KimiSettings, environment: NodeJS.ProcessEnv) => + Effect.gen(function* () { + const command = settings.binaryPath || "kimi"; + const spawnCommand = yield* resolveSpawnCommand(command, ["--version"], { env: environment }); + return yield* spawnAndCollect( + command, + ChildProcess.make(spawnCommand.command, spawnCommand.args, { + env: environment, + shell: spawnCommand.shell, + }), + ); + }); + +const discoverModels = (settings: KimiSettings, environment: NodeJS.ProcessEnv) => + Effect.gen(function* () { + const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const acp = yield* makeKimiAcpRuntime(settings, { + environment, + childProcessSpawner, + cwd: process.cwd(), + clientInfo: { name: "t3-code-provider-probe", version: "0.0.0" }, + }); + const started = yield* acp.start(); + return buildKimiModelsFromConfigOptions(started.sessionSetupResult.configOptions ?? []); + }).pipe(Effect.scoped); + +export const checkKimiProviderStatus = Effect.fn("checkKimiProviderStatus")(function* ( + settings: KimiSettings, + environment: NodeJS.ProcessEnv = process.env, +): Effect.fn.Return< + ServerProviderDraft, + never, + ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto +> { + const checkedAt = DateTime.formatIso(yield* DateTime.now); + const fallbackModels = modelsFromSettings(settings); + if (!settings.enabled) return yield* buildInitialKimiProviderSnapshot(settings); + + const versionResult = yield* runVersionCommand(settings, environment).pipe( + Effect.timeoutOption(VERSION_TIMEOUT_MS), + Effect.result, + ); + if (Result.isFailure(versionResult)) { + const missing = isCommandMissingCause(versionResult.failure); + return buildServerProvider({ + presentation: PRESENTATION, + enabled: true, + checkedAt, + models: fallbackModels, + probe: { + installed: !missing, + version: null, + status: "error", + auth: { status: "unknown" }, + message: missing + ? `Kimi Code CLI command \`${settings.binaryPath}\` was not found. Configure its absolute path in provider settings.` + : "Failed to execute the Kimi Code CLI health check.", + }, + }); + } + if (Option.isNone(versionResult.success)) { + return buildServerProvider({ + presentation: PRESENTATION, + enabled: true, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version: null, + status: "error", + auth: { status: "unknown" }, + message: "Kimi Code CLI timed out while running `kimi --version`.", + }, + }); + } + const versionOutput = versionResult.success.value; + const version = parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`); + if (versionOutput.code !== 0) { + return buildServerProvider({ + presentation: PRESENTATION, + enabled: true, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "error", + auth: { status: "unknown" }, + message: "Kimi Code CLI is installed but failed to run.", + }, + }); + } + + const discoveryExit = yield* discoverModels(settings, environment).pipe( + Effect.timeoutOption(DISCOVERY_TIMEOUT_MS), + Effect.exit, + ); + if (Exit.isFailure(discoveryExit)) { + yield* Effect.logWarning("Kimi ACP model discovery failed", { + errorTag: causeErrorTag(discoveryExit.cause), + causeDetail: Cause.pretty(discoveryExit.cause), + }); + return buildServerProvider({ + presentation: PRESENTATION, + enabled: true, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "error", + auth: { status: "unauthenticated" }, + message: "Kimi ACP startup failed. Run `kimi login`, then refresh the provider.", + }, + }); + } + const discovered = Option.isSome(discoveryExit.value) ? discoveryExit.value.value : []; + return buildServerProvider({ + presentation: PRESENTATION, + enabled: true, + checkedAt, + models: modelsFromSettings(settings, discovered), + probe: { + installed: true, + version, + status: discovered.length > 0 ? "ready" : "warning", + auth: { status: "authenticated" }, + ...(discovered.length === 0 ? { message: "Kimi ACP returned no models." } : {}), + }, + }); +}); + +export const enrichKimiSnapshot = (input: { + readonly settings: KimiSettings; + readonly snapshot: ServerProvider; + readonly maintenanceCapabilities: ProviderMaintenanceCapabilities; + readonly enableProviderUpdateChecks?: boolean; + readonly publishSnapshot: (snapshot: ServerProvider) => Effect.Effect; + readonly stampIdentity: (snapshot: ServerProvider) => ServerProvider; + readonly httpClient: HttpClient.HttpClient; +}): Effect.Effect => { + if (!input.settings.enabled || input.snapshot.auth.status === "unauthenticated") + return Effect.void; + return enrichProviderSnapshotWithVersionAdvisory(input.snapshot, input.maintenanceCapabilities, { + enableProviderUpdateChecks: input.enableProviderUpdateChecks, + }).pipe( + Effect.provideService(HttpClient.HttpClient, input.httpClient), + Effect.flatMap((snapshot) => input.publishSnapshot(input.stampIdentity(snapshot))), + Effect.catchCause((cause) => + Effect.logWarning("Kimi version advisory enrichment failed", { + errorTag: causeErrorTag(cause), + }), + ), + ); +}; diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts index ee5767f9d356..1e9303b91500 100644 --- a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts +++ b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts @@ -36,6 +36,7 @@ import { ServerConfig } from "../../config.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { buildRuntimeInstructions } from "../RuntimeInstructions.ts"; import { ProviderSessionDirectory } from "../Services/ProviderSessionDirectory.ts"; +import { DirenvEnvironmentError } from "../DirenvEnvironment.ts"; import type { OpenCodeAdapterShape } from "../Services/OpenCodeAdapter.ts"; import { OpenCodeRuntime, @@ -47,6 +48,7 @@ import { isSameOpenCodeDirectory, makeOpenCodeAdapter, mergeOpenCodeAssistantText, + normalizeOpenCodeTokenUsage, } from "./OpenCodeAdapter.ts"; import { symlinksSupported } from "@t3tools/shared/testing/symlinks"; @@ -56,6 +58,7 @@ class OpenCodeAdapter extends Context.Service ThreadId.make(value); +const decodeOpenCodeSettings = Schema.decodeSync(OpenCodeSettings); type MessageEntry = { info: { @@ -68,11 +71,18 @@ type MessageEntry = { const runtimeMock = { state: { startCalls: [] as string[], + sessionCreateCalls: [] as Array<{ baseUrl: string; input: unknown }>, + connectCalls: [] as Array<{ + serverUrl?: string | null; + environment?: NodeJS.ProcessEnv; + cwd?: string; + }>, sessionCreateUrls: [] as string[], sessionCreateInputs: [] as Array>, createdSessionIds: [] as string[], authHeaders: [] as Array, abortCalls: [] as string[], + abortCallRecords: [] as Array<{ sessionID: string; directory?: string }>, abortSignals: [] as AbortSignal[], abortImplementation: null as | ((sessionID: string, signal?: AbortSignal) => Promise) @@ -84,7 +94,7 @@ const runtimeMock = { | null, closeCalls: [] as string[], revertMessageID: undefined as string | undefined, - revertCalls: [] as Array<{ sessionID: string; messageID?: string }>, + revertCalls: [] as Array<{ sessionID: string; directory?: string; messageID?: string }>, messageCalls: [] as Array<{ sessionID: string; messageID: string }>, messageFailures: 0, promptCalls: [] as Array, @@ -98,6 +108,8 @@ const runtimeMock = { closeError: null as Error | null, messages: [] as MessageEntry[], subscribedEvents: [] as Array>, + getSessionDirectory: null as string | null, + createSessionDirectoryOverride: null as string | null, eventSubscribeObserved: null as (() => void) | null, eventStreamError: null as ((cause: unknown) => void) | null, permissionReplyCalls: [] as Array<{ requestID: string; reply: string }>, @@ -132,11 +144,14 @@ const runtimeMock = { }, reset() { this.state.startCalls.length = 0; + this.state.sessionCreateCalls.length = 0; + this.state.connectCalls.length = 0; this.state.sessionCreateUrls.length = 0; this.state.sessionCreateInputs.length = 0; this.state.createdSessionIds.length = 0; this.state.authHeaders.length = 0; this.state.abortCalls.length = 0; + this.state.abortCallRecords.length = 0; this.state.abortSignals.length = 0; this.state.abortImplementation = null; this.state.sessionChildrenCalls.length = 0; @@ -158,6 +173,8 @@ const runtimeMock = { this.state.closeError = null; this.state.messages = []; this.state.subscribedEvents = []; + this.state.getSessionDirectory = null; + this.state.createSessionDirectoryOverride = null; this.state.eventSubscribeObserved = null; this.state.eventStreamError = null; this.state.permissionReplyCalls.length = 0; @@ -208,11 +225,18 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = { isRunning: Effect.succeed(true), }; }), - connectToOpenCodeServer: ({ serverUrl, serverPassword }) => + connectToOpenCodeServer: ({ serverUrl, serverPassword, environment, cwd }) => Effect.gen(function* () { + runtimeMock.state.connectCalls.push({ + ...(serverUrl !== undefined ? { serverUrl } : {}), + ...(environment !== undefined ? { environment } : {}), + ...(cwd !== undefined ? { cwd } : {}), + }); const url = serverUrl ?? "http://127.0.0.1:4301"; - // Always register a finalizer so the closeCalls/closeError probes fire; - // production attaches none for external servers. + // Unconditionally register a scope finalizer for test observability — + // preserves the `closeCalls` / `closeError` probes that the existing + // suites rely on. Production code never attaches a finalizer to an + // external server (it simply returns `Effect.succeed(...)`). yield* Effect.addFinalizer(() => Effect.sync(() => { runtimeMock.state.closeCalls.push(url); @@ -233,17 +257,29 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = { createOpenCodeSdkClient: ({ baseUrl, serverPassword }) => ({ session: { - create: async (input: Record) => { + create: async (input: unknown) => { + runtimeMock.state.sessionCreateCalls.push({ baseUrl, input }); runtimeMock.state.sessionCreateUrls.push(baseUrl); - runtimeMock.state.sessionCreateInputs.push(input); + if (input && typeof input === "object") { + runtimeMock.state.sessionCreateInputs.push(input as Record); + } runtimeMock.state.authHeaders.push( serverPassword ? `Basic ${btoa(`opencode:${serverPassword}`)}` : null, ); + const directory = + runtimeMock.state.createSessionDirectoryOverride ?? + (input as { readonly directory?: unknown })?.directory; return { - data: { id: runtimeMock.state.createdSessionIds.shift() ?? `${baseUrl}/session` }, + data: { + id: runtimeMock.state.createdSessionIds.shift() ?? `${baseUrl}/session`, + ...(typeof directory === "string" ? { directory } : {}), + }, }; }, - get: async ({ sessionID }: { sessionID: string }, options?: { signal?: AbortSignal }) => { + get: async ( + { sessionID }: { sessionID: string; directory?: string }, + options?: { signal?: AbortSignal }, + ) => { runtimeMock.state.sessionGetIds.push(sessionID); runtimeMock.state.sessionGetObserved?.(sessionID); if (runtimeMock.state.sessionGetImplementation) { @@ -259,7 +295,9 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = { cause: { status: 404, body: { name: "NotFoundError" } }, }); } - const directory = runtimeMock.state.sessionDirectoryById.get(sessionID); + const directory = + runtimeMock.state.sessionDirectoryById.get(sessionID) ?? + runtimeMock.state.getSessionDirectory; const parentID = runtimeMock.state.sessionParentById.get(sessionID); return { data: { @@ -285,8 +323,15 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = { } return { data: { id: forkedId, ...(directory ? { directory } : {}) } }; }, - abort: async ({ sessionID }: { sessionID: string }, options?: { signal?: AbortSignal }) => { + abort: async ( + { sessionID, directory }: { sessionID: string; directory?: string }, + options?: { signal?: AbortSignal }, + ) => { runtimeMock.state.abortCalls.push(sessionID); + runtimeMock.state.abortCallRecords.push({ + sessionID, + ...(directory ? { directory } : {}), + }); if (options?.signal) { runtimeMock.state.abortSignals.push(options.signal); } @@ -370,9 +415,18 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = { } return { data: message }; }, - revert: async ({ sessionID, messageID }: { sessionID: string; messageID?: string }) => { + revert: async ({ + sessionID, + directory, + messageID, + }: { + sessionID: string; + directory?: string; + messageID?: string; + }) => { runtimeMock.state.revertCalls.push({ sessionID, + ...(directory ? { directory } : {}), ...(messageID ? { messageID } : {}), }); if (!messageID) { @@ -534,7 +588,7 @@ const providerSessionDirectoryTestLayer = Layer.succeed(ProviderSessionDirectory // the layer graph reach for it — but the routing values the assertions // probe (serverUrl, serverPassword) must be threaded directly through the // decoded `OpenCodeSettings`. -const openCodeAdapterTestSettings = Schema.decodeSync(OpenCodeSettings)({ +const openCodeAdapterTestSettings = decodeOpenCodeSettings({ binaryPath: "fake-opencode", serverUrl: "http://127.0.0.1:9999", serverPassword: "secret-password", @@ -568,6 +622,24 @@ beforeEach(() => { const advanceTestClock = (ms: number) => TestClock.adjust(`${ms} millis`).pipe(Effect.andThen(Effect.yieldNow)); +const makeDirenvAdapterLayer = ( + settings: typeof openCodeAdapterTestSettings, + resolveEnvironment: NonNullable< + NonNullable[1]>["resolveEnvironment"] + >, +) => + Layer.effect( + OpenCodeAdapter, + makeOpenCodeAdapter(settings, { + environment: { PATH: process.env.PATH, PROVIDER_VALUE: "configured" }, + resolveEnvironment, + }), + ).pipe( + Layer.provideMerge(Layer.succeed(OpenCodeRuntime, OpenCodeRuntimeTestDouble)), + Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())), + Layer.provideMerge(NodeServices.layer), + ); + function promiseWithResolvers() { let resolve!: (value: T | PromiseLike) => void; let reject!: (reason?: unknown) => void; @@ -612,6 +684,62 @@ const questionRequest = (id: string, sessionID: string): QuestionRequest => ({ }); it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { + it.effect("passes the resolved environment and project cwd to a local OpenCode server", () => { + const resolvedEnvironment = { PATH: process.env.PATH, PROVIDER_VALUE: "from-direnv" }; + const resolveEnvironment = vi.fn((_input: { readonly cwd: string }) => + Effect.succeed(resolvedEnvironment), + ); + const settings = decodeOpenCodeSettings({ + binaryPath: "fake-opencode", + serverUrl: "", + }); + const adapterLayer = makeDirenvAdapterLayer(settings, resolveEnvironment); + + return Effect.gen(function* () { + const adapter = yield* OpenCodeAdapter; + yield* adapter.startSession({ + provider: ProviderDriverKind.make("opencode"), + threadId: asThreadId("thread-opencode-direnv"), + cwd: ".", + runtimeMode: "full-access", + }); + + NodeAssert.equal(resolveEnvironment.mock.calls[0]?.[0].cwd, process.cwd()); + NodeAssert.deepEqual(runtimeMock.state.connectCalls, [ + { + serverUrl: "", + environment: resolvedEnvironment, + cwd: process.cwd(), + }, + ]); + }).pipe(Effect.provide(adapterLayer)); + }); + + it.effect("does not resolve direnv for a configured external OpenCode server", () => { + const resolveEnvironment = vi.fn(() => + Effect.fail( + new DirenvEnvironmentError({ + stage: "execution", + detail: "must not run for external servers", + }), + ), + ); + const adapterLayer = makeDirenvAdapterLayer(openCodeAdapterTestSettings, resolveEnvironment); + + return Effect.gen(function* () { + const adapter = yield* OpenCodeAdapter; + yield* adapter.startSession({ + provider: ProviderDriverKind.make("opencode"), + threadId: asThreadId("thread-opencode-external-direnv"), + cwd: ".", + runtimeMode: "full-access", + }); + + NodeAssert.equal(resolveEnvironment.mock.calls.length, 0); + NodeAssert.equal(runtimeMock.state.connectCalls[0]?.serverUrl, "http://127.0.0.1:9999"); + }).pipe(Effect.provide(adapterLayer)); + }); + it.effect("reuses a configured OpenCode server URL instead of spawning a local server", () => Effect.gen(function* () { const adapter = yield* OpenCodeAdapter; @@ -625,7 +753,10 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { NodeAssert.equal(session.provider, "opencode"); NodeAssert.equal(session.threadId, "thread-opencode"); NodeAssert.deepEqual(runtimeMock.state.startCalls, []); - NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]); + NodeAssert.deepEqual( + runtimeMock.state.sessionCreateCalls.map((call) => call.baseUrl), + ["http://127.0.0.1:9999"], + ); NodeAssert.deepEqual(runtimeMock.state.authHeaders, [ `Basic ${btoa("opencode:secret-password")}`, ]); @@ -1305,6 +1436,13 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { yield* adapter.stopSession(asThreadId("thread-opencode")); NodeAssert.deepEqual(runtimeMock.state.startCalls, []); + NodeAssert.deepEqual( + runtimeMock.state.abortCallRecords.some( + (call) => + call.sessionID === "http://127.0.0.1:9999/session" && call.directory === process.cwd(), + ), + true, + ); NodeAssert.deepEqual(runtimeMock.state.abortCalls, [ rootSessionId, "ses_stop_child", @@ -1362,10 +1500,10 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { yield* Effect.exit(adapter.stopAll()); const sessions = yield* adapter.listSessions(); - NodeAssert.deepEqual(runtimeMock.state.closeCalls, [ - "http://127.0.0.1:9999", - "http://127.0.0.1:9999", - ]); + NodeAssert.equal( + runtimeMock.state.closeCalls.filter((url) => url === "http://127.0.0.1:9999").length >= 2, + true, + ); NodeAssert.deepEqual(sessions, []); }), ); @@ -6217,6 +6355,7 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { NodeAssert.match(messageID, /^msg_[0-9a-f]{12}[0-9A-Za-z]{14}$/); NodeAssert.deepEqual(prompt, { sessionID: "http://127.0.0.1:9999/session", + directory: process.cwd(), model: { providerID: "anthropic", modelID: "claude-sonnet-4-5", @@ -6275,6 +6414,7 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { NodeAssert.match(messageID, /^msg_[0-9a-f]{12}[0-9A-Za-z]{14}$/); NodeAssert.deepEqual(prompt, { sessionID: "http://127.0.0.1:9999/session", + directory: process.cwd(), model: { providerID: "anthropic", modelID: "claude-sonnet-4-5", @@ -6367,6 +6507,7 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { : [ { sessionID: "http://127.0.0.1:9999/session", + directory: process.cwd(), messageID: numTurns === 1 ? "assistant-2" : "assistant-1", }, ], @@ -6513,6 +6654,98 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { }), ); + it.effect("maps OpenCode token rollups to last in/out usage", () => + Effect.sync(() => { + NodeAssert.deepEqual( + normalizeOpenCodeTokenUsage({ + total: 1_500, + input: 1_000, + output: 400, + reasoning: 100, + cache: { read: 200, write: 0 }, + }), + { + usedTokens: 1_500, + lastUsedTokens: 1_500, + inputTokens: 1_200, + lastInputTokens: 1_200, + outputTokens: 400, + lastOutputTokens: 400, + reasoningOutputTokens: 100, + lastReasoningOutputTokens: 100, + cachedInputTokens: 200, + lastCachedInputTokens: 200, + }, + ); + NodeAssert.equal( + normalizeOpenCodeTokenUsage({ + input: 0, + output: 0, + reasoning: 0, + cache: { read: 0, write: 0 }, + }), + undefined, + ); + }), + ); + + it.effect("emits thread token usage from OpenCode assistant message tokens", () => + Effect.gen(function* () { + const adapter = yield* OpenCodeAdapter; + const threadId = asThreadId("thread-opencode-token-usage"); + runtimeMock.state.subscribedEvents = [ + { + type: "message.updated", + properties: { + sessionID: "http://127.0.0.1:9999/session", + info: { + id: "msg-tokens", + role: "assistant", + tokens: { + total: 1_500, + input: 1_000, + output: 400, + reasoning: 100, + cache: { read: 200, write: 0 }, + }, + }, + }, + }, + ]; + + const eventsFiber = yield* adapter.streamEvents.pipe( + Stream.filter((event) => event.threadId === threadId), + Stream.take(3), + Stream.runCollect, + Effect.forkChild, + ); + + yield* adapter.startSession({ + provider: ProviderDriverKind.make("opencode"), + threadId, + runtimeMode: "full-access", + }); + + const events = Array.from(yield* Fiber.join(eventsFiber).pipe(Effect.timeout("1 second"))); + const usageEvent = events.find((event) => event.type === "thread.token-usage.updated"); + NodeAssert.ok(usageEvent); + if (usageEvent?.type === "thread.token-usage.updated") { + NodeAssert.deepEqual(usageEvent.payload.usage, { + usedTokens: 1_500, + lastUsedTokens: 1_500, + inputTokens: 1_200, + lastInputTokens: 1_200, + outputTokens: 400, + lastOutputTokens: 400, + reasoningOutputTokens: 100, + lastReasoningOutputTokens: 100, + cachedInputTokens: 200, + lastCachedInputTokens: 200, + }); + } + }), + ); + it.effect("does not strip coincidental prefix overlap from OpenCode part deltas", () => Effect.gen(function* () { const adapter = yield* OpenCodeAdapter; @@ -7289,8 +7522,11 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { }); const events = Array.from(yield* Fiber.join(eventsFiber).pipe(Effect.timeout("1 second"))); - NodeAssert.equal(runtimeMock.state.sessionCreateInputs.length, 1); - NodeAssert.equal("title" in (runtimeMock.state.sessionCreateInputs[0] ?? {}), false); + NodeAssert.equal(runtimeMock.state.sessionCreateCalls.length, 1); + NodeAssert.equal( + "title" in ((runtimeMock.state.sessionCreateCalls[0]?.input ?? {}) as object), + false, + ); const metadataUpdated = events.find((event) => event.type === "thread.metadata.updated"); NodeAssert.ok(metadataUpdated); @@ -7312,9 +7548,9 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => { title: "Investigate reconnect failures", }); - NodeAssert.equal(runtimeMock.state.sessionCreateInputs.length, 1); + NodeAssert.equal(runtimeMock.state.sessionCreateCalls.length, 1); NodeAssert.equal( - runtimeMock.state.sessionCreateInputs[0]?.title, + (runtimeMock.state.sessionCreateCalls[0]?.input as { title?: string } | undefined)?.title, "Investigate reconnect failures", ); }), diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.ts index 312a9494bebc..4b246556bbe5 100644 --- a/apps/server/src/provider/Layers/OpenCodeAdapter.ts +++ b/apps/server/src/provider/Layers/OpenCodeAdapter.ts @@ -9,6 +9,7 @@ import { RuntimeItemId, RuntimeRequestId, ThreadId, + type ThreadTokenUsageSnapshot, type ToolLifecycleItemType, type TurnTokenUsage, TurnId, @@ -45,6 +46,7 @@ import { } from "../Errors.ts"; import { buildRuntimeInstructions } from "../RuntimeInstructions.ts"; import { type OpenCodeAdapterShape } from "../Services/OpenCodeAdapter.ts"; +import { type DirenvEnvironment, resolveProviderSessionEnvironment } from "../DirenvEnvironment.ts"; import { buildOpenCodePermissionRules, OpenCodeRuntime, @@ -62,114 +64,6 @@ import * as Option from "effect/Option"; const PROVIDER = ProviderDriverKind.make("opencode"); -/** - * Version tag stamped into the OpenCode resume cursor. Bump if the cursor - * shape changes so stale-shaped cursors written by older builds are ignored - * rather than misread (mirrors GROK_RESUME_VERSION / CURSOR_RESUME_VERSION). - */ -const OPENCODE_RESUME_VERSION = 1 as const; - -/** - * Decode a persisted resume cursor into the upstream `ses_…` id. Anything - * that isn't a current-version cursor with a non-empty id means "no resume" - * rather than an error. Re-adopting the session id IS the resume mechanism — - * OpenCode scopes a conversation's history by session id. - */ -function parseOpenCodeResume(raw: unknown): { readonly sessionId: string } | undefined { - if (typeof raw !== "object" || raw === null || Array.isArray(raw)) { - return undefined; - } - const record = raw as Record; - if (record.schemaVersion !== OPENCODE_RESUME_VERSION) { - return undefined; - } - if (typeof record.sessionId !== "string" || record.sessionId.trim().length === 0) { - return undefined; - } - return { sessionId: record.sessionId.trim() }; -} - -/** - * Whether an error definitively reports a missing session. Only a confirmed - * miss may silently start a fresh session; any other failure (the SDK client - * is `throwOnError: true`, so `session.get` rejects on every non-2xx) must - * propagate, or a transient blip resets a live thread to an empty one — the - * #3604 silent context loss. Decides on structured signals only, never free - * text: a numeric 404 or the exact `NotFoundError` name, found via a bounded walk - * over `cause`/`body`/`error`/`data`. An explicit non-404 status seals its - * subtree so a wrapped "NotFound" name can't reclassify a real failure. - * Exported for unit testing. - */ -export function isOpenCodeNotFound(cause: unknown): boolean { - const seen = new Set(); - const queue: Array = [cause]; - for (let steps = 0; queue.length > 0 && steps < 32; steps += 1) { - const node = queue.shift(); - if (node === null || typeof node !== "object" || seen.has(node)) { - continue; - } - seen.add(node); - const record = node as Record; - - const response = record.response; - const statuses = [ - record.status, - record.statusCode, - response !== null && typeof response === "object" - ? (response as { readonly status?: unknown }).status - : undefined, - ].filter((status): status is number => typeof status === "number"); - if (statuses.includes(404)) { - return true; - } - if (statuses.length > 0) { - continue; - } - - const name = record.name; - if (typeof name === "string" && name.toLowerCase() === "notfounderror") { - return true; - } - - for (const key of ["cause", "body", "error", "data"] as const) { - if (record[key] !== undefined) { - queue.push(record[key]); - } - } - } - return false; -} - -/** - * Whether two directory spellings name the same location. Raw string - * equality misreads a trailing slash, `.`/`..` segment, or symlinked cwd - * (macOS `/tmp` → `/private/tmp`) as a cwd change, needlessly forking the - * session on every resume. Lexically equal paths short-circuit; otherwise - * both sides go through `realPath`, each falling back to its lexical form - * on failure (deleted directory, external-server path) — so the probe can - * only widen matches, never split them. Takes the services as arguments so - * adapter methods stay service-free. Exported for unit testing. - */ -export function isSameOpenCodeDirectory( - fileSystem: FileSystem.FileSystem, - path: Path.Path, - left: string, - right: string, -): Effect.Effect { - const lexicalLeft = path.resolve(left); - const lexicalRight = path.resolve(right); - if (lexicalLeft === lexicalRight) { - return Effect.succeed(true); - } - const canonicalize = (lexical: string) => - fileSystem.realPath(lexical).pipe(Effect.orElseSucceed(() => lexical)); - return Effect.zipWith( - canonicalize(lexicalLeft), - canonicalize(lexicalRight), - (canonicalLeft, canonicalRight) => canonicalLeft === canonicalRight, - ); -} - interface OpenCodeTurnSnapshot { readonly id: TurnId; readonly items: Array; @@ -276,6 +170,66 @@ function openCodeEventSessionId(event: OpenCodeSubscribedEvent): string | undefi return info && typeof info.id === "string" ? info.id : undefined; } +type OpenCodeTokenCounts = { + readonly total?: number; + readonly input: number; + readonly output: number; + readonly reasoning: number; + readonly cache: { + readonly read: number; + readonly write: number; + }; +}; + +function finiteNonNegativeInteger(value: unknown): number | undefined { + if (typeof value !== "number" || !Number.isFinite(value) || value < 0) { + return undefined; + } + return Math.round(value); +} + +/** + * Map OpenCode assistant/session/step token rollups onto T3's thread snapshot + * so Discord/GitHub footers can show in/out (and a used-total fallback). + */ +export function normalizeOpenCodeTokenUsage( + tokens: OpenCodeTokenCounts | null | undefined, +): ThreadTokenUsageSnapshot | undefined { + if (tokens === null || tokens === undefined) { + return undefined; + } + + const input = finiteNonNegativeInteger(tokens.input) ?? 0; + const cachedRead = finiteNonNegativeInteger(tokens.cache?.read) ?? 0; + const output = finiteNonNegativeInteger(tokens.output) ?? 0; + const reasoning = finiteNonNegativeInteger(tokens.reasoning) ?? 0; + const inputTokens = input + cachedRead; + const usedTokens = finiteNonNegativeInteger(tokens.total) ?? inputTokens + output + reasoning; + if (usedTokens <= 0) { + return undefined; + } + + return { + usedTokens, + lastUsedTokens: usedTokens, + ...(inputTokens > 0 ? { inputTokens, lastInputTokens: inputTokens } : {}), + ...(output > 0 ? { outputTokens: output, lastOutputTokens: output } : {}), + ...(reasoning > 0 + ? { reasoningOutputTokens: reasoning, lastReasoningOutputTokens: reasoning } + : {}), + ...(cachedRead > 0 ? { cachedInputTokens: cachedRead, lastCachedInputTokens: cachedRead } : {}), + }; +} + +function openCodeUsageFingerprint(usage: ThreadTokenUsageSnapshot): string { + return [ + usage.usedTokens, + usage.lastInputTokens ?? usage.inputTokens ?? 0, + usage.lastOutputTokens ?? usage.outputTokens ?? 0, + usage.lastReasoningOutputTokens ?? usage.reasoningOutputTokens ?? 0, + ].join(":"); +} + function openCodeEventSessionTitle(event: OpenCodeSubscribedEvent): string | undefined { if (event.type !== "session.updated") { return undefined; @@ -350,6 +304,9 @@ interface OpenCodeSessionContext { // OpenCode permits edits to completed parts. Keep text for snapshot comparison // until native removal or session teardown, but do not retain other part payloads. readonly textPartsByMessageId: Map>; + readonly completedAssistantPartIds: Set; + /** Last emitted usage fingerprint so repeated OpenCode token pings do not flood activities. */ + lastEmittedUsageFingerprint: string | undefined; turnTokenUsage: OpenCodeTurnTokenUsageAccumulator | undefined; activeTurnId: TurnId | undefined; activeAgent: string | undefined; @@ -456,6 +413,7 @@ function takeOpenCodeTurnTokenUsage( export interface OpenCodeAdapterLiveOptions { readonly instanceId?: ProviderInstanceId; readonly environment?: NodeJS.ProcessEnv; + readonly resolveEnvironment?: DirenvEnvironment["Service"]["resolve"]; readonly nativeEventLogPath?: string; readonly nativeEventLogger?: EventNdjsonLogger; } @@ -719,6 +677,133 @@ function sessionErrorMessage(error: unknown): string { : "OpenCode session failed."; } +function isOpenCodeMessageAborted(error: unknown): boolean { + if (!error || typeof error !== "object") { + return false; + } + const record = error as { + readonly name?: unknown; + readonly message?: unknown; + readonly data?: { readonly message?: unknown }; + }; + return ( + record.name === "MessageAbortedError" || + record.message === "Aborted" || + record.data?.message === "Aborted" + ); +} + +/** + * Whether an error definitively reports a missing session. Only a confirmed + * miss may silently start a fresh session; any other failure (the SDK client + * is `throwOnError: true`, so `session.get` rejects on every non-2xx) must + * propagate, or a transient blip resets a live thread to an empty one — the + * #3604 silent context loss. Decides on structured signals only, never free + * text: a numeric 404 or the exact `NotFoundError` name, found via a bounded walk + * over `cause`/`body`/`error`/`data`. An explicit non-404 status seals its + * subtree so a wrapped "NotFound" name can't reclassify a real failure. + * Exported for unit testing. + */ +export function isOpenCodeNotFound(cause: unknown): boolean { + const seen = new Set(); + const queue: Array = [cause]; + for (let steps = 0; queue.length > 0 && steps < 32; steps += 1) { + const node = queue.shift(); + if (node === null || typeof node !== "object" || seen.has(node)) { + continue; + } + seen.add(node); + const record = node as Record; + + const response = record.response; + const statuses = [ + record.status, + record.statusCode, + response !== null && typeof response === "object" + ? (response as { readonly status?: unknown }).status + : undefined, + ].filter((status): status is number => typeof status === "number"); + if (statuses.includes(404)) { + return true; + } + if (statuses.length > 0) { + continue; + } + + const name = record.name; + if (typeof name === "string" && name.toLowerCase() === "notfounderror") { + return true; + } + + for (const key of ["cause", "body", "error", "data"] as const) { + if (record[key] !== undefined) { + queue.push(record[key]); + } + } + } + return false; +} + +/** + * Whether two directory spellings name the same location. Raw string + * equality misreads a trailing slash, `.`/`..` segment, or symlinked cwd + * (macOS `/tmp` → `/private/tmp`) as a cwd change, needlessly forking the + * session on every resume. Lexically equal paths short-circuit; otherwise + * both sides go through `realPath`, each falling back to its lexical form + * on failure (deleted directory, external-server path) — so the probe can + * only widen matches, never split them. Takes the services as arguments so + * adapter methods stay service-free. Exported for unit testing. + */ +export function isSameOpenCodeDirectory( + fileSystem: FileSystem.FileSystem, + path: Path.Path, + left: string, + right: string, +): Effect.Effect { + const lexicalLeft = path.resolve(left); + const lexicalRight = path.resolve(right); + if (lexicalLeft === lexicalRight) { + return Effect.succeed(true); + } + const canonicalize = (lexical: string) => + fileSystem.realPath(lexical).pipe(Effect.orElseSucceed(() => lexical)); + return Effect.zipWith( + canonicalize(lexicalLeft), + canonicalize(lexicalRight), + (canonicalLeft, canonicalRight) => canonicalLeft === canonicalRight, + ); +} + +/** + * Version tag stamped into the OpenCode resume cursor. Bump if the cursor + * shape changes so stale-shaped cursors written by older builds are ignored + * rather than misread (mirrors GROK_RESUME_VERSION / CURSOR_RESUME_VERSION). + */ +const OPENCODE_RESUME_VERSION = 1 as const; + +/** + * Decode a persisted resume cursor into the upstream `ses_…` id. Anything + * that isn't a current-version cursor with a non-empty id means "no resume" + * rather than an error. Also accepts the fork's unversioned `{ sessionId }` + * / `{ openCodeSessionId }` shape so existing sessions keep history. + */ +function readOpenCodeResumeSessionId(resumeCursor: unknown): string | undefined { + if (!resumeCursor || typeof resumeCursor !== "object" || Array.isArray(resumeCursor)) { + return undefined; + } + const record = resumeCursor as Record; + if (record.schemaVersion !== undefined && record.schemaVersion !== OPENCODE_RESUME_VERSION) { + return undefined; + } + const sessionId = + typeof record.sessionId === "string" + ? record.sessionId + : typeof record.openCodeSessionId === "string" + ? record.openCodeSessionId + : undefined; + return sessionId && sessionId.trim().length > 0 ? sessionId : undefined; +} + function updateProviderSession( context: OpenCodeSessionContext, patch: Partial, @@ -794,7 +879,10 @@ const abortOpenCodeDescendants = Effect.fn("abortOpenCodeDescendants")(function* const abortResult = yield* requestSemaphore .withPermit( runOpenCodeSdk("session.abort", (signal) => - context.client.session.abort({ sessionID: sessionId }, { signal }), + context.client.session.abort( + { sessionID: sessionId, directory: context.directory }, + { signal }, + ), ), ) .pipe( @@ -853,7 +941,10 @@ const abortOpenCodeSessionForTeardown = Effect.fn("abortOpenCodeSessionForTeardo // Stop the parent before the snapshot so it cannot add another child after // the adapter reads the tree. yield* runOpenCodeSdk("session.abort", (signal) => - context.client.session.abort({ sessionID: context.openCodeSessionId }, { signal }), + context.client.session.abort( + { sessionID: context.openCodeSessionId, directory: context.directory }, + { signal }, + ), ).pipe(Effect.timeout("1 second"), Effect.ignore({ log: true })); yield* abortOpenCodeDescendants(context).pipe( Effect.timeout("1 second"), @@ -1074,6 +1165,32 @@ export function makeOpenCodeAdapter( const emit = (event: ProviderRuntimeEvent) => Queue.offer(runtimeEvents, event).pipe(Effect.asVoid); + const emitOpenCodeTokenUsage = ( + context: OpenCodeSessionContext, + tokens: OpenCodeTokenCounts | undefined, + raw: unknown, + ) => + Effect.gen(function* () { + const usage = normalizeOpenCodeTokenUsage(tokens); + if (!usage) { + return; + } + const fingerprint = openCodeUsageFingerprint(usage); + if (fingerprint === context.lastEmittedUsageFingerprint) { + return; + } + context.lastEmittedUsageFingerprint = fingerprint; + yield* emit({ + ...(yield* buildEventBase({ + threadId: context.session.threadId, + turnId: context.activeTurnId, + raw, + })), + type: "thread.token-usage.updated", + payload: { usage }, + }); + }); + // Synchronous publish for callers that must not yield between a state // check and the enqueue, e.g. reopening an approval only if its terminal // event has not landed yet. @@ -1285,7 +1402,10 @@ export function makeOpenCodeAdapter( "OpenCode accepted the prompt, but T3 Code could not confirm its message or session status."; const abortExit = yield* Effect.exit( runOpenCodeSdk("session.abort", (signal) => - context.client.session.abort({ sessionID: context.openCodeSessionId }, { signal }), + context.client.session.abort( + { sessionID: context.openCodeSessionId, directory: context.directory }, + { signal }, + ), ).pipe(Effect.timeout("1 second")), ); if (Exit.isFailure(abortExit)) { @@ -2287,6 +2407,7 @@ export function makeOpenCodeAdapter( }, }); } + yield* emitOpenCodeTokenUsage(context, event.properties.info.tokens, event); break; } case "session.compacted": { @@ -2329,6 +2450,9 @@ export function makeOpenCodeAdapter( context.textPartsByMessageId.delete(event.properties.info.id); } if (event.properties.info.role === "assistant") { + if (!context.turnTokenUsage) { + yield* emitOpenCodeTokenUsage(context, event.properties.info.tokens, event); + } const usage = context.turnTokenUsage; const parentMessageId = typeof event.properties.info.parentID === "string" && @@ -2459,6 +2583,10 @@ export function makeOpenCodeAdapter( } } + if (part.type === "step-finish" && !context.turnTokenUsage) { + yield* emitOpenCodeTokenUsage(context, part.tokens, event); + } + if (part.type === "tool") { const itemType = toToolLifecycleItemType(part.tool); const title = @@ -2653,6 +2781,29 @@ export function makeOpenCodeAdapter( context.activeAgent = undefined; context.activeVariant = undefined; context.reconcileIdleStatus = false; + if (isOpenCodeMessageAborted(event.properties.error)) { + yield* updateProviderSession( + context, + { + status: "ready", + }, + { clearActiveTurnId: true, clearLastError: true }, + ); + if (activeTurnId) { + yield* emit({ + ...(yield* buildEventBase({ + threadId: context.session.threadId, + turnId: activeTurnId, + raw: event, + })), + type: "turn.aborted", + payload: { + reason: message, + }, + }); + } + break; + } yield* schedulePendingRequestRecovery(context); yield* updateProviderSession( context, @@ -2809,8 +2960,36 @@ export function makeOpenCodeAdapter( const binaryPath = openCodeSettings.binaryPath; const serverUrl = openCodeSettings.serverUrl; const serverPassword = openCodeSettings.serverPassword; - const directory = input.cwd ?? serverConfig.cwd; - const resumeSessionId = parseOpenCodeResume(input.resumeCursor)?.sessionId; + if (input.cwd !== undefined && !input.cwd.trim()) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "startSession", + issue: "cwd must be non-empty when provided.", + }); + } + const directory = + input.cwd === undefined ? serverConfig.cwd : path.resolve(input.cwd.trim()); + const environment = + input.cwd === undefined || serverUrl?.trim() + ? options?.environment + : yield* resolveProviderSessionEnvironment({ + resolve: options?.resolveEnvironment, + provider: PROVIDER, + threadId: input.threadId, + cwd: directory, + environment: options?.environment ?? process.env, + }).pipe( + Effect.mapError( + (cause) => + new ProviderAdapterProcessError({ + provider: PROVIDER, + threadId: input.threadId, + detail: cause.message, + cause, + }), + ), + ); + const resumeSessionId = readOpenCodeResumeSessionId(input.resumeCursor); const existing = sessions.get(input.threadId); if (existing) { if (existing.session.status === "connecting" && !(yield* Ref.get(existing.stopped))) { @@ -2834,9 +3013,10 @@ export function makeOpenCodeAdapter( serverUrl, ...(serverPassword ? { serverPassword } : {}), environment: McpProviderSession.withAgentDeviceEnvironment( - options?.environment ?? process.env, + environment ?? options?.environment ?? process.env, mcpSession, ), + cwd: directory, }); const client = openCodeRuntime.createOpenCodeSdkClient({ baseUrl: server.url, @@ -2865,7 +3045,7 @@ export function makeOpenCodeAdapter( const resolved = yield* Effect.gen(function* () { const adopted = resumeSessionId ? yield* runOpenCodeSdk("session.get", () => - client.session.get({ sessionID: resumeSessionId }), + client.session.get({ sessionID: resumeSessionId, directory }), ).pipe( Effect.map((response) => response.data), Effect.catchIf( @@ -2930,6 +3110,7 @@ export function makeOpenCodeAdapter( } const createdSession = yield* runOpenCodeSdk("session.create", () => client.session.create({ + directory, ...(input.title ? { title: input.title } : {}), permission: buildOpenCodePermissionRules(input.runtimeMode), }), @@ -2968,9 +3149,6 @@ export function makeOpenCodeAdapter( cwd: directory, ...(input.modelSelection ? { model: input.modelSelection.model } : {}), threadId: input.threadId, - // ProviderService persists this cursor and feeds it back into - // `startSession` after the in-memory session is lost (reaper / - // restart), so follow-ups continue the same conversation (#3604). resumeCursor: { schemaVersion: OPENCODE_RESUME_VERSION, sessionId: started.openCodeSession.id, @@ -2994,6 +3172,8 @@ export function makeOpenCodeAdapter( pendingQuestions: new Map(), textPartsByMessageId: new Map(), messageRoleById: new Map(), + completedAssistantPartIds: new Set(), + lastEmittedUsageFingerprint: undefined, turnTokenUsage: undefined, activeTurnId: undefined, activeAgent: undefined, @@ -3216,6 +3396,7 @@ export function makeOpenCodeAdapter( { sessionID: context.openCodeSessionId, messageID: messageId, + directory: context.directory, model: parsedModel, ...(context.activeAgent ? { agent: context.activeAgent } : {}), ...(context.activeVariant ? { variant: context.activeVariant } : {}), @@ -3286,7 +3467,10 @@ export function makeOpenCodeAdapter( const cleanupExit = yield* Effect.exit( runOpenCodeSdk("session.abort", (signal) => context.client.session.abort( - { sessionID: context.openCodeSessionId }, + { + sessionID: context.openCodeSessionId, + directory: context.directory, + }, { signal }, ), ).pipe(Effect.timeout("1 second")), @@ -3529,7 +3713,10 @@ export function makeOpenCodeAdapter( const parentAbortOutcome = yield* Effect.raceFirst( runOpenCodeSdk("session.abort", (signal) => - context.client.session.abort({ sessionID: context.openCodeSessionId }, { signal }), + context.client.session.abort( + { sessionID: context.openCodeSessionId, directory: context.directory }, + { signal }, + ), ).pipe( Effect.asVoid, Effect.timeout("10 seconds"), @@ -3784,6 +3971,7 @@ export function makeOpenCodeAdapter( const messages = yield* runOpenCodeSdk("session.messages", () => context.client.session.messages({ sessionID: context.openCodeSessionId, + directory: context.directory, }), ).pipe(Effect.mapError(toRequestError)); @@ -3815,6 +4003,7 @@ export function makeOpenCodeAdapter( yield* runOpenCodeSdk("session.revert", () => context.client.session.revert({ sessionID: context.openCodeSessionId, + directory: context.directory, messageID: target.id, }), ).pipe(Effect.mapError(toRequestError)); diff --git a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts index 25dafa5ba040..9c212c83b94d 100644 --- a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts +++ b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts @@ -56,6 +56,7 @@ import { GrokDriver } from "../Drivers/GrokDriver.ts"; import { OpenCodeDriver } from "../Drivers/OpenCodeDriver.ts"; import * as ModelManifest from "../ModelManifest.ts"; import { OpenCodeRuntimeLive } from "../opencodeRuntime.ts"; +import * as DirenvEnvironment from "../DirenvEnvironment.ts"; import * as CodexResetCredit from "./codexResetCredit.ts"; import { NoOpProviderEventLoggers, ProviderEventLoggers } from "./ProviderEventLoggers.ts"; import { makeProviderInstanceRegistry } from "./ProviderInstanceRegistryLive.ts"; @@ -230,6 +231,7 @@ describe("ProviderInstanceRegistryLive — multi-instance codex slice", () => { Layer.provideMerge(ServerSettingsService.layerTest()), Layer.provideMerge(TestHttpClientLive), Layer.provideMerge(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)), + Layer.provideMerge(DirenvEnvironment.layerNoop), Layer.provideMerge(ModelManifest.layerTest), Layer.provideMerge(CodexResetCredit.layerTest), ); @@ -446,7 +448,10 @@ describe("ProviderInstanceRegistryLive — all drivers slice", () => { // provides `OpenCodeRuntimeLive`'s deps while keeping its own outputs // surfaced; that merged layer then provides `ServerConfig.layerTest`'s // `FileSystem` dep while keeping everything else surfaced to the test. - const infraLayer = OpenCodeRuntimeLive.pipe(Layer.provideMerge(NodeServices.layer)); + const infraLayer = OpenCodeRuntimeLive.pipe( + Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(DirenvEnvironment.layerNoop), + ); const testLayer = AntigravityInstallation.layer.pipe( Layer.provideMerge( ServerConfig.layerTest(process.cwd(), { diff --git a/apps/server/src/provider/Layers/ProviderRegistry.test.ts b/apps/server/src/provider/Layers/ProviderRegistry.test.ts index 988c89e1e679..05154429cebd 100644 --- a/apps/server/src/provider/Layers/ProviderRegistry.test.ts +++ b/apps/server/src/provider/Layers/ProviderRegistry.test.ts @@ -43,6 +43,7 @@ import * as OpenCodeRuntime from "../opencodeRuntime.ts"; import * as ProviderEventLoggers from "./ProviderEventLoggers.ts"; import { ProviderInstanceRegistryHydrationLive } from "./ProviderInstanceRegistryHydration.ts"; import { + haveProvidersChanged, mergeProviderSnapshot, upsertProviderWorkspaceSnapshot, ProviderRegistryLive, @@ -59,6 +60,7 @@ import type { ProviderInstance } from "../ProviderDriver.ts"; import * as ProviderInstanceRegistry from "../Services/ProviderInstanceRegistry.ts"; import * as ProviderRegistry from "../Services/ProviderRegistry.ts"; import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts"; +import * as DirenvEnvironment from "../DirenvEnvironment.ts"; const decodeServerSettings = Schema.decodeSync(ServerSettings); const encodeServerSettings = Schema.encodeSync(ServerSettings); const encodedDefaultServerSettings = encodeServerSettings(DEFAULT_SERVER_SETTINGS); @@ -361,201 +363,205 @@ const awaitPersistedProvider = ( Effect.forkScoped, ); -it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), TestHttpClientLive))( - "ProviderRegistry", - (it) => { - describe("checkCodexProviderStatus", () => { - it.effect("uses the app-server account and model list for provider status", () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => - Effect.succeed( - makeCodexProbeSnapshot({ - skills: [ - { - name: "github:gh-fix-ci", - path: "/Users/test/.codex/skills/gh-fix-ci/SKILL.md", - enabled: true, - displayName: "CI Debug", - shortDescription: "Debug failing GitHub Actions checks", - }, - ], - }), - ), - ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.installed, true); - assert.strictEqual(status.version, "1.0.0"); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "chatgpt"); - assert.strictEqual(status.auth.label, "ChatGPT Pro 20x Subscription"); - assert.strictEqual(status.auth.email, "test@example.com"); - assert.deepStrictEqual(status.models, [ - { - slug: "gpt-live-codex", - name: "GPT Live Codex", - isCustom: false, - capabilities: codexModelCapabilities, - }, - ]); - assert.deepStrictEqual(status.skills, [ - { - name: "github:gh-fix-ci", - path: "/Users/test/.codex/skills/gh-fix-ci/SKILL.md", - enabled: true, - displayName: "CI Debug", - shortDescription: "Debug failing GitHub Actions checks", - }, - ]); - assert.deepStrictEqual(status.slashCommands.slice(1), [ - { - name: "feedback", - description: "Send this thread and Codex logs to OpenAI", - input: { hint: "Describe the issue (optional)" }, - }, - ]); - }), - ); +it.layer( + Layer.mergeAll( + NodeServices.layer, + ServerSettingsModule.layerTest(), + TestHttpClientLive, + DirenvEnvironment.layerNoop, + ), +)("ProviderRegistry", (it) => { + describe("checkCodexProviderStatus", () => { + it.effect("uses the app-server account and model list for provider status", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => + Effect.succeed( + makeCodexProbeSnapshot({ + skills: [ + { + name: "github:gh-fix-ci", + path: "/Users/test/.codex/skills/gh-fix-ci/SKILL.md", + enabled: true, + displayName: "CI Debug", + shortDescription: "Debug failing GitHub Actions checks", + }, + ], + }), + ), + ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.installed, true); + assert.strictEqual(status.version, "1.0.0"); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "chatgpt"); + assert.strictEqual(status.auth.label, "ChatGPT Pro 20x Subscription"); + assert.strictEqual(status.auth.email, "test@example.com"); + assert.deepStrictEqual(status.models, [ + { + slug: "gpt-live-codex", + name: "GPT Live Codex", + isCustom: false, + capabilities: codexModelCapabilities, + }, + ]); + assert.deepStrictEqual(status.skills, [ + { + name: "github:gh-fix-ci", + path: "/Users/test/.codex/skills/gh-fix-ci/SKILL.md", + enabled: true, + displayName: "CI Debug", + shortDescription: "Debug failing GitHub Actions checks", + }, + ]); + assert.deepStrictEqual(status.slashCommands.slice(1), [ + { + name: "feedback", + description: "Send this thread and Codex logs to OpenAI", + input: { hint: "Describe the issue (optional)" }, + }, + ]); + }), + ); - it.effect("passes configured launch args to the Codex provider probe", () => - Effect.gen(function* () { - let observedLaunchArgs: string | undefined; - const settings = decodeCodexSettings({ launchArgs: "--strict-config --enable foo" }); + it.effect("passes configured launch args to the Codex provider probe", () => + Effect.gen(function* () { + let observedLaunchArgs: string | undefined; + const settings = decodeCodexSettings({ launchArgs: "--strict-config --enable foo" }); - const status = yield* checkCodexProviderStatus(settings, (input) => { - observedLaunchArgs = input.launchArgs; - return Effect.succeed(makeCodexProbeSnapshot()); - }); + const status = yield* checkCodexProviderStatus(settings, (input) => { + observedLaunchArgs = input.launchArgs; + return Effect.succeed(makeCodexProbeSnapshot()); + }); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(observedLaunchArgs, "--strict-config --enable foo"); - }), - ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(observedLaunchArgs, "--strict-config --enable foo"); + }), + ); - it.effect("returns unauthenticated when app-server requires OpenAI auth", () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => - Effect.succeed( - makeCodexProbeSnapshot({ - account: { - account: null, - requiresOpenaiAuth: true, - }, - }), - ), - ); + it.effect("returns unauthenticated when app-server requires OpenAI auth", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => + Effect.succeed( + makeCodexProbeSnapshot({ + account: { + account: null, + requiresOpenaiAuth: true, + }, + }), + ), + ); - assert.strictEqual(status.status, "error"); - assert.strictEqual(status.auth.status, "unauthenticated"); - assert.strictEqual( - status.message, - "Codex CLI is not authenticated. Run `codex login` and try again.", - ); - }), - ); + assert.strictEqual(status.status, "error"); + assert.strictEqual(status.auth.status, "unauthenticated"); + assert.strictEqual( + status.message, + "Codex CLI is not authenticated. Run `codex login` and try again.", + ); + }), + ); - it.effect( - "returns ready with unknown auth when app-server does not require OpenAI auth", - () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => - Effect.succeed( - makeCodexProbeSnapshot({ - account: { - account: null, - requiresOpenaiAuth: false, - }, - }), - ), - ); + it.effect("returns ready with unknown auth when app-server does not require OpenAI auth", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => + Effect.succeed( + makeCodexProbeSnapshot({ + account: { + account: null, + requiresOpenaiAuth: false, + }, + }), + ), + ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.auth.status, "unknown"); - }), - ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.auth.status, "unknown"); + }), + ); - it.effect("returns an api key label for codex api key auth", () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => - Effect.succeed( - makeCodexProbeSnapshot({ - account: { - account: { type: "apiKey" }, - requiresOpenaiAuth: false, - }, - }), - ), - ); + it.effect("returns an api key label for codex api key auth", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => + Effect.succeed( + makeCodexProbeSnapshot({ + account: { + account: { type: "apiKey" }, + requiresOpenaiAuth: false, + }, + }), + ), + ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "apiKey"); - assert.strictEqual(status.auth.label, "OpenAI API Key"); - }), - ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "apiKey"); + assert.strictEqual(status.auth.label, "OpenAI API Key"); + }), + ); - it.effect("returns an Amazon Bedrock label for codex Bedrock auth", () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => - Effect.succeed( - makeCodexProbeSnapshot({ - account: { - account: { type: "amazonBedrock" }, - requiresOpenaiAuth: false, - }, - }), - ), - ); + it.effect("returns an Amazon Bedrock label for codex Bedrock auth", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => + Effect.succeed( + makeCodexProbeSnapshot({ + account: { + account: { type: "amazonBedrock" }, + requiresOpenaiAuth: false, + }, + }), + ), + ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "amazonBedrock"); - assert.strictEqual(status.auth.label, "Amazon Bedrock"); - }), - ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "amazonBedrock"); + assert.strictEqual(status.auth.label, "Amazon Bedrock"); + }), + ); - it.effect("returns unavailable when codex is missing", () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => - Effect.fail( - new CodexErrors.CodexAppServerSpawnError({ - command: "codex app-server", - cause: new Error("spawn codex ENOENT"), - }), - ), - ); - assert.strictEqual(status.status, "error"); - assert.strictEqual(status.installed, false); - assert.strictEqual(status.auth.status, "unknown"); - assert.strictEqual(status.message, "Codex CLI (`codex`) was not found on PATH."); - }), - ); + it.effect("returns unavailable when codex is missing", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(defaultCodexSettings, () => + Effect.fail( + new CodexErrors.CodexAppServerSpawnError({ + command: "codex app-server", + cause: new Error("spawn codex ENOENT"), + }), + ), + ); + assert.strictEqual(status.status, "error"); + assert.strictEqual(status.installed, false); + assert.strictEqual(status.auth.status, "unknown"); + assert.strictEqual(status.message, "Codex CLI (`codex`) was not found on PATH."); + }), + ); - it.effect("closes the app-server probe scope when provider status times out", () => - Effect.gen(function* () { - const killCalls = yield* Ref.make(0); - const statusFiber = yield* checkCodexProviderStatus(defaultCodexSettings).pipe( - Effect.provide(hangingScopedSpawnerLayer(killCalls)), - Effect.forkChild, - ); + it.effect("closes the app-server probe scope when provider status times out", () => + Effect.gen(function* () { + const killCalls = yield* Ref.make(0); + const statusFiber = yield* checkCodexProviderStatus(defaultCodexSettings).pipe( + Effect.provide(hangingScopedSpawnerLayer(killCalls)), + Effect.forkChild, + ); - yield* Effect.yieldNow; - yield* TestClock.adjust("11 seconds"); - yield* Effect.yieldNow; + yield* Effect.yieldNow; + yield* TestClock.adjust("11 seconds"); + yield* Effect.yieldNow; - const status = yield* Fiber.join(statusFiber); - assert.strictEqual(status.status, "error"); - assert.strictEqual( - status.message, - "Timed out while checking Codex app-server provider status.", - ); - assert.strictEqual(yield* Ref.get(killCalls), 1); - }), - ); - }); + const status = yield* Fiber.join(statusFiber); + assert.strictEqual(status.status, "error"); + assert.strictEqual( + status.message, + "Timed out while checking Codex app-server provider status.", + ); + assert.strictEqual(yield* Ref.get(killCalls), 1); + }), + ); + }); - describe("ProviderRegistryLive", () => { - it("stores workspace skills and commands without changing machine metadata", () => { - const provider = { + describe("ProviderRegistryLive", () => { + it("treats equal provider snapshots as unchanged", () => { + const providers = [ + { instanceId: ProviderInstanceId.make("codex"), driver: ProviderDriverKind.make("codex"), status: "ready", @@ -565,1242 +571,1107 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te checkedAt: "2026-03-25T00:00:00.000Z", version: "1.0.0", models: [], - slashCommands: [{ name: "global" }], - skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }], - } satisfies ServerProvider; - const scopedSnapshot = { - ...provider, - checkedAt: "2026-03-25T00:01:00.000Z", - slashCommands: [{ name: "project" }], - skills: [{ name: "project", path: "/project/SKILL.md", enabled: true }], - } satisfies ServerProvider; - - const result = upsertProviderWorkspaceSnapshot(provider, "/project", scopedSnapshot); - - assert.deepStrictEqual(result.slashCommands, provider.slashCommands); - assert.deepStrictEqual(result.skills, provider.skills); - assert.deepStrictEqual(result.workspaceSnapshots, [ - { - cwd: "/project", - checkedAt: scopedSnapshot.checkedAt, - slashCommands: scopedSnapshot.slashCommands, - skills: scopedSnapshot.skills, - }, - ]); - }); - - it("preserves previously discovered provider models when a refresh returns none", () => { - const previousProvider = { - instanceId: ProviderInstanceId.make("cursor"), - driver: ProviderDriverKind.make("cursor"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-04-14T00:00:00.000Z", - version: "2026.04.09-f2b0fcd", - models: [ - { - slug: "claude-opus-4-6", - name: "Opus 4.6", - isCustom: false, - capabilities: createModelCapabilities({ - optionDescriptors: [ - selectDescriptor("reasoning", "Reasoning", [ - { id: "high", label: "High", isDefault: true }, - ]), - booleanDescriptor("fastMode", "Fast Mode"), - booleanDescriptor("thinking", "Thinking"), - ], - }), - }, - ], - slashCommands: [{ name: "review", description: "Review changes" }], - skills: [ - { - name: "typescript", - description: "TypeScript help", - path: "/skills/typescript/SKILL.md", - enabled: true, - }, - ], - } as const satisfies ServerProvider; - const refreshedProvider = { - ...previousProvider, - checkedAt: "2026-04-14T00:01:00.000Z", - models: [], slashCommands: [], skills: [], - } satisfies ServerProvider; - - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ - ...previousProvider.models, - ]); - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, refreshedProvider).slashCommands, - [], - ); - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, refreshedProvider).skills, - [], - ); - }); - - it("drops custom models the refreshed snapshot no longer carries", () => { - const previousProvider = { + }, + { instanceId: ProviderInstanceId.make("claudeAgent"), driver: ProviderDriverKind.make("claudeAgent"), - status: "ready", + status: "warning", enabled: true, installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-04-14T00:00:00.000Z", - version: "2.1.0", - models: [ - { - slug: "claude-sonnet-4-6", - name: "Sonnet 4.6", - isCustom: false, - capabilities: null, - }, - { - slug: "removed-custom", - name: "removed-custom", - isCustom: true, - capabilities: null, - }, - ], + auth: { status: "unknown" }, + checkedAt: "2026-03-25T00:00:00.000Z", + version: "1.0.0", + models: [], slashCommands: [], skills: [], - } as const satisfies ServerProvider; - const refreshedProvider = { - ...previousProvider, - checkedAt: "2026-04-14T00:01:00.000Z", - models: [previousProvider.models[0]], - } satisfies ServerProvider; + }, + ] as const satisfies ReadonlyArray; - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ - ...refreshedProvider.models, - ]); - }); + assert.strictEqual(haveProvidersChanged(providers, [...providers]), false); + }); - it("drops stale OpenCode models missing from a successful refresh", () => { - const previousProvider = { - instanceId: ProviderInstanceId.make("opencode"), - driver: ProviderDriverKind.make("opencode"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-07-17T00:00:00.000Z", - version: "1.0.0", - models: [ - { - slug: "github/gpt-5", - name: "GPT-5", - subProvider: "GitHub", - isCustom: false, - capabilities: null, - }, - { - slug: "removed-plugin/model", - name: "Removed Plugin Model", - subProvider: "Removed Plugin", - isCustom: false, - capabilities: null, - }, - ], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const refreshedProvider = { - ...previousProvider, - checkedAt: "2026-07-17T00:01:00.000Z", - models: [ - { - slug: "github/gpt-5", - name: "GPT-5", - subProvider: "GitHub", - isCustom: false, - capabilities: null, - }, - ], - } satisfies ServerProvider; + it("stores workspace skills and commands without changing machine metadata", () => { + const provider = { + instanceId: ProviderInstanceId.make("codex"), + driver: ProviderDriverKind.make("codex"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-03-25T00:00:00.000Z", + version: "1.0.0", + models: [], + slashCommands: [{ name: "global" }], + skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }], + } satisfies ServerProvider; + const scopedSnapshot = { + ...provider, + checkedAt: "2026-03-25T00:01:00.000Z", + slashCommands: [{ name: "project" }], + skills: [{ name: "project", path: "/project/SKILL.md", enabled: true }], + } satisfies ServerProvider; + + const result = upsertProviderWorkspaceSnapshot(provider, "/project", scopedSnapshot); + + assert.deepStrictEqual(result.slashCommands, provider.slashCommands); + assert.deepStrictEqual(result.skills, provider.skills); + assert.deepStrictEqual(result.workspaceSnapshots, [ + { + cwd: "/project", + checkedAt: scopedSnapshot.checkedAt, + slashCommands: scopedSnapshot.slashCommands, + skills: scopedSnapshot.skills, + }, + ]); + }); - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ - ...refreshedProvider.models, - ]); - }); + it("preserves previously discovered provider models when a refresh returns none", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("cursor"), + driver: ProviderDriverKind.make("cursor"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-14T00:00:00.000Z", + version: "2026.04.09-f2b0fcd", + models: [ + { + slug: "claude-opus-4-6", + name: "Opus 4.6", + isCustom: false, + capabilities: createModelCapabilities({ + optionDescriptors: [ + selectDescriptor("reasoning", "Reasoning", [ + { id: "high", label: "High", isDefault: true }, + ]), + booleanDescriptor("fastMode", "Fast Mode"), + booleanDescriptor("thinking", "Thinking"), + ], + }), + }, + ], + slashCommands: [{ name: "review", description: "Review changes" }], + skills: [ + { + name: "typescript", + description: "TypeScript help", + path: "/skills/typescript/SKILL.md", + enabled: true, + }, + ], + } as const satisfies ServerProvider; + const refreshedProvider = { + ...previousProvider, + checkedAt: "2026-04-14T00:01:00.000Z", + models: [], + slashCommands: [], + skills: [], + } satisfies ServerProvider; + + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ + ...previousProvider.models, + ]); + assert.deepStrictEqual( + mergeProviderSnapshot(previousProvider, refreshedProvider).slashCommands, + [], + ); + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).skills, []); + }); - it("retains stale OpenCode models when a refresh fails", () => { - const previousProvider = { - instanceId: ProviderInstanceId.make("opencode"), - driver: ProviderDriverKind.make("opencode"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-07-17T00:00:00.000Z", - version: "1.0.0", - models: [ - { - slug: "github/gpt-5", - name: "GPT-5", - subProvider: "GitHub", - isCustom: false, - capabilities: null, - }, - ], - slashCommands: [{ name: "review", description: "Review changes" }], - skills: [ - { - name: "typescript", - description: "TypeScript help", - path: "/skills/typescript/SKILL.md", - enabled: true, - }, - ], - } as const satisfies ServerProvider; - const refreshedProvider = { - ...previousProvider, - status: "error", - auth: { status: "unknown" }, - checkedAt: "2026-07-17T00:01:00.000Z", - models: [], - message: "Failed to refresh OpenCode models.", - } satisfies ServerProvider; + it("drops custom models the refreshed snapshot no longer carries", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: ProviderDriverKind.make("claudeAgent"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-14T00:00:00.000Z", + version: "2.1.0", + models: [ + { + slug: "claude-sonnet-4-6", + name: "Sonnet 4.6", + isCustom: false, + capabilities: null, + }, + { + slug: "removed-custom", + name: "removed-custom", + isCustom: true, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const refreshedProvider = { + ...previousProvider, + checkedAt: "2026-04-14T00:01:00.000Z", + models: [previousProvider.models[0]], + } satisfies ServerProvider; + + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ + ...refreshedProvider.models, + ]); + }); - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ - ...previousProvider.models, - ]); - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, refreshedProvider).slashCommands, - previousProvider.slashCommands, - ); - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, refreshedProvider).skills, - previousProvider.skills, - ); + it("drops stale OpenCode models missing from a successful refresh", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("opencode"), + driver: ProviderDriverKind.make("opencode"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-07-17T00:00:00.000Z", + version: "1.0.0", + models: [ + { + slug: "github/gpt-5", + name: "GPT-5", + subProvider: "GitHub", + isCustom: false, + capabilities: null, + }, + { + slug: "removed-plugin/model", + name: "Removed Plugin Model", + subProvider: "Removed Plugin", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const refreshedProvider = { + ...previousProvider, + checkedAt: "2026-07-17T00:01:00.000Z", + models: [ + { + slug: "github/gpt-5", + name: "GPT-5", + subProvider: "GitHub", + isCustom: false, + capabilities: null, + }, + ], + } satisfies ServerProvider; + + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ + ...refreshedProvider.models, + ]); + }); + + it("retains stale OpenCode models when a refresh fails", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("opencode"), + driver: ProviderDriverKind.make("opencode"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-07-17T00:00:00.000Z", + version: "1.0.0", + models: [ + { + slug: "github/gpt-5", + name: "GPT-5", + subProvider: "GitHub", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [{ name: "review", description: "Review changes" }], + skills: [ + { + name: "typescript", + description: "TypeScript help", + path: "/skills/typescript/SKILL.md", + enabled: true, + }, + ], + } as const satisfies ServerProvider; + const refreshedProvider = { + ...previousProvider, + status: "error", + auth: { status: "unknown" }, + checkedAt: "2026-07-17T00:01:00.000Z", + models: [], + message: "Failed to refresh OpenCode models.", + } satisfies ServerProvider; + + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ + ...previousProvider.models, + ]); + assert.deepStrictEqual( + mergeProviderSnapshot(previousProvider, refreshedProvider).slashCommands, + previousProvider.slashCommands, + ); + assert.deepStrictEqual( + mergeProviderSnapshot(previousProvider, refreshedProvider).skills, + previousProvider.skills, + ); + }); + + it("classifies pending, logout, uninstall, and reconnect OpenCode inventories", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("opencode"), + driver: ProviderDriverKind.make("opencode"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-07-17T00:00:00.000Z", + version: "1.0.0", + models: [ + { + slug: "github/gpt-5", + name: "GPT-5", + subProvider: "GitHub", + isCustom: false, + capabilities: null, + }, + { + slug: "removed-plugin/model", + name: "Removed Plugin Model", + subProvider: "Removed Plugin", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [{ name: "review", description: "Review changes" }], + skills: [ + { + name: "typescript", + description: "TypeScript help", + path: "/skills/typescript/SKILL.md", + enabled: true, + }, + ], + } as const satisfies ServerProvider; + const pendingProvider = { + ...previousProvider, + status: "warning", + installed: false, + auth: { status: "unknown" }, + checkedAt: "2026-07-17T00:01:00.000Z", + version: null, + models: [], + message: "OpenCode provider status has not been checked in this session yet.", + } satisfies ServerProvider; + const loggedOutProvider = { + ...previousProvider, + status: "warning", + auth: { status: "unknown" }, + checkedAt: "2026-07-17T00:02:00.000Z", + models: [], + slashCommands: [], + skills: [], + message: "OpenCode is available, but it did not report any connected upstream providers.", + } satisfies ServerProvider; + const missingProvider = { + ...previousProvider, + status: "error", + installed: false, + auth: { status: "unknown" }, + checkedAt: "2026-07-17T00:03:00.000Z", + version: null, + models: [], + message: "OpenCode CLI (`opencode`) is not installed or not on PATH.", + } satisfies ServerProvider; + const authoritativeProvider = { + ...previousProvider, + checkedAt: "2026-07-17T00:04:00.000Z", + models: [previousProvider.models[0]!], + } satisfies ServerProvider; + const failedProvider = { + ...authoritativeProvider, + status: "error", + auth: { status: "unknown" }, + checkedAt: "2026-07-17T00:05:00.000Z", + models: [], + message: "Failed to refresh OpenCode models.", + } satisfies ServerProvider; + + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, pendingProvider).models, [ + ...previousProvider.models, + ]); + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, loggedOutProvider).models, []); + assert.deepStrictEqual( + mergeProviderSnapshot(previousProvider, loggedOutProvider).slashCommands, + [], + ); + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, loggedOutProvider).skills, []); + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, missingProvider).models, []); + + const afterRemoval = mergeProviderSnapshot(previousProvider, authoritativeProvider); + const afterFailure = mergeProviderSnapshot(afterRemoval, failedProvider); + + assert.deepStrictEqual(afterFailure.models, [authoritativeProvider.models[0]!]); + }); + + describe("Codex model inventories", () => { + const cachedProvider = { + instanceId: ProviderInstanceId.make("codex-personal"), + driver: ProviderDriverKind.make("codex"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-09-04T19:00:00.000Z", + version: "0.153.3", + models: ["vega-alpha", "joule-alpha", "kindle-alpha", "ultima-alpha", "solstice-alpha"].map( + (slug) => ({ slug, name: slug, isCustom: false, capabilities: null }), + ), + slashCommands: [], + skills: [], + } satisfies ServerProvider; + const customModel = { + slug: "custom-model", + name: "Custom model", + isCustom: true, + capabilities: null, + } as const; + const refreshedProvider = { + ...cachedProvider, + checkedAt: "2026-09-04T19:01:00.000Z", + models: [ + { slug: "gpt-6-astra", name: "GPT 6 Astra", isCustom: false, capabilities: null }, + cachedProvider.models[0]!, + customModel, + ], + } satisfies ServerProvider; + const pendingProvider = { + ...cachedProvider, + status: "warning", + installed: false, + auth: { status: "unknown" }, + models: [customModel], + } satisfies ServerProvider; + const failedProvider = { + ...pendingProvider, + checkedAt: "2026-09-04T19:02:00.000Z", + status: "error", + installed: true, + } satisfies ServerProvider; + + it("drops retired alpha models after discovery, including without OpenAI authentication", () => { + for (const authStatus of ["authenticated", "unknown"] as const) { + assert.deepStrictEqual( + mergeProviderSnapshot(cachedProvider, { + ...refreshedProvider, + auth: { status: authStatus }, + }).models, + refreshedProvider.models, + ); + } }); - it("classifies pending, logout, uninstall, and reconnect OpenCode inventories", () => { - const previousProvider = { - instanceId: ProviderInstanceId.make("opencode"), - driver: ProviderDriverKind.make("opencode"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-07-17T00:00:00.000Z", - version: "1.0.0", - models: [ - { - slug: "github/gpt-5", - name: "GPT-5", - subProvider: "GitHub", - isCustom: false, - capabilities: null, + it("keeps discovered models during startup and failed probes without restoring removed custom models", () => { + for (const provider of [pendingProvider, failedProvider]) { + assert.deepStrictEqual( + mergeProviderSnapshot( + { + ...cachedProvider, + models: [...cachedProvider.models, { ...customModel, slug: "removed-custom" }], + }, + provider, + ).models, + [customModel, ...cachedProvider.models], + ); + } + }); + + it("clears discovered models after sign-out, disable, uninstall, or empty discovery", () => { + const emptyProvider = { ...refreshedProvider, models: [customModel] }; + const clearedProviders = [ + { ...emptyProvider, status: "error", auth: { status: "unauthenticated" } }, + { ...emptyProvider, status: "disabled", enabled: false }, + { ...emptyProvider, status: "error", installed: false, auth: { status: "unknown" } }, + emptyProvider, + { ...emptyProvider, models: [] }, + ] satisfies ReadonlyArray; + + for (const provider of clearedProviders) { + assert.deepStrictEqual( + mergeProviderSnapshot(cachedProvider, provider).models, + provider.models, + ); + } + }); + + it.effect("persists removals across failed refreshes and registry restarts", () => + Effect.gen(function* () { + const config = yield* ServerConfig.ServerConfig; + const filePath = yield* resolveProviderStatusCachePath({ + cacheDir: config.providerStatusCacheDir, + instanceId: cachedProvider.instanceId, + }); + yield* writeProviderStatusCache({ filePath, provider: cachedProvider }); + const nextProvider = yield* Ref.make(refreshedProvider); + const instance = { + instanceId: cachedProvider.instanceId, + driverKind: cachedProvider.driver, + continuationIdentity: { + driverKind: cachedProvider.driver, + continuationKey: "codex:instance:codex-personal", }, - { - slug: "removed-plugin/model", - name: "Removed Plugin Model", - subProvider: "Removed Plugin", - isCustom: false, - capabilities: null, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: cachedProvider.driver, + packageName: null, + }), + ), + getSnapshot: Effect.succeed(pendingProvider), + refresh: Ref.get(nextProvider), + streamChanges: Stream.empty, + applyUsageLimits: () => Effect.void, }, - ], - slashCommands: [{ name: "review", description: "Review changes" }], - skills: [ + adapter: {} as ProviderInstance["adapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + } satisfies ProviderInstance; + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, { - name: "typescript", - description: "TypeScript help", - path: "/skills/typescript/SKILL.md", - enabled: true, + getInstance: (id) => + Effect.succeed(id === instance.instanceId ? instance : undefined), + listInstances: Effect.succeed([instance]), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), }, - ], - } as const satisfies ServerProvider; - const pendingProvider = { - ...previousProvider, - status: "warning", - installed: false, - auth: { status: "unknown" }, - checkedAt: "2026-07-17T00:01:00.000Z", - version: null, - models: [], - message: "OpenCode provider status has not been checked in this session yet.", - } satisfies ServerProvider; - const loggedOutProvider = { + ); + const retainedModels = [ + customModel, + ...refreshedProvider.models.filter((model) => !model.isCustom), + ]; + + for (const restarted of [false, true]) { + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const expectedModels = restarted + ? retainedModels + : [customModel, ...cachedProvider.models]; + assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, expectedModels); + + yield* registry.refreshInstance(instance.instanceId); + assert.deepStrictEqual( + (yield* readProviderStatusCache(filePath))?.models, + restarted ? retainedModels : refreshedProvider.models, + ); + + yield* Ref.set(nextProvider, failedProvider); + const afterFailure = yield* registry.refreshInstance(instance.instanceId); + assert.deepStrictEqual(afterFailure[0]?.models, retainedModels); + assert.deepStrictEqual( + (yield* readProviderStatusCache(filePath))?.models, + retainedModels, + ); + }).pipe( + Effect.provide(ProviderRegistryLive.pipe(Layer.provide(instanceRegistryLayer))), + Effect.scoped, + ); + } + }).pipe( + Effect.provide( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-codex-retired-model-cache-", + }).pipe(Layer.provideMerge(NodeServices.layer)), + ), + ), + ); + }); + + describe("Antigravity model inventories", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("antigravity-personal"), + driver: ProviderDriverKind.make("antigravity"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-09-02T00:00:00.000Z", + version: "0.1.3", + models: [ + { + slug: "gemini-3.1-pro-high", + name: "Gemini 3.1 Pro High", + isCustom: false, + capabilities: null, + }, + { + slug: "gemini-3-flash", + name: "Gemini 3 Flash", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + + it("removes unavailable models after a successful refresh", () => { + for (const status of ["ready", "warning"] as const) { + const refreshedProvider = { + ...previousProvider, + status, + checkedAt: "2026-09-02T00:01:00.000Z", + models: [previousProvider.models[1]], + } satisfies ServerProvider; + const afterRefresh = mergeProviderSnapshot(previousProvider, refreshedProvider); + + assert.deepStrictEqual(afterRefresh.models, refreshedProvider.models); + + const afterFailure = mergeProviderSnapshot(afterRefresh, { + ...refreshedProvider, + status: "error", + auth: { status: "unknown" }, + models: [], + }); + assert.deepStrictEqual(afterFailure.models, refreshedProvider.models); + } + }); + + it("keeps cached models during health checks and temporary failures", () => { + for (const installed of [false, true]) { + const pendingProvider = { + ...previousProvider, + status: "warning", + installed, + auth: { status: "unknown" }, + checkedAt: "2026-09-02T00:01:00.000Z", + version: installed ? previousProvider.version : null, + models: [], + } satisfies ServerProvider; + + assert.deepStrictEqual( + mergeProviderSnapshot(previousProvider, pendingProvider).models, + previousProvider.models, + ); + } + + for (const authStatus of ["unknown", "authenticated"] as const) { + const failedProvider = { + ...previousProvider, + status: "error", + auth: { status: authStatus }, + checkedAt: "2026-09-02T00:02:00.000Z", + models: [], + } satisfies ServerProvider; + + assert.deepStrictEqual( + mergeProviderSnapshot(previousProvider, failedProvider).models, + previousProvider.models, + ); + } + }); + + it("clears models after sign-out, disable, uninstall, or an empty successful refresh", () => { + const emptyProvider = { ...previousProvider, - status: "warning", - auth: { status: "unknown" }, - checkedAt: "2026-07-17T00:02:00.000Z", + checkedAt: "2026-09-02T00:01:00.000Z", models: [], - slashCommands: [], - skills: [], - message: "OpenCode is available, but it did not report any connected upstream providers.", } satisfies ServerProvider; - const missingProvider = { - ...previousProvider, - status: "error", + const clearedProviders = [ + { ...emptyProvider, status: "warning", auth: { status: "unauthenticated" } }, + { ...emptyProvider, status: "error", auth: { status: "unauthenticated" } }, + { ...emptyProvider, status: "disabled", enabled: false }, + { ...emptyProvider, status: "error", enabled: false }, + { ...emptyProvider, status: "error", installed: false, auth: { status: "unknown" } }, + emptyProvider, + ] satisfies ReadonlyArray; + + for (const provider of clearedProviders) { + const afterRemoval = mergeProviderSnapshot(previousProvider, provider); + assert.deepStrictEqual(afterRemoval.models, []); + + const afterFailure = mergeProviderSnapshot(afterRemoval, { + ...emptyProvider, + status: "error", + auth: { status: "unknown" }, + }); + assert.deepStrictEqual(afterFailure.models, []); + } + }); + }); + + describe("Antigravity saved account", () => { + const signedIn = { + instanceId: ProviderInstanceId.make("antigravity-personal"), + driver: ProviderDriverKind.make("antigravity"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated", type: "oauth-personal", label: "Google account" }, + checkedAt: "2026-09-05T00:00:00.000Z", + version: "agy_acp_server_1.1.1", + models: [ + { + slug: "gemini-3.7-flash-high", + name: "Gemini 3.7 Flash", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [{ name: "plan" }], + skills: [], + } as const satisfies ServerProvider; + const uncheckedMessage = + "Antigravity is installed. Google account access is not checked yet."; + const restartProbe = { + ...signedIn, + status: "warning", + auth: { status: "unknown" }, + checkedAt: "2026-09-05T00:01:00.000Z", + message: uncheckedMessage, + models: [], + } as const satisfies ServerProvider; + + it("keeps the saved Google account through restart health checks", () => { + const merged = mergeProviderSnapshot(signedIn, restartProbe); + const { message: _uncheckedMessage, ...probeWithoutMessage } = restartProbe; + assert.deepStrictEqual(merged, { + ...probeWithoutMessage, + status: "ready", + auth: signedIn.auth, + models: signedIn.models, + }); + assert.equal("message" in merged, false); + // The next periodic probe reads the merged snapshot as its previous state. + assert.deepStrictEqual(mergeProviderSnapshot(merged, restartProbe), merged); + }); + + it("carries the account through the boot probe and a failed probe without hiding them", () => { + const booting = { + ...restartProbe, installed: false, - auth: { status: "unknown" }, - checkedAt: "2026-07-17T00:03:00.000Z", version: null, - models: [], - message: "OpenCode CLI (`opencode`) is not installed or not on PATH.", - } satisfies ServerProvider; - const authoritativeProvider = { - ...previousProvider, - checkedAt: "2026-07-17T00:04:00.000Z", - models: [previousProvider.models[0]!], + message: "Checking Antigravity availability.", } satisfies ServerProvider; - const failedProvider = { - ...authoritativeProvider, + assert.deepStrictEqual(mergeProviderSnapshot(signedIn, booting), { + ...booting, + auth: signedIn.auth, + models: signedIn.models, + }); + + const failed = { + ...restartProbe, status: "error", - auth: { status: "unknown" }, - checkedAt: "2026-07-17T00:05:00.000Z", - models: [], - message: "Failed to refresh OpenCode models.", + message: "Antigravity did not respond to its local health check within 90 seconds.", } satisfies ServerProvider; + assert.deepStrictEqual(mergeProviderSnapshot(signedIn, failed), { + ...failed, + auth: signedIn.auth, + models: signedIn.models, + }); + }); - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, pendingProvider).models, [ - ...previousProvider.models, - ]); + it("does not invent an account after sign-out, disable, uninstall, or for other providers", () => { + const untouched = [ + { ...restartProbe, auth: { status: "unauthenticated" } }, + { ...restartProbe, status: "disabled", enabled: false }, + { ...restartProbe, status: "error", installed: false }, + { ...restartProbe, driver: ProviderDriverKind.make("codex") }, + // The instance was rebuilt with another sign-in method. + { ...restartProbe, auth: { status: "unknown", type: "gemini-api-key" } }, + ] satisfies ReadonlyArray; + for (const next of untouched) { + const merged = mergeProviderSnapshot(signedIn, next); + assert.deepStrictEqual(merged.auth, next.auth); + assert.equal(merged.status, next.status); + assert.equal(merged.message, next.message); + } assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, loggedOutProvider).models, - [], + mergeProviderSnapshot({ ...signedIn, auth: { status: "unknown" } }, restartProbe).auth, + { status: "unknown" }, ); - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, loggedOutProvider).slashCommands, - [], + assert.equal( + mergeProviderSnapshot( + { ...signedIn, driver: ProviderDriverKind.make("codex") }, + restartProbe, + ).auth.status, + "unknown", ); assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, loggedOutProvider).skills, - [], + mergeProviderSnapshot(signedIn, { + ...restartProbe, + auth: { status: "unknown", type: "oauth-personal" }, + }).auth, + signedIn.auth, ); - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, missingProvider).models, []); + }); + }); - const afterRemoval = mergeProviderSnapshot(previousProvider, authoritativeProvider); - const afterFailure = mergeProviderSnapshot(afterRemoval, failedProvider); + it("fills missing capabilities from the previous provider snapshot", () => { + const previousProvider = { + instanceId: ProviderInstanceId.make("cursor"), + driver: ProviderDriverKind.make("cursor"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-14T00:00:00.000Z", + version: "2026.04.09-f2b0fcd", + models: [ + { + slug: "claude-opus-4-6", + name: "Opus 4.6", + isCustom: false, + capabilities: createModelCapabilities({ + optionDescriptors: [ + selectDescriptor("reasoning", "Reasoning", [ + { id: "high", label: "High", isDefault: true }, + ]), + booleanDescriptor("fastMode", "Fast Mode"), + booleanDescriptor("thinking", "Thinking"), + ], + }), + }, + ], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const refreshedProvider = { + ...previousProvider, + checkedAt: "2026-04-14T00:01:00.000Z", + models: [ + { + slug: "claude-opus-4-6", + name: "Opus 4.6", + isCustom: false, + capabilities: createModelCapabilities({ + optionDescriptors: [], + }), + }, + ], + } satisfies ServerProvider; - assert.deepStrictEqual(afterFailure.models, [authoritativeProvider.models[0]!]); - }); + assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ + ...previousProvider.models, + ]); + }); - describe("Codex model inventories", () => { - const cachedProvider = { - instanceId: ProviderInstanceId.make("codex-personal"), - driver: ProviderDriverKind.make("codex"), + it.effect("does not run provider probes during layer construction", () => + Effect.gen(function* () { + const codexDriver = ProviderDriverKind.make("codex"); + const codexInstanceId = ProviderInstanceId.make("codex"); + const initialProvider = { + instanceId: codexInstanceId, + driver: codexDriver, + status: "warning", + enabled: true, + installed: false, + auth: { status: "unknown" }, + checkedAt: "2026-06-10T00:00:00.000Z", + version: null, + message: "Checking Codex provider status.", + models: [], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const refreshCalls = yield* Ref.make(0); + const instance = { + instanceId: codexInstanceId, + driverKind: codexDriver, + continuationIdentity: { + driverKind: codexDriver, + continuationKey: "codex:instance:codex", + }, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: codexDriver, + packageName: null, + }), + ), + getSnapshot: Effect.succeed(initialProvider), + refresh: Ref.update(refreshCalls, (count) => count + 1).pipe( + Effect.andThen(Effect.never), + ), + streamChanges: Stream.empty, + applyUsageLimits: () => Effect.void, + }, + adapter: {} as ProviderInstance["adapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + } satisfies ProviderInstance; + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, + { + getInstance: (instanceId) => + Effect.succeed(instanceId === codexInstanceId ? instance : undefined), + listInstances: Effect.succeed([instance]), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), + }, + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const runtimeServices = yield* Layer.build( + ProviderRegistryLive.pipe( + Layer.provideMerge(instanceRegistryLayer), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-background-refresh-", + }), + ), + Layer.provideMerge(NodeServices.layer), + ), + ).pipe(Scope.provide(scope)); + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + assert.deepStrictEqual(yield* registry.getProviders, [initialProvider]); + assert.strictEqual(yield* Ref.get(refreshCalls), 0); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + it.effect("deduplicates cwd probes and clears snapshots when an instance rebuilds", () => + Effect.gen(function* () { + const driver = ProviderDriverKind.make("codex"); + const instanceId = ProviderInstanceId.make("codex"); + const machineProvider = { + instanceId, + driver, status: "ready", enabled: true, installed: true, auth: { status: "authenticated" }, - checkedAt: "2026-09-04T19:00:00.000Z", - version: "0.153.3", - models: [ - "vega-alpha", - "joule-alpha", - "kindle-alpha", - "ultima-alpha", - "solstice-alpha", - ].map((slug) => ({ slug, name: slug, isCustom: false, capabilities: null })), - slashCommands: [], - skills: [], - } satisfies ServerProvider; - const customModel = { - slug: "custom-model", - name: "Custom model", - isCustom: true, - capabilities: null, - } as const; - const refreshedProvider = { - ...cachedProvider, - checkedAt: "2026-09-04T19:01:00.000Z", - models: [ - { slug: "gpt-6-astra", name: "GPT 6 Astra", isCustom: false, capabilities: null }, - cachedProvider.models[0]!, - customModel, - ], - } satisfies ServerProvider; - const pendingProvider = { - ...cachedProvider, - status: "warning", - installed: false, - auth: { status: "unknown" }, - models: [customModel], - } satisfies ServerProvider; - const failedProvider = { - ...pendingProvider, - checkedAt: "2026-09-04T19:02:00.000Z", - status: "error", - installed: true, - } satisfies ServerProvider; - - it("drops retired alpha models after discovery, including without OpenAI authentication", () => { - for (const authStatus of ["authenticated", "unknown"] as const) { - assert.deepStrictEqual( - mergeProviderSnapshot(cachedProvider, { - ...refreshedProvider, - auth: { status: authStatus }, - }).models, - refreshedProvider.models, - ); - } - }); - - it("keeps discovered models during startup and failed probes without restoring removed custom models", () => { - for (const provider of [pendingProvider, failedProvider]) { - assert.deepStrictEqual( - mergeProviderSnapshot( - { - ...cachedProvider, - models: [...cachedProvider.models, { ...customModel, slug: "removed-custom" }], - }, - provider, - ).models, - [customModel, ...cachedProvider.models], - ); - } - }); - - it("clears discovered models after sign-out, disable, uninstall, or empty discovery", () => { - const emptyProvider = { ...refreshedProvider, models: [customModel] }; - const clearedProviders = [ - { ...emptyProvider, status: "error", auth: { status: "unauthenticated" } }, - { ...emptyProvider, status: "disabled", enabled: false }, - { ...emptyProvider, status: "error", installed: false, auth: { status: "unknown" } }, - emptyProvider, - { ...emptyProvider, models: [] }, - ] satisfies ReadonlyArray; - - for (const provider of clearedProviders) { - assert.deepStrictEqual( - mergeProviderSnapshot(cachedProvider, provider).models, - provider.models, - ); - } - }); - - it.effect("persists removals across failed refreshes and registry restarts", () => - Effect.gen(function* () { - const config = yield* ServerConfig.ServerConfig; - const filePath = yield* resolveProviderStatusCachePath({ - cacheDir: config.providerStatusCacheDir, - instanceId: cachedProvider.instanceId, - }); - yield* writeProviderStatusCache({ filePath, provider: cachedProvider }); - const nextProvider = yield* Ref.make(refreshedProvider); - const instance = { - instanceId: cachedProvider.instanceId, - driverKind: cachedProvider.driver, - continuationIdentity: { - driverKind: cachedProvider.driver, - continuationKey: "codex:instance:codex-personal", - }, - displayName: undefined, - enabled: true, - snapshot: { - resolveMaintenance: () => - Effect.succeed( - makeManualOnlyProviderMaintenanceCapabilities({ - provider: cachedProvider.driver, - packageName: null, - }), - ), - getSnapshot: Effect.succeed(pendingProvider), - refresh: Ref.get(nextProvider), - streamChanges: Stream.empty, - applyUsageLimits: () => Effect.void, - }, - adapter: {} as ProviderInstance["adapter"], - textGeneration: {} as ProviderInstance["textGeneration"], - } satisfies ProviderInstance; - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, - { - getInstance: (id) => - Effect.succeed(id === instance.instanceId ? instance : undefined), - listInstances: Effect.succeed([instance]), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.empty, - subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), - }, - ); - const retainedModels = [ - customModel, - ...refreshedProvider.models.filter((model) => !model.isCustom), - ]; - - for (const restarted of [false, true]) { - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - const expectedModels = restarted - ? retainedModels - : [customModel, ...cachedProvider.models]; - assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, expectedModels); - - yield* registry.refreshInstance(instance.instanceId); - assert.deepStrictEqual( - (yield* readProviderStatusCache(filePath))?.models, - restarted ? retainedModels : refreshedProvider.models, - ); - - yield* Ref.set(nextProvider, failedProvider); - const afterFailure = yield* registry.refreshInstance(instance.instanceId); - assert.deepStrictEqual(afterFailure[0]?.models, retainedModels); - assert.deepStrictEqual( - (yield* readProviderStatusCache(filePath))?.models, - retainedModels, - ); - }).pipe( - Effect.provide(ProviderRegistryLive.pipe(Layer.provide(instanceRegistryLayer))), - Effect.scoped, - ); - } - }).pipe( - Effect.provide( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-codex-retired-model-cache-", - }).pipe(Layer.provideMerge(NodeServices.layer)), - ), - ), - ); - }); - - describe("Antigravity model inventories", () => { - const previousProvider = { - instanceId: ProviderInstanceId.make("antigravity-personal"), - driver: ProviderDriverKind.make("antigravity"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-09-02T00:00:00.000Z", - version: "0.1.3", - models: [ - { - slug: "gemini-3.1-pro-high", - name: "Gemini 3.1 Pro High", - isCustom: false, - capabilities: null, - }, - { - slug: "gemini-3-flash", - name: "Gemini 3 Flash", - isCustom: false, - capabilities: null, - }, - ], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - - it("removes unavailable models after a successful refresh", () => { - for (const status of ["ready", "warning"] as const) { - const refreshedProvider = { - ...previousProvider, - status, - checkedAt: "2026-09-02T00:01:00.000Z", - models: [previousProvider.models[1]], - } satisfies ServerProvider; - const afterRefresh = mergeProviderSnapshot(previousProvider, refreshedProvider); - - assert.deepStrictEqual(afterRefresh.models, refreshedProvider.models); - - const afterFailure = mergeProviderSnapshot(afterRefresh, { - ...refreshedProvider, - status: "error", - auth: { status: "unknown" }, - models: [], - }); - assert.deepStrictEqual(afterFailure.models, refreshedProvider.models); - } - }); - - it("keeps cached models during health checks and temporary failures", () => { - for (const installed of [false, true]) { - const pendingProvider = { - ...previousProvider, - status: "warning", - installed, - auth: { status: "unknown" }, - checkedAt: "2026-09-02T00:01:00.000Z", - version: installed ? previousProvider.version : null, - models: [], - } satisfies ServerProvider; - - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, pendingProvider).models, - previousProvider.models, - ); - } - - for (const authStatus of ["unknown", "authenticated"] as const) { - const failedProvider = { - ...previousProvider, - status: "error", - auth: { status: authStatus }, - checkedAt: "2026-09-02T00:02:00.000Z", - models: [], - } satisfies ServerProvider; - - assert.deepStrictEqual( - mergeProviderSnapshot(previousProvider, failedProvider).models, - previousProvider.models, - ); - } - }); - - it("clears models after sign-out, disable, uninstall, or an empty successful refresh", () => { - const emptyProvider = { - ...previousProvider, - checkedAt: "2026-09-02T00:01:00.000Z", - models: [], - } satisfies ServerProvider; - const clearedProviders = [ - { ...emptyProvider, status: "warning", auth: { status: "unauthenticated" } }, - { ...emptyProvider, status: "error", auth: { status: "unauthenticated" } }, - { ...emptyProvider, status: "disabled", enabled: false }, - { ...emptyProvider, status: "error", enabled: false }, - { ...emptyProvider, status: "error", installed: false, auth: { status: "unknown" } }, - emptyProvider, - ] satisfies ReadonlyArray; - - for (const provider of clearedProviders) { - const afterRemoval = mergeProviderSnapshot(previousProvider, provider); - assert.deepStrictEqual(afterRemoval.models, []); - - const afterFailure = mergeProviderSnapshot(afterRemoval, { - ...emptyProvider, - status: "error", - auth: { status: "unknown" }, - }); - assert.deepStrictEqual(afterFailure.models, []); - } - }); - }); - - describe("Antigravity saved account", () => { - const signedIn = { - instanceId: ProviderInstanceId.make("antigravity-personal"), - driver: ProviderDriverKind.make("antigravity"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated", type: "oauth-personal", label: "Google account" }, - checkedAt: "2026-09-05T00:00:00.000Z", - version: "agy_acp_server_1.1.1", - models: [ - { - slug: "gemini-3.7-flash-high", - name: "Gemini 3.7 Flash", - isCustom: false, - capabilities: null, - }, - ], - slashCommands: [{ name: "plan" }], - skills: [], - } as const satisfies ServerProvider; - const uncheckedMessage = - "Antigravity is installed. Google account access is not checked yet."; - const restartProbe = { - ...signedIn, - status: "warning", - auth: { status: "unknown" }, - checkedAt: "2026-09-05T00:01:00.000Z", - message: uncheckedMessage, + checkedAt: "2026-06-10T00:00:00.000Z", + version: "1.0.0", models: [], + slashCommands: [{ name: "global" }], + skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }], } as const satisfies ServerProvider; - - it("keeps the saved Google account through restart health checks", () => { - const merged = mergeProviderSnapshot(signedIn, restartProbe); - const { message: _uncheckedMessage, ...probeWithoutMessage } = restartProbe; - assert.deepStrictEqual(merged, { - ...probeWithoutMessage, - status: "ready", - auth: signedIn.auth, - models: signedIn.models, - }); - assert.equal("message" in merged, false); - // The next periodic probe reads the merged snapshot as its previous state. - assert.deepStrictEqual(mergeProviderSnapshot(merged, restartProbe), merged); - }); - - it("carries the account through the boot probe and a failed probe without hiding them", () => { - const booting = { - ...restartProbe, - installed: false, - version: null, - message: "Checking Antigravity availability.", - } satisfies ServerProvider; - assert.deepStrictEqual(mergeProviderSnapshot(signedIn, booting), { - ...booting, - auth: signedIn.auth, - models: signedIn.models, - }); - - const failed = { - ...restartProbe, - status: "error", - message: "Antigravity did not respond to its local health check within 90 seconds.", - } satisfies ServerProvider; - assert.deepStrictEqual(mergeProviderSnapshot(signedIn, failed), { - ...failed, - auth: signedIn.auth, - models: signedIn.models, - }); - }); - - it("does not invent an account after sign-out, disable, uninstall, or for other providers", () => { - const untouched = [ - { ...restartProbe, auth: { status: "unauthenticated" } }, - { ...restartProbe, status: "disabled", enabled: false }, - { ...restartProbe, status: "error", installed: false }, - { ...restartProbe, driver: ProviderDriverKind.make("codex") }, - // The instance was rebuilt with another sign-in method. - { ...restartProbe, auth: { status: "unknown", type: "gemini-api-key" } }, - ] satisfies ReadonlyArray; - for (const next of untouched) { - const merged = mergeProviderSnapshot(signedIn, next); - assert.deepStrictEqual(merged.auth, next.auth); - assert.equal(merged.status, next.status); - assert.equal(merged.message, next.message); - } - assert.deepStrictEqual( - mergeProviderSnapshot({ ...signedIn, auth: { status: "unknown" } }, restartProbe).auth, - { status: "unknown" }, - ); - assert.equal( - mergeProviderSnapshot( - { ...signedIn, driver: ProviderDriverKind.make("codex") }, - restartProbe, - ).auth.status, - "unknown", - ); - assert.deepStrictEqual( - mergeProviderSnapshot(signedIn, { - ...restartProbe, - auth: { status: "unknown", type: "oauth-personal" }, - }).auth, - signedIn.auth, - ); - }); - }); - - it("fills missing capabilities from the previous provider snapshot", () => { - const previousProvider = { - instanceId: ProviderInstanceId.make("cursor"), - driver: ProviderDriverKind.make("cursor"), - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-04-14T00:00:00.000Z", - version: "2026.04.09-f2b0fcd", - models: [ - { - slug: "claude-opus-4-6", - name: "Opus 4.6", - isCustom: false, - capabilities: createModelCapabilities({ - optionDescriptors: [ - selectDescriptor("reasoning", "Reasoning", [ - { id: "high", label: "High", isDefault: true }, - ]), - booleanDescriptor("fastMode", "Fast Mode"), - booleanDescriptor("thinking", "Thinking"), - ], - }), - }, - ], + const scopedProvider = { + ...machineProvider, + checkedAt: "2026-06-10T00:01:00.000Z", + slashCommands: [{ name: "project" }], + skills: [{ name: "project", path: "/workspace/SKILL.md", enabled: true }], + } as const satisfies ServerProvider; + const pendingScopedProvider = { + ...scopedProvider, + status: "error", + installed: false, slashCommands: [], - skills: [], } as const satisfies ServerProvider; - const refreshedProvider = { - ...previousProvider, - checkedAt: "2026-04-14T00:01:00.000Z", - models: [ - { - slug: "claude-opus-4-6", - name: "Opus 4.6", - isCustom: false, - capabilities: createModelCapabilities({ - optionDescriptors: [], - }), - }, - ], - } satisfies ServerProvider; - - assert.deepStrictEqual(mergeProviderSnapshot(previousProvider, refreshedProvider).models, [ - ...previousProvider.models, - ]); - }); - - it.effect("does not run provider probes during layer construction", () => - Effect.gen(function* () { - const codexDriver = ProviderDriverKind.make("codex"); - const codexInstanceId = ProviderInstanceId.make("codex"); - const initialProvider = { - instanceId: codexInstanceId, - driver: codexDriver, - status: "warning", - enabled: true, - installed: false, - auth: { status: "unknown" }, - checkedAt: "2026-06-10T00:00:00.000Z", - version: null, - message: "Checking Codex provider status.", - models: [], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const refreshCalls = yield* Ref.make(0); - const instance = { - instanceId: codexInstanceId, - driverKind: codexDriver, - continuationIdentity: { - driverKind: codexDriver, - continuationKey: "codex:instance:codex", - }, - displayName: undefined, - enabled: true, - snapshot: { - resolveMaintenance: () => - Effect.succeed( - makeManualOnlyProviderMaintenanceCapabilities({ - provider: codexDriver, - packageName: null, - }), - ), - getSnapshot: Effect.succeed(initialProvider), - refresh: Ref.update(refreshCalls, (count) => count + 1).pipe( - Effect.andThen(Effect.never), - ), - streamChanges: Stream.empty, - applyUsageLimits: () => Effect.void, - }, - adapter: {} as ProviderInstance["adapter"], - textGeneration: {} as ProviderInstance["textGeneration"], - } satisfies ProviderInstance; - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, - { - getInstance: (instanceId) => - Effect.succeed(instanceId === codexInstanceId ? instance : undefined), - listInstances: Effect.succeed([instance]), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.empty, - subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), - }, - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const runtimeServices = yield* Layer.build( - ProviderRegistryLive.pipe( - Layer.provideMerge(instanceRegistryLayer), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-background-refresh-", - }), - ), - Layer.provideMerge(NodeServices.layer), - ), - ).pipe(Scope.provide(scope)); - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - assert.deepStrictEqual(yield* registry.getProviders, [initialProvider]); - assert.strictEqual(yield* Ref.get(refreshCalls), 0); - }).pipe(Effect.provide(runtimeServices)); - }), - ); - - it.effect("deduplicates cwd probes and clears snapshots when an instance rebuilds", () => - Effect.gen(function* () { - const driver = ProviderDriverKind.make("codex"); - const instanceId = ProviderInstanceId.make("codex"); - const machineProvider = { - instanceId, - driver, - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-06-10T00:00:00.000Z", - version: "1.0.0", - models: [], - slashCommands: [{ name: "global" }], - skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }], - } as const satisfies ServerProvider; - const scopedProvider = { - ...machineProvider, - checkedAt: "2026-06-10T00:01:00.000Z", - slashCommands: [{ name: "project" }], - skills: [{ name: "project", path: "/workspace/SKILL.md", enabled: true }], - } as const satisfies ServerProvider; - const pendingScopedProvider = { - ...scopedProvider, - status: "error", - installed: false, - slashCommands: [], - } as const satisfies ServerProvider; - const snapshotCalls = yield* Ref.make(0); - const returnPendingSnapshot = yield* Ref.make(true); - const probeStarted = yield* Deferred.make(); - const releaseProbe = yield* Deferred.make(); - const makeInstance = ( - provider: ServerProvider, - snapshotForCwd: NonNullable, - ): ProviderInstance => ({ - instanceId, + const snapshotCalls = yield* Ref.make(0); + const returnPendingSnapshot = yield* Ref.make(true); + const probeStarted = yield* Deferred.make(); + const releaseProbe = yield* Deferred.make(); + const makeInstance = ( + provider: ServerProvider, + snapshotForCwd: NonNullable, + ): ProviderInstance => ({ + instanceId, + driverKind: driver, + continuationIdentity: { driverKind: driver, - continuationIdentity: { - driverKind: driver, - continuationKey: "codex:instance:codex", - }, - displayName: undefined, - enabled: true, - snapshot: { - resolveMaintenance: () => - Effect.succeed( - makeManualOnlyProviderMaintenanceCapabilities({ - provider: driver, - packageName: null, - }), - ), - getSnapshot: Effect.succeed(provider), - refresh: Effect.succeed(provider), - streamChanges: Stream.empty, - applyUsageLimits: () => Effect.void, - }, - snapshotForCwd, - adapter: {} as ProviderInstance["adapter"], - textGeneration: {} as ProviderInstance["textGeneration"], - }); - const firstInstance = makeInstance(machineProvider, () => - Effect.gen(function* () { - yield* Ref.update(snapshotCalls, (count) => count + 1); - if (yield* Ref.get(returnPendingSnapshot)) return pendingScopedProvider; - yield* Deferred.succeed(probeStarted, undefined); - yield* Deferred.await(releaseProbe); - return scopedProvider; - }), - ); - const rebuiltProvider = { - ...machineProvider, - checkedAt: "2026-06-10T00:02:00.000Z", - status: "warning", - installed: false, - auth: { status: "unknown" }, - } satisfies ServerProvider; - const rebuiltInstance = makeInstance(rebuiltProvider, () => - Ref.update(snapshotCalls, (count) => count + 1).pipe(Effect.as(scopedProvider)), - ); - const registryChanges = yield* PubSub.unbounded(); - const instancesRef = yield* Ref.make>([firstInstance]); - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, - { - getInstance: (requestedId) => - Ref.get(instancesRef).pipe( - Effect.map((instances) => - instances.find((instance) => instance.instanceId === requestedId), - ), - ), - listInstances: Ref.get(instancesRef), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.fromPubSub(registryChanges), - subscribeChanges: PubSub.subscribe(registryChanges), - }, - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const runtimeServices = yield* Layer.build( - ProviderRegistryLive.pipe( - Layer.provideMerge(instanceRegistryLayer), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-workspace-snapshot-", + continuationKey: "codex:instance:codex", + }, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: driver, + packageName: null, }), ), - Layer.provideMerge(NodeServices.layer), - ), - ).pipe(Scope.provide(scope)); - - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }); - assert.strictEqual((yield* registry.getProviders)[0]?.workspaceSnapshots, undefined); - yield* Ref.set(returnPendingSnapshot, false); - const workspaceUpdate = yield* registry.streamChanges.pipe( - Stream.runHead, - Effect.forkChild, - ); - yield* Effect.yieldNow; - const firstRefresh = yield* registry - .refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }) - .pipe(Effect.forkChild); - yield* Deferred.await(probeStarted); - const duplicateRefresh = yield* registry - .refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }) - .pipe(Effect.forkChild); - yield* Effect.yieldNow; - assert.strictEqual(yield* Ref.get(snapshotCalls), 2); - yield* Deferred.succeed(releaseProbe, undefined); - yield* Fiber.join(firstRefresh); - yield* Fiber.join(duplicateRefresh); - const published = yield* Fiber.join(workspaceUpdate); - assert.strictEqual(published._tag, "Some"); - const providers = yield* registry.getProviders; - assert.deepStrictEqual(providers[0]?.skills, machineProvider.skills); - assert.deepStrictEqual( - providers[0]?.workspaceSnapshots?.[0]?.skills, - scopedProvider.skills, - ); - yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }); - assert.strictEqual(yield* Ref.get(snapshotCalls), 2); - - yield* Ref.set(instancesRef, [rebuiltInstance]); - yield* PubSub.publish(registryChanges, undefined); - let rebuilt = yield* registry.getProviders; - for ( - let attempt = 0; - attempt < 50 && rebuilt[0]?.checkedAt !== rebuiltProvider.checkedAt; - attempt += 1 - ) { - yield* Effect.yieldNow; - rebuilt = yield* registry.getProviders; - } - assert.strictEqual(rebuilt[0]?.checkedAt, rebuiltProvider.checkedAt); - assert.strictEqual(rebuilt[0]?.workspaceSnapshots, undefined); - }).pipe(Effect.provide(runtimeServices)); - }), - ); - - it.effect("refreshes OpenCode catalogs and preserves other providers", () => - Effect.gen(function* () { - const codexDriver = ProviderDriverKind.make("codex"); - const openCodeDriver = ProviderDriverKind.make("opencode"); - const codexInstanceId = ProviderInstanceId.make("codex"); - const openCodeInstanceId = ProviderInstanceId.make("opencode"); - const codexRefreshCalls = yield* Ref.make(0); - const openCodeRefreshCalls = yield* Ref.make(0); - const codexProvider = { - instanceId: codexInstanceId, - driver: codexDriver, - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-06-10T00:00:00.000Z", - version: "1.0.0", - models: [], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const failedOpenCodeProvider = { - instanceId: openCodeInstanceId, - driver: openCodeDriver, - status: "error", - enabled: true, - installed: true, - auth: { status: "unknown" }, - checkedAt: "2026-06-10T00:00:00.000Z", - version: "1.0.0", - message: "Failed to refresh OpenCode models.", - models: [], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const recoveredOpenCodeProvider = { - ...failedOpenCodeProvider, - status: "ready", - auth: { status: "authenticated" }, - checkedAt: "2026-06-10T00:01:00.000Z", - message: "One upstream provider connected through OpenCode.", - models: [ - { - slug: "github/gpt-5", - name: "GPT-5", - subProvider: "GitHub", - isCustom: false, - capabilities: null, - }, - ], - } as const satisfies ServerProvider; - const changedCatalogProvider = { - ...recoveredOpenCodeProvider, - checkedAt: "2026-06-10T00:02:00.000Z", - models: [ - { - slug: "anthropic/claude-sonnet-4", - name: "Claude Sonnet 4", - subProvider: "Anthropic", - isCustom: false, - capabilities: null, - }, - ], - } as const satisfies ServerProvider; - const catalogSnapshot = yield* Ref.make(recoveredOpenCodeProvider); - const instances = [ - { - instanceId: codexInstanceId, - driverKind: codexDriver, - continuationIdentity: { - driverKind: codexDriver, - continuationKey: "codex:instance:codex", - }, - displayName: undefined, - enabled: true, - snapshot: { - resolveMaintenance: () => - Effect.succeed( - makeManualOnlyProviderMaintenanceCapabilities({ - provider: codexDriver, - packageName: null, - }), - ), - getSnapshot: Effect.succeed(codexProvider), - refresh: Ref.update(codexRefreshCalls, (count) => count + 1).pipe( - Effect.as(codexProvider), - ), - streamChanges: Stream.empty, - applyUsageLimits: () => Effect.void, - }, - adapter: {} as ProviderInstance["adapter"], - textGeneration: {} as ProviderInstance["textGeneration"], - }, - { - instanceId: openCodeInstanceId, - driverKind: openCodeDriver, - continuationIdentity: { - driverKind: openCodeDriver, - continuationKey: "opencode:instance:opencode", - }, - displayName: undefined, - enabled: true, - snapshot: { - resolveMaintenance: () => - Effect.succeed( - makeManualOnlyProviderMaintenanceCapabilities({ - provider: openCodeDriver, - packageName: null, - }), - ), - getSnapshot: Effect.succeed(failedOpenCodeProvider), - refresh: Ref.update(openCodeRefreshCalls, (count) => count + 1).pipe( - Effect.andThen(Ref.get(catalogSnapshot)), + getSnapshot: Effect.succeed(provider), + refresh: Effect.succeed(provider), + streamChanges: Stream.empty, + applyUsageLimits: () => Effect.void, + }, + snapshotForCwd, + adapter: {} as ProviderInstance["adapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + }); + const firstInstance = makeInstance(machineProvider, () => + Effect.gen(function* () { + yield* Ref.update(snapshotCalls, (count) => count + 1); + if (yield* Ref.get(returnPendingSnapshot)) return pendingScopedProvider; + yield* Deferred.succeed(probeStarted, undefined); + yield* Deferred.await(releaseProbe); + return scopedProvider; + }), + ); + const rebuiltProvider = { + ...machineProvider, + checkedAt: "2026-06-10T00:02:00.000Z", + status: "warning", + installed: false, + auth: { status: "unknown" }, + } satisfies ServerProvider; + const rebuiltInstance = makeInstance(rebuiltProvider, () => + Ref.update(snapshotCalls, (count) => count + 1).pipe(Effect.as(scopedProvider)), + ); + const registryChanges = yield* PubSub.unbounded(); + const instancesRef = yield* Ref.make>([firstInstance]); + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, + { + getInstance: (requestedId) => + Ref.get(instancesRef).pipe( + Effect.map((instances) => + instances.find((instance) => instance.instanceId === requestedId), ), - streamChanges: Stream.empty, - applyUsageLimits: () => Effect.void, - }, - adapter: {} as ProviderInstance["adapter"], - textGeneration: {} as ProviderInstance["textGeneration"], - }, - ] satisfies ReadonlyArray; - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, - { - getInstance: (instanceId) => - Effect.succeed(instances.find((instance) => instance.instanceId === instanceId)), - listInstances: Effect.succeed(instances), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.empty, - subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), - }, - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const runtimeServices = yield* Layer.build( - ProviderRegistryLive.pipe( - Layer.provideMerge(instanceRegistryLayer), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-reconnect-refresh-", - }), ), - Layer.provideMerge(NodeServices.layer), + listInstances: Ref.get(instancesRef), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.fromPubSub(registryChanges), + subscribeChanges: PubSub.subscribe(registryChanges), + }, + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const runtimeServices = yield* Layer.build( + ProviderRegistryLive.pipe( + Layer.provideMerge(instanceRegistryLayer), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-workspace-snapshot-", + }), ), - ).pipe(Scope.provide(scope)); - - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - const initialProviders = yield* registry.getProviders; - assert.strictEqual( - initialProviders.find((provider) => provider.instanceId === openCodeInstanceId) - ?.status, - "error", - ); - - const recoveredProviders = yield* registry.refresh(); - assert.deepStrictEqual( - recoveredProviders.find((provider) => provider.instanceId === openCodeInstanceId) - ?.models, - recoveredOpenCodeProvider.models, - ); - assert.deepStrictEqual( - recoveredProviders.find((provider) => provider.instanceId === codexInstanceId), - codexProvider, - ); - - yield* Ref.set(catalogSnapshot, changedCatalogProvider); - const changedProviders = yield* registry.refresh(); - assert.deepStrictEqual( - changedProviders.find((provider) => provider.instanceId === openCodeInstanceId) - ?.models, - changedCatalogProvider.models, - ); - assert.deepStrictEqual( - changedProviders.find((provider) => provider.instanceId === codexInstanceId), - codexProvider, - ); - }).pipe(Effect.provide(runtimeServices)); - - assert.strictEqual(yield* Ref.get(codexRefreshCalls), 2); - assert.strictEqual(yield* Ref.get(openCodeRefreshCalls), 2); - }), - ); - - it.effect("persists the merged snapshot when a live update has empty models", () => - Effect.gen(function* () { - const cursorDriver = ProviderDriverKind.make("cursor"); - const cursorInstanceId = ProviderInstanceId.make("cursor"); - const initialProvider = { - instanceId: cursorInstanceId, - driver: cursorDriver, - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-04-14T00:00:00.000Z", - version: "2026.04.09-f2b0fcd", - models: [ - { - slug: "claude-opus-4-6", - name: "Opus 4.6", - isCustom: false, - capabilities: createModelCapabilities({ - optionDescriptors: [ - selectDescriptor("reasoning", "Reasoning", [ - { id: "high", label: "High", isDefault: true }, - ]), - ], - }), - }, - ], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const refreshedProvider = { - ...initialProvider, - checkedAt: "2026-04-14T00:01:00.000Z", - models: [], - } satisfies ServerProvider; - const changes = yield* PubSub.unbounded(); - const instance = { - instanceId: cursorInstanceId, - driverKind: cursorDriver, + Layer.provideMerge(NodeServices.layer), + ), + ).pipe(Scope.provide(scope)); + + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }); + assert.strictEqual((yield* registry.getProviders)[0]?.workspaceSnapshots, undefined); + yield* Ref.set(returnPendingSnapshot, false); + const workspaceUpdate = yield* registry.streamChanges.pipe( + Stream.runHead, + Effect.forkChild, + ); + yield* Effect.yieldNow; + const firstRefresh = yield* registry + .refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }) + .pipe(Effect.forkChild); + yield* Deferred.await(probeStarted); + const duplicateRefresh = yield* registry + .refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }) + .pipe(Effect.forkChild); + yield* Effect.yieldNow; + assert.strictEqual(yield* Ref.get(snapshotCalls), 2); + yield* Deferred.succeed(releaseProbe, undefined); + yield* Fiber.join(firstRefresh); + yield* Fiber.join(duplicateRefresh); + const published = yield* Fiber.join(workspaceUpdate); + assert.strictEqual(published._tag, "Some"); + const providers = yield* registry.getProviders; + assert.deepStrictEqual(providers[0]?.skills, machineProvider.skills); + assert.deepStrictEqual( + providers[0]?.workspaceSnapshots?.[0]?.skills, + scopedProvider.skills, + ); + yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" }); + assert.strictEqual(yield* Ref.get(snapshotCalls), 2); + + yield* Ref.set(instancesRef, [rebuiltInstance]); + yield* PubSub.publish(registryChanges, undefined); + let rebuilt = yield* registry.getProviders; + for ( + let attempt = 0; + attempt < 50 && rebuilt[0]?.checkedAt !== rebuiltProvider.checkedAt; + attempt += 1 + ) { + yield* Effect.yieldNow; + rebuilt = yield* registry.getProviders; + } + assert.strictEqual(rebuilt[0]?.checkedAt, rebuiltProvider.checkedAt); + assert.strictEqual(rebuilt[0]?.workspaceSnapshots, undefined); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + it.effect("refreshes OpenCode catalogs and preserves other providers", () => + Effect.gen(function* () { + const codexDriver = ProviderDriverKind.make("codex"); + const openCodeDriver = ProviderDriverKind.make("opencode"); + const codexInstanceId = ProviderInstanceId.make("codex"); + const openCodeInstanceId = ProviderInstanceId.make("opencode"); + const codexRefreshCalls = yield* Ref.make(0); + const openCodeRefreshCalls = yield* Ref.make(0); + const codexProvider = { + instanceId: codexInstanceId, + driver: codexDriver, + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-06-10T00:00:00.000Z", + version: "1.0.0", + models: [], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const failedOpenCodeProvider = { + instanceId: openCodeInstanceId, + driver: openCodeDriver, + status: "error", + enabled: true, + installed: true, + auth: { status: "unknown" }, + checkedAt: "2026-06-10T00:00:00.000Z", + version: "1.0.0", + message: "Failed to refresh OpenCode models.", + models: [], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const recoveredOpenCodeProvider = { + ...failedOpenCodeProvider, + status: "ready", + auth: { status: "authenticated" }, + checkedAt: "2026-06-10T00:01:00.000Z", + message: "One upstream provider connected through OpenCode.", + models: [ + { + slug: "github/gpt-5", + name: "GPT-5", + subProvider: "GitHub", + isCustom: false, + capabilities: null, + }, + ], + } as const satisfies ServerProvider; + const changedCatalogProvider = { + ...recoveredOpenCodeProvider, + checkedAt: "2026-06-10T00:02:00.000Z", + models: [ + { + slug: "anthropic/claude-sonnet-4", + name: "Claude Sonnet 4", + subProvider: "Anthropic", + isCustom: false, + capabilities: null, + }, + ], + } as const satisfies ServerProvider; + const catalogSnapshot = yield* Ref.make(recoveredOpenCodeProvider); + const instances = [ + { + instanceId: codexInstanceId, + driverKind: codexDriver, continuationIdentity: { - driverKind: cursorDriver, - continuationKey: "cursor:instance:cursor", + driverKind: codexDriver, + continuationKey: "codex:instance:codex", }, displayName: undefined, enabled: true, @@ -1808,227 +1679,26 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te resolveMaintenance: () => Effect.succeed( makeManualOnlyProviderMaintenanceCapabilities({ - provider: cursorDriver, + provider: codexDriver, packageName: null, }), ), - getSnapshot: Effect.succeed(initialProvider), - refresh: Effect.succeed(refreshedProvider), - streamChanges: Stream.fromPubSub(changes), + getSnapshot: Effect.succeed(codexProvider), + refresh: Ref.update(codexRefreshCalls, (count) => count + 1).pipe( + Effect.as(codexProvider), + ), + streamChanges: Stream.empty, applyUsageLimits: () => Effect.void, }, adapter: {} as ProviderInstance["adapter"], textGeneration: {} as ProviderInstance["textGeneration"], - } satisfies ProviderInstance; - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, - { - getInstance: (instanceId) => - Effect.succeed(instanceId === cursorInstanceId ? instance : undefined), - listInstances: Effect.succeed([instance]), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.empty, - subscribeChanges: Effect.flatMap(PubSub.unbounded(), (pubsub) => - PubSub.subscribe(pubsub), - ), - }, - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const runtimeServices = yield* Layer.build( - ProviderRegistryLive.pipe( - Layer.provideMerge(instanceRegistryLayer), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-merged-persist-", - }), - ), - Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), - Layer.provideMerge(NodeServices.layer), - ), - ).pipe(Scope.provide(scope)); - - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - const config = yield* ServerConfig.ServerConfig; - const filePath = yield* resolveProviderStatusCachePath({ - cacheDir: config.providerStatusCacheDir, - instanceId: cursorInstanceId, - }); - - assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, [ - ...initialProvider.models, - ]); - const persisted = yield* awaitPersistedProvider(registry, refreshedProvider.checkedAt); - yield* PubSub.publish(changes, refreshedProvider); - yield* Fiber.join(persisted); - const cachedProvider = yield* readProviderStatusCache(filePath); - - assert.deepStrictEqual(cachedProvider, { - ...refreshedProvider, - models: [...initialProvider.models], - }); - }).pipe(Effect.provide(runtimeServices)); - }), - ); - - it.effect( - "persists authoritative OpenCode removals without resurrecting them on a failed live refresh", - () => - Effect.gen(function* () { - const openCodeDriver = ProviderDriverKind.make("opencode"); - const openCodeInstanceId = ProviderInstanceId.make("opencode"); - const initialProvider = { - instanceId: openCodeInstanceId, - driver: openCodeDriver, - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-07-17T00:00:00.000Z", - version: "1.0.0", - models: [ - { - slug: "github/gpt-5", - name: "GPT-5", - subProvider: "GitHub", - isCustom: false, - capabilities: null, - }, - { - slug: "removed-plugin/model", - name: "Removed Plugin Model", - subProvider: "Removed Plugin", - isCustom: false, - capabilities: null, - }, - ], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const authoritativeProvider = { - ...initialProvider, - checkedAt: "2026-07-17T00:01:00.000Z", - models: [initialProvider.models[0]!], - } satisfies ServerProvider; - const failedProvider = { - ...authoritativeProvider, - status: "error", - auth: { status: "unknown" }, - checkedAt: "2026-07-17T00:02:00.000Z", - models: [], - message: "Failed to refresh OpenCode models.", - } satisfies ServerProvider; - const changes = yield* PubSub.unbounded(); - const instance = { - instanceId: openCodeInstanceId, - driverKind: openCodeDriver, - continuationIdentity: { - driverKind: openCodeDriver, - continuationKey: "opencode:instance:opencode", - }, - displayName: undefined, - enabled: true, - snapshot: { - resolveMaintenance: () => - Effect.succeed( - makeManualOnlyProviderMaintenanceCapabilities({ - provider: openCodeDriver, - packageName: null, - }), - ), - getSnapshot: Effect.succeed(initialProvider), - refresh: Effect.succeed(authoritativeProvider), - streamChanges: Stream.fromPubSub(changes), - applyUsageLimits: () => Effect.void, - }, - adapter: {} as ProviderInstance["adapter"], - textGeneration: {} as ProviderInstance["textGeneration"], - } satisfies ProviderInstance; - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, - { - getInstance: (instanceId) => - Effect.succeed(instanceId === openCodeInstanceId ? instance : undefined), - listInstances: Effect.succeed([instance]), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.empty, - subscribeChanges: Effect.flatMap(PubSub.unbounded(), (pubsub) => - PubSub.subscribe(pubsub), - ), - }, - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const runtimeServices = yield* Layer.build( - ProviderRegistryLive.pipe( - Layer.provideMerge(instanceRegistryLayer), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-opencode-authoritative-persist-", - }), - ), - Layer.provideMerge(NodeServices.layer), - ), - ).pipe(Scope.provide(scope)); - - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - const config = yield* ServerConfig.ServerConfig; - const filePath = yield* resolveProviderStatusCachePath({ - cacheDir: config.providerStatusCacheDir, - instanceId: openCodeInstanceId, - }); - - const authoritativePersisted = yield* awaitPersistedProvider( - registry, - authoritativeProvider.checkedAt, - ); - yield* PubSub.publish(changes, authoritativeProvider); - yield* Fiber.join(authoritativePersisted); - let cachedProvider = yield* readProviderStatusCache(filePath); - - assert.deepStrictEqual(cachedProvider?.models, [authoritativeProvider.models[0]!]); - - const failedPersisted = yield* awaitPersistedProvider( - registry, - failedProvider.checkedAt, - ); - yield* PubSub.publish(changes, failedProvider); - yield* Fiber.join(failedPersisted); - cachedProvider = yield* readProviderStatusCache(filePath); - - assert.deepStrictEqual(cachedProvider?.models, [authoritativeProvider.models[0]!]); - assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, [ - authoritativeProvider.models[0]!, - ]); - }).pipe(Effect.provide(runtimeServices)); - }), - ); - - it.effect("returns the cached provider list when a manual refresh fails", () => - Effect.gen(function* () { - const codexDriver = ProviderDriverKind.make("codex"); - const codexInstanceId = ProviderInstanceId.make("codex"); - const cachedProvider = { - instanceId: codexInstanceId, - driver: codexDriver, - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-04-29T10:00:00.000Z", - version: "1.0.0", - models: [], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const instance = { - instanceId: codexInstanceId, - driverKind: codexDriver, + }, + { + instanceId: openCodeInstanceId, + driverKind: openCodeDriver, continuationIdentity: { - driverKind: codexDriver, - continuationKey: "codex:instance:codex", + driverKind: openCodeDriver, + continuationKey: "opencode:instance:opencode", }, displayName: undefined, enabled: true, @@ -2036,96 +1706,249 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te resolveMaintenance: () => Effect.succeed( makeManualOnlyProviderMaintenanceCapabilities({ - provider: codexDriver, + provider: openCodeDriver, packageName: null, }), ), - getSnapshot: Effect.succeed(cachedProvider), - refresh: Effect.die(new Error("simulated refresh failure")), + getSnapshot: Effect.succeed(failedOpenCodeProvider), + refresh: Ref.update(openCodeRefreshCalls, (count) => count + 1).pipe( + Effect.andThen(Ref.get(catalogSnapshot)), + ), streamChanges: Stream.empty, applyUsageLimits: () => Effect.void, }, adapter: {} as ProviderInstance["adapter"], textGeneration: {} as ProviderInstance["textGeneration"], - } satisfies ProviderInstance; - const instanceRegistryLayer = Layer.succeed( - ProviderInstanceRegistry.ProviderInstanceRegistry, + }, + ] satisfies ReadonlyArray; + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, + { + getInstance: (instanceId) => + Effect.succeed(instances.find((instance) => instance.instanceId === instanceId)), + listInstances: Effect.succeed(instances), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), + }, + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const runtimeServices = yield* Layer.build( + ProviderRegistryLive.pipe( + Layer.provideMerge(instanceRegistryLayer), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-reconnect-refresh-", + }), + ), + Layer.provideMerge(NodeServices.layer), + ), + ).pipe(Scope.provide(scope)); + + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const initialProviders = yield* registry.getProviders; + assert.strictEqual( + initialProviders.find((provider) => provider.instanceId === openCodeInstanceId)?.status, + "error", + ); + + const recoveredProviders = yield* registry.refresh(); + assert.deepStrictEqual( + recoveredProviders.find((provider) => provider.instanceId === openCodeInstanceId) + ?.models, + recoveredOpenCodeProvider.models, + ); + assert.deepStrictEqual( + recoveredProviders.find((provider) => provider.instanceId === codexInstanceId), + codexProvider, + ); + + yield* Ref.set(catalogSnapshot, changedCatalogProvider); + const changedProviders = yield* registry.refresh(); + assert.deepStrictEqual( + changedProviders.find((provider) => provider.instanceId === openCodeInstanceId)?.models, + changedCatalogProvider.models, + ); + assert.deepStrictEqual( + changedProviders.find((provider) => provider.instanceId === codexInstanceId), + codexProvider, + ); + }).pipe(Effect.provide(runtimeServices)); + + assert.strictEqual(yield* Ref.get(codexRefreshCalls), 2); + assert.strictEqual(yield* Ref.get(openCodeRefreshCalls), 2); + }), + ); + + it.effect("persists the merged snapshot when a live update has empty models", () => + Effect.gen(function* () { + const cursorDriver = ProviderDriverKind.make("cursor"); + const cursorInstanceId = ProviderInstanceId.make("cursor"); + const initialProvider = { + instanceId: cursorInstanceId, + driver: cursorDriver, + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-14T00:00:00.000Z", + version: "2026.04.09-f2b0fcd", + models: [ { - getInstance: (instanceId) => - Effect.succeed(instanceId === codexInstanceId ? instance : undefined), - listInstances: Effect.succeed([instance]), - listUnavailable: Effect.succeed([]), - streamChanges: Stream.empty, - subscribeChanges: Effect.flatMap(PubSub.unbounded(), (pubsub) => - PubSub.subscribe(pubsub), - ), + slug: "claude-opus-4-6", + name: "Opus 4.6", + isCustom: false, + capabilities: createModelCapabilities({ + optionDescriptors: [ + selectDescriptor("reasoning", "Reasoning", [ + { id: "high", label: "High", isDefault: true }, + ]), + ], + }), }, - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const runtimeServices = yield* Layer.build( - ProviderRegistryLive.pipe( - Layer.provideMerge(instanceRegistryLayer), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-refresh-failure-", + ], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const refreshedProvider = { + ...initialProvider, + checkedAt: "2026-04-14T00:01:00.000Z", + models: [], + } satisfies ServerProvider; + const changes = yield* PubSub.unbounded(); + const instance = { + instanceId: cursorInstanceId, + driverKind: cursorDriver, + continuationIdentity: { + driverKind: cursorDriver, + continuationKey: "cursor:instance:cursor", + }, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: cursorDriver, + packageName: null, }), ), - Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), - Layer.provideMerge(NodeServices.layer), + getSnapshot: Effect.succeed(initialProvider), + refresh: Effect.succeed(refreshedProvider), + streamChanges: Stream.fromPubSub(changes), + applyUsageLimits: () => Effect.void, + }, + adapter: {} as ProviderInstance["adapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + } satisfies ProviderInstance; + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, + { + getInstance: (instanceId) => + Effect.succeed(instanceId === cursorInstanceId ? instance : undefined), + listInstances: Effect.succeed([instance]), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), (pubsub) => + PubSub.subscribe(pubsub), ), - ).pipe(Scope.provide(scope)); + }, + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const runtimeServices = yield* Layer.build( + ProviderRegistryLive.pipe( + Layer.provideMerge(instanceRegistryLayer), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-merged-persist-", + }), + ), + Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), + Layer.provideMerge(NodeServices.layer), + ), + ).pipe(Scope.provide(scope)); - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const config = yield* ServerConfig.ServerConfig; + const filePath = yield* resolveProviderStatusCachePath({ + cacheDir: config.providerStatusCacheDir, + instanceId: cursorInstanceId, + }); - assert.deepStrictEqual(yield* registry.getProviders, [cachedProvider]); - assert.deepStrictEqual(yield* registry.refresh(codexDriver), [cachedProvider]); - assert.deepStrictEqual(yield* registry.refreshInstance(codexInstanceId), [ - cachedProvider, - ]); - }).pipe(Effect.provide(runtimeServices)); - }), - ); + assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, [ + ...initialProvider.models, + ]); + const persisted = yield* awaitPersistedProvider(registry, refreshedProvider.checkedAt); + yield* PubSub.publish(changes, refreshedProvider); + yield* Fiber.join(persisted); + const cachedProvider = yield* readProviderStatusCache(filePath); + + assert.deepStrictEqual(cachedProvider, { + ...refreshedProvider, + models: [...initialProvider.models], + }); + }).pipe(Effect.provide(runtimeServices)); + }), + ); - it.effect("keeps consuming registry changes after one sync fails", () => + it.effect( + "persists authoritative OpenCode removals without resurrecting them on a failed live refresh", + () => Effect.gen(function* () { - const codexDriver = ProviderDriverKind.make("codex"); - const codexInstanceId = ProviderInstanceId.make("codex"); - const claudeDriver = ProviderDriverKind.make("claudeAgent"); - const claudeInstanceId = ProviderInstanceId.make("claudeAgent"); - const codexProvider = { - instanceId: codexInstanceId, - driver: codexDriver, + const openCodeDriver = ProviderDriverKind.make("opencode"); + const openCodeInstanceId = ProviderInstanceId.make("opencode"); + const initialProvider = { + instanceId: openCodeInstanceId, + driver: openCodeDriver, status: "ready", enabled: true, installed: true, auth: { status: "authenticated" }, - checkedAt: "2026-04-29T10:00:00.000Z", + checkedAt: "2026-07-17T00:00:00.000Z", version: "1.0.0", - models: [], + models: [ + { + slug: "github/gpt-5", + name: "GPT-5", + subProvider: "GitHub", + isCustom: false, + capabilities: null, + }, + { + slug: "removed-plugin/model", + name: "Removed Plugin Model", + subProvider: "Removed Plugin", + isCustom: false, + capabilities: null, + }, + ], slashCommands: [], skills: [], } as const satisfies ServerProvider; - const claudeProvider = { - instanceId: claudeInstanceId, - driver: claudeDriver, - status: "ready", - enabled: true, - installed: true, - auth: { status: "authenticated" }, - checkedAt: "2026-04-29T10:01:00.000Z", - version: "1.0.0", + const authoritativeProvider = { + ...initialProvider, + checkedAt: "2026-07-17T00:01:00.000Z", + models: [initialProvider.models[0]!], + } satisfies ServerProvider; + const failedProvider = { + ...authoritativeProvider, + status: "error", + auth: { status: "unknown" }, + checkedAt: "2026-07-17T00:02:00.000Z", models: [], - slashCommands: [], - skills: [], - } as const satisfies ServerProvider; - const makeInstance = (provider: ServerProvider): ProviderInstance => ({ - instanceId: provider.instanceId, - driverKind: provider.driver, + message: "Failed to refresh OpenCode models.", + } satisfies ServerProvider; + const changes = yield* PubSub.unbounded(); + const instance = { + instanceId: openCodeInstanceId, + driverKind: openCodeDriver, continuationIdentity: { - driverKind: provider.driver, - continuationKey: `${provider.driver}:instance:${provider.instanceId}`, + driverKind: openCodeDriver, + continuationKey: "opencode:instance:opencode", }, displayName: undefined, enabled: true, @@ -2133,44 +1956,29 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te resolveMaintenance: () => Effect.succeed( makeManualOnlyProviderMaintenanceCapabilities({ - provider: provider.driver, + provider: openCodeDriver, packageName: null, }), ), - getSnapshot: Effect.succeed(provider), - refresh: Effect.succeed(provider), - streamChanges: Stream.empty, + getSnapshot: Effect.succeed(initialProvider), + refresh: Effect.succeed(authoritativeProvider), + streamChanges: Stream.fromPubSub(changes), applyUsageLimits: () => Effect.void, }, adapter: {} as ProviderInstance["adapter"], textGeneration: {} as ProviderInstance["textGeneration"], - }); - const codexInstance = makeInstance(codexProvider); - const claudeInstance = makeInstance(claudeProvider); - const changes = yield* PubSub.unbounded(); - const instancesRef = yield* Ref.make>([codexInstance]); - const failNextList = yield* Ref.make(false); - const wait = () => Effect.yieldNow; + } satisfies ProviderInstance; const instanceRegistryLayer = Layer.succeed( ProviderInstanceRegistry.ProviderInstanceRegistry, { getInstance: (instanceId) => - Ref.get(instancesRef).pipe( - Effect.map((instances) => - instances.find((instance) => instance.instanceId === instanceId), - ), - ), - listInstances: Effect.gen(function* () { - const shouldFail = yield* Ref.get(failNextList); - if (shouldFail) { - yield* Ref.set(failNextList, false); - return yield* Effect.die(new Error("simulated registry list failure")); - } - return yield* Ref.get(instancesRef); - }), + Effect.succeed(instanceId === openCodeInstanceId ? instance : undefined), + listInstances: Effect.succeed([instance]), listUnavailable: Effect.succeed([]), - streamChanges: Stream.fromPubSub(changes), - subscribeChanges: PubSub.subscribe(changes), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), (pubsub) => + PubSub.subscribe(pubsub), + ), }, ); const scope = yield* Scope.make(); @@ -2180,311 +1988,587 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te Layer.provideMerge(instanceRegistryLayer), Layer.provideMerge( ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-sync-failure-", + prefix: "t3-provider-registry-opencode-authoritative-persist-", }), ), - Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), Layer.provideMerge(NodeServices.layer), ), ).pipe(Scope.provide(scope)); yield* Effect.gen(function* () { const registry = yield* ProviderRegistry.ProviderRegistry; - assert.deepStrictEqual(yield* registry.getProviders, [codexProvider]); - - yield* Ref.set(failNextList, true); - yield* PubSub.publish(changes, undefined); - - yield* Ref.set(instancesRef, [codexInstance, claudeInstance]); - yield* PubSub.publish(changes, undefined); - - let providers = yield* registry.getProviders; - for ( - let attempt = 0; - attempt < 50 && - !providers.some((provider) => provider.instanceId === claudeInstanceId); - attempt += 1 - ) { - yield* wait(); - providers = yield* registry.getProviders; - } - - assert.deepStrictEqual( - providers.map((provider) => provider.instanceId).toSorted(), - [codexInstanceId, claudeInstanceId].toSorted(), + const config = yield* ServerConfig.ServerConfig; + const filePath = yield* resolveProviderStatusCachePath({ + cacheDir: config.providerStatusCacheDir, + instanceId: openCodeInstanceId, + }); + + const authoritativePersisted = yield* awaitPersistedProvider( + registry, + authoritativeProvider.checkedAt, + ); + yield* PubSub.publish(changes, authoritativeProvider); + yield* Fiber.join(authoritativePersisted); + let cachedProvider = yield* readProviderStatusCache(filePath); + + assert.deepStrictEqual(cachedProvider?.models, [authoritativeProvider.models[0]!]); + + const failedPersisted = yield* awaitPersistedProvider( + registry, + failedProvider.checkedAt, ); + yield* PubSub.publish(changes, failedProvider); + yield* Fiber.join(failedPersisted); + cachedProvider = yield* readProviderStatusCache(filePath); + + assert.deepStrictEqual(cachedProvider?.models, [authoritativeProvider.models[0]!]); + assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, [ + authoritativeProvider.models[0]!, + ]); }).pipe(Effect.provide(runtimeServices)); }), - ); + ); - // This test intentionally avoids `mockCommandSpawnerLayer` so the real - // `probeCodexAppServerProvider` path runs — including the full - // `codex app-server` RPC handshake via `CodexClient.layerChildProcess`. - // We point `binaryPath` at a name that cannot exist on any machine so - // the real `ChildProcessSpawner` deterministically returns ENOENT; the - // probe wraps that as `CodexAppServerSpawnError` and - // `checkCodexProviderStatus` turns it into the user-visible "not - // installed" error snapshot. If the aggregator's `syncLiveSources` - // breaks — the `codex_personal`-never-probes bug we are guarding - // against — that snapshot never lands in `getProviders` and the - // assertions below fail. - it.effect("propagates real Codex probe failures to the aggregator at boot", () => - Effect.gen(function* () { - const missingBinary = `t3code_codex_missing_`; - const serverSettings = yield* makeMutableServerSettingsService( - decodeServerSettings( - deepMerge(encodedDefaultServerSettings, { - providers: { - // Disable every built-in probe that would otherwise spawn - // on the CI host. `enabled: false` short-circuits each - // driver's probe *before* it touches the spawner, so the - // test environment stays isolated from the dev - // machine's PATH. - codex: { enabled: false }, - claudeAgent: { enabled: false }, - cursor: { enabled: false }, - grok: { enabled: false }, - opencode: { enabled: false }, - }, - // `providerInstances` keys are branded `ProviderInstanceId`; - // the branded index signature rejects plain string literals - // at the TS level even though the runtime schema happily - // accepts + decodes them. Cast the patch to `unknown` so - // the `Schema.decodeSync` below does the real validation. - providerInstances: { - // Matches the shape the user had in `.t3/dev/settings.json` - // when the bug was reported: a custom enabled Codex instance - // pointing at a binary the server has to actually spawn. - codex_personal: { - driver: "codex", - displayName: "Codex Personal", - enabled: true, - config: { - binaryPath: missingBinary, - homePath: `/tmp/${missingBinary}_home`, - }, - }, - } as unknown as ContractServerSettings["providerInstances"], - }), - ), - ); - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const providerRegistryLayer = ProviderRegistryLive.pipe( - Layer.provideMerge(ProviderInstanceRegistryHydrationLive), - Layer.provideMerge(AntigravityInstallation.layer), - Layer.provideMerge( - Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), + it.effect("returns the cached provider list when a manual refresh fails", () => + Effect.gen(function* () { + const codexDriver = ProviderDriverKind.make("codex"); + const codexInstanceId = ProviderInstanceId.make("codex"); + const cachedProvider = { + instanceId: codexInstanceId, + driver: codexDriver, + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-29T10:00:00.000Z", + version: "1.0.0", + models: [], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const instance = { + instanceId: codexInstanceId, + driverKind: codexDriver, + continuationIdentity: { + driverKind: codexDriver, + continuationKey: "codex:instance:codex", + }, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: codexDriver, + packageName: null, + }), + ), + getSnapshot: Effect.succeed(cachedProvider), + refresh: Effect.die(new Error("simulated refresh failure")), + streamChanges: Stream.empty, + applyUsageLimits: () => Effect.void, + }, + adapter: {} as ProviderInstance["adapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + } satisfies ProviderInstance; + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, + { + getInstance: (instanceId) => + Effect.succeed(instanceId === codexInstanceId ? instance : undefined), + listInstances: Effect.succeed([instance]), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), (pubsub) => + PubSub.subscribe(pubsub), ), + }, + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const runtimeServices = yield* Layer.build( + ProviderRegistryLive.pipe( + Layer.provideMerge(instanceRegistryLayer), Layer.provideMerge( ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-", + prefix: "t3-provider-registry-refresh-failure-", }), ), - Layer.provideMerge(TestHttpClientLive), - Layer.provideMerge( - Layer.succeed( - ProviderEventLoggers.ProviderEventLoggers, - ProviderEventLoggers.NoOpProviderEventLoggers, - ), - ), - Layer.provideMerge(ModelManifest.layerTest), - Layer.provideMerge(CodexResetCredit.layerTest), - Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), - // NO spawner mock — `ChildProcessSpawner` is supplied by the - // outer `NodeServices.layer` on `it.layer(...)` and will - // genuinely spawn a subprocess. The missing-binary ENOENT is - // what exercises the same failure mode as a misconfigured - // production `binaryPath`. - ); - const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe( - Scope.provide(scope), - ); + Layer.provideMerge(NodeServices.layer), + ), + ).pipe(Scope.provide(scope)); - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - let providers = yield* registry.getProviders; - for ( - let attempts = 0; - attempts < 50 && - providers.find((provider) => provider.instanceId === "codex_personal")?.status !== - "error"; - attempts += 1 - ) { - yield* Effect.yieldNow; - providers = yield* registry.getProviders; - } - const codexPersonal = providers.find( - (provider) => provider.instanceId === "codex_personal", - ); - assert.notStrictEqual( - codexPersonal, - undefined, - `Expected the aggregator to know about codex_personal; instead saw: ${providers - .map((provider) => provider.instanceId) - .join(", ")}`, - ); - assert.strictEqual( - codexPersonal?.status, - "error", - "Real Codex probe against a missing binary should surface as 'error' in the aggregator", - ); - assert.strictEqual(codexPersonal?.installed, false); - assert.strictEqual( - codexPersonal?.message, - "Codex CLI (`codex`) was not found on PATH.", - ); - }).pipe(Effect.provide(runtimeServices)); - }), - ); + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; - // A binary path change must rebuild Codex and publish its new probe result. - it.effect("re-probes when settings change the codex binaryPath", () => - Effect.gen(function* () { - const firstMissing = `t3code_codex_first_`; - const secondMissing = `t3code_codex_second_`; - const spawnedCommands: Array = []; - const secondProbeStarted = yield* Deferred.make(); - const releaseSecondProbe = yield* Deferred.make(); - const allowLazySettingsStream = yield* Deferred.make(); - const mutableServerSettings = yield* makeMutableServerSettingsService( - decodeServerSettings( - deepMerge(encodedDefaultServerSettings, { - providers: { - codex: { enabled: true, binaryPath: firstMissing }, - claudeAgent: { enabled: false }, - cursor: { enabled: false }, - grok: { enabled: false }, - opencode: { enabled: false }, - }, + assert.deepStrictEqual(yield* registry.getProviders, [cachedProvider]); + assert.deepStrictEqual(yield* registry.refresh(codexDriver), [cachedProvider]); + assert.deepStrictEqual(yield* registry.refreshInstance(codexInstanceId), [ + cachedProvider, + ]); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + it.effect("keeps consuming registry changes after one sync fails", () => + Effect.gen(function* () { + const codexDriver = ProviderDriverKind.make("codex"); + const codexInstanceId = ProviderInstanceId.make("codex"); + const claudeDriver = ProviderDriverKind.make("claudeAgent"); + const claudeInstanceId = ProviderInstanceId.make("claudeAgent"); + const codexProvider = { + instanceId: codexInstanceId, + driver: codexDriver, + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-29T10:00:00.000Z", + version: "1.0.0", + models: [], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const claudeProvider = { + instanceId: claudeInstanceId, + driver: claudeDriver, + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-04-29T10:01:00.000Z", + version: "1.0.0", + models: [], + slashCommands: [], + skills: [], + } as const satisfies ServerProvider; + const makeInstance = (provider: ServerProvider): ProviderInstance => ({ + instanceId: provider.instanceId, + driverKind: provider.driver, + continuationIdentity: { + driverKind: provider.driver, + continuationKey: `${provider.driver}:instance:${provider.instanceId}`, + }, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: provider.driver, + packageName: null, + }), + ), + getSnapshot: Effect.succeed(provider), + refresh: Effect.succeed(provider), + streamChanges: Stream.empty, + applyUsageLimits: () => Effect.void, + }, + adapter: {} as ProviderInstance["adapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + }); + const codexInstance = makeInstance(codexProvider); + const claudeInstance = makeInstance(claudeProvider); + const changes = yield* PubSub.unbounded(); + const instancesRef = yield* Ref.make>([codexInstance]); + const failNextList = yield* Ref.make(false); + const wait = () => Effect.yieldNow; + const instanceRegistryLayer = Layer.succeed( + ProviderInstanceRegistry.ProviderInstanceRegistry, + { + getInstance: (instanceId) => + Ref.get(instancesRef).pipe( + Effect.map((instances) => + instances.find((instance) => instance.instanceId === instanceId), + ), + ), + listInstances: Effect.gen(function* () { + const shouldFail = yield* Ref.get(failNextList); + if (shouldFail) { + yield* Ref.set(failNextList, false); + return yield* Effect.die(new Error("simulated registry list failure")); + } + return yield* Ref.get(instancesRef); + }), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.fromPubSub(changes), + subscribeChanges: PubSub.subscribe(changes), + }, + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const runtimeServices = yield* Layer.build( + ProviderRegistryLive.pipe( + Layer.provideMerge(instanceRegistryLayer), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-sync-failure-", }), ), + Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), + Layer.provideMerge(NodeServices.layer), + ), + ).pipe(Scope.provide(scope)); + + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + assert.deepStrictEqual(yield* registry.getProviders, [codexProvider]); + + yield* Ref.set(failNextList, true); + yield* PubSub.publish(changes, undefined); + + yield* Ref.set(instancesRef, [codexInstance, claudeInstance]); + yield* PubSub.publish(changes, undefined); + + let providers = yield* registry.getProviders; + for ( + let attempt = 0; + attempt < 50 && !providers.some((provider) => provider.instanceId === claudeInstanceId); + attempt += 1 + ) { + yield* wait(); + providers = yield* registry.getProviders; + } + + assert.deepStrictEqual( + providers.map((provider) => provider.instanceId).toSorted(), + [codexInstanceId, claudeInstanceId].toSorted(), ); - const serverSettings = { - ...mutableServerSettings, - streamChanges: Stream.unwrap( - Deferred.await(allowLazySettingsStream).pipe( - Effect.as(mutableServerSettings.streamChanges), - ), + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + // This test intentionally avoids `mockCommandSpawnerLayer` so the real + // `probeCodexAppServerProvider` path runs — including the full + // `codex app-server` RPC handshake via `CodexClient.layerChildProcess`. + // We point `binaryPath` at a name that cannot exist on any machine so + // the real `ChildProcessSpawner` deterministically returns ENOENT; the + // probe wraps that as `CodexAppServerSpawnError` and + // `checkCodexProviderStatus` turns it into the user-visible "not + // installed" error snapshot. If the aggregator's `syncLiveSources` + // breaks — the `codex_personal`-never-probes bug we are guarding + // against — that snapshot never lands in `getProviders` and the + // assertions below fail. + it.effect("propagates real Codex probe failures to the aggregator at boot", () => + Effect.gen(function* () { + const missingBinary = `t3code_codex_missing_`; + const serverSettings = yield* makeMutableServerSettingsService( + decodeServerSettings( + deepMerge(encodedDefaultServerSettings, { + providers: { + // Disable every built-in probe that would otherwise spawn + // on the CI host. `enabled: false` short-circuits each + // driver's probe *before* it touches the spawner, so the + // test environment stays isolated from the dev + // machine's PATH. + codex: { enabled: false }, + claudeAgent: { enabled: false }, + cursor: { enabled: false }, + grok: { enabled: false }, + kimi: { enabled: false }, + opencode: { enabled: false }, + }, + // `providerInstances` keys are branded `ProviderInstanceId`; + // the branded index signature rejects plain string literals + // at the TS level even though the runtime schema happily + // accepts + decodes them. Cast the patch to `unknown` so + // the `Schema.decodeSync` below does the real validation. + providerInstances: { + // Matches the shape the user had in `.t3/dev/settings.json` + // when the bug was reported: a custom enabled Codex instance + // pointing at a binary the server has to actually spawn. + codex_personal: { + driver: "codex", + displayName: "Codex Personal", + enabled: true, + config: { + binaryPath: missingBinary, + homePath: `/tmp/${missingBinary}_home`, + }, + }, + } as unknown as ContractServerSettings["providerInstances"], + }), + ), + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const providerRegistryLayer = ProviderRegistryLive.pipe( + Layer.provideMerge(ProviderInstanceRegistryHydrationLive), + Layer.provideMerge(AntigravityInstallation.layer), + Layer.provideMerge( + Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), + ), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-", + }), + ), + Layer.provideMerge(TestHttpClientLive), + Layer.provideMerge( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, ), - } satisfies ServerSettingsModule.ServerSettingsService["Service"]; - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const providerRegistryLayer = ProviderRegistryLive.pipe( - Layer.provideMerge(ProviderInstanceRegistryHydrationLive), - Layer.provideMerge(AntigravityInstallation.layer), - Layer.provideMerge( - Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), + ), + Layer.provideMerge(ModelManifest.layerTest), + Layer.provideMerge(CodexResetCredit.layerTest), + Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), + Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), + // NO spawner mock — `ChildProcessSpawner` is supplied by the + // outer `NodeServices.layer` on `it.layer(...)` and will + // genuinely spawn a subprocess. The missing-binary ENOENT is + // what exercises the same failure mode as a misconfigured + // production `binaryPath`. + ); + const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe( + Scope.provide(scope), + ); + + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + let providers = yield* registry.getProviders; + for ( + let attempts = 0; + attempts < 50 && + providers.find((provider) => provider.instanceId === "codex_personal")?.status !== + "error"; + attempts += 1 + ) { + yield* Effect.yieldNow; + providers = yield* registry.getProviders; + } + const codexPersonal = providers.find( + (provider) => provider.instanceId === "codex_personal", + ); + assert.notStrictEqual( + codexPersonal, + undefined, + `Expected the aggregator to know about codex_personal; instead saw: ${providers + .map((provider) => provider.instanceId) + .join(", ")}`, + ); + assert.strictEqual( + codexPersonal?.status, + "error", + "Real Codex probe against a missing binary should surface as 'error' in the aggregator", + ); + assert.strictEqual(codexPersonal?.installed, false); + assert.strictEqual(codexPersonal?.message, "Codex CLI (`codex`) was not found on PATH."); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + // A binary path change must rebuild Codex and publish its new probe result. + it.effect("re-probes when settings change the codex binaryPath", () => + Effect.gen(function* () { + const firstMissing = `t3code_codex_first_`; + const secondMissing = `t3code_codex_second_`; + const spawnedCommands: Array = []; + const secondProbeStarted = yield* Deferred.make(); + const releaseSecondProbe = yield* Deferred.make(); + const allowLazySettingsStream = yield* Deferred.make(); + const mutableServerSettings = yield* makeMutableServerSettingsService( + decodeServerSettings( + deepMerge(encodedDefaultServerSettings, { + providers: { + codex: { enabled: true, binaryPath: firstMissing }, + claudeAgent: { enabled: false }, + cursor: { enabled: false }, + grok: { enabled: false }, + kimi: { enabled: false }, + opencode: { enabled: false }, + }, + }), + ), + ); + const serverSettings = { + ...mutableServerSettings, + streamChanges: Stream.unwrap( + Deferred.await(allowLazySettingsStream).pipe( + Effect.as(mutableServerSettings.streamChanges), ), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-", - }), + ), + } satisfies ServerSettingsModule.ServerSettingsService["Service"]; + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const providerRegistryLayer = ProviderRegistryLive.pipe( + Layer.provideMerge(ProviderInstanceRegistryHydrationLive), + Layer.provideMerge(AntigravityInstallation.layer), + Layer.provideMerge( + Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), + ), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-", + }), + ), + Layer.provideMerge(TestHttpClientLive), + Layer.provideMerge( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, ), - Layer.provideMerge(TestHttpClientLive), - Layer.provideMerge( - Layer.succeed( - ProviderEventLoggers.ProviderEventLoggers, - ProviderEventLoggers.NoOpProviderEventLoggers, - ), + ), + Layer.provideMerge(ModelManifest.layerTest), + Layer.provideMerge(CodexResetCredit.layerTest), + Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), + Layer.updateService(ChildProcessSpawner.ChildProcessSpawner, (spawner) => + ChildProcessSpawner.make((command) => { + if (command._tag !== "StandardCommand") return spawner.spawn(command); + spawnedCommands.push(command.command); + const beforeSpawn = + command.command === secondMissing + ? Deferred.succeed(secondProbeStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseSecondProbe)), + ) + : Effect.void; + return beforeSpawn.pipe(Effect.andThen(spawner.spawn(command))); + }), + ), + Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), + ); + const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe( + Scope.provide(scope), + ); + + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const codexSnapshots = registry.streamChanges.pipe( + Stream.map((providers) => + providers.find((provider) => provider.instanceId === "codex"), ), - Layer.provideMerge(ModelManifest.layerTest), - Layer.provideMerge(CodexResetCredit.layerTest), - Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), - Layer.updateService(ChildProcessSpawner.ChildProcessSpawner, (spawner) => - ChildProcessSpawner.make((command) => { - if (command._tag !== "StandardCommand") return spawner.spawn(command); - spawnedCommands.push(command.command); - const beforeSpawn = - command.command === secondMissing - ? Deferred.succeed(secondProbeStarted, undefined).pipe( - Effect.andThen(Deferred.await(releaseSecondProbe)), - ) - : Effect.void; - return beforeSpawn.pipe(Effect.andThen(spawner.spawn(command))); - }), + Stream.filter((provider): provider is ServerProvider => provider !== undefined), + ); + const firstError = yield* Stream.toPull( + codexSnapshots.pipe(Stream.filter((provider) => provider.status === "error")), + ); + const currentCodex = (yield* registry.getProviders).find( + (provider) => provider.instanceId === "codex", + ); + const initialCodex = + currentCodex?.status === "error" ? currentCodex : (yield* firstError)[0]; + assert.strictEqual(initialCodex?.status, "error"); + assert.strictEqual(initialCodex?.installed, false); + assert.deepStrictEqual(spawnedCommands, [firstMissing]); + + const pendingRebuild = yield* Stream.toPull( + codexSnapshots.pipe( + Stream.filter((provider) => provider.status === "warning" && !provider.installed), ), - Layer.provideMerge(NodeServices.layer), - Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), ); - const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe( - Scope.provide(scope), + yield* serverSettings.updateSettings({ + providers: { + codex: { enabled: true, binaryPath: secondMissing }, + }, + }); + // Start the lazy stream only after publishing. A watcher that did + // not subscribe before forking has already lost this update. + yield* Deferred.succeed(allowLazySettingsStream, undefined); + + // Hold the second probe until the aggregator sees the rebuilt + // instance. Its next error must come from the new executable. + yield* Deferred.await(secondProbeStarted); + yield* pendingRebuild; + const rebuiltError = yield* Stream.toPull( + codexSnapshots.pipe(Stream.filter((provider) => provider.status === "error")), ); + yield* Deferred.succeed(releaseSecondProbe, undefined); + const [reprobedCodex] = yield* rebuiltError; + assert.deepStrictEqual(spawnedCommands, [firstMissing, secondMissing]); + assert.strictEqual(reprobedCodex?.status, "error"); + assert.strictEqual(reprobedCodex?.installed, false); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + it.effect("includes unavailable instance snapshots in getProviders", () => + Effect.gen(function* () { + const serverSettings = yield* makeMutableServerSettingsService( + decodeServerSettings( + deepMerge(encodedDefaultServerSettings, { + providers: { + codex: { enabled: false }, + claudeAgent: { enabled: false }, + cursor: { enabled: false }, + grok: { enabled: false }, + kimi: { enabled: false }, + opencode: { enabled: false }, + }, + providerInstances: { + ghost_main: { + driver: "ghostDriver", + displayName: "A fork-only driver we don't ship", + enabled: false, + config: { arbitrary: "payload" }, + }, + } as unknown as ContractServerSettings["providerInstances"], + }), + ), + ); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + const providerRegistryLayer = ProviderRegistryLive.pipe( + Layer.provideMerge(ProviderInstanceRegistryHydrationLive), + Layer.provideMerge(AntigravityInstallation.layer), + Layer.provideMerge( + Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), + ), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { + prefix: "t3-provider-registry-", + }), + ), + Layer.provideMerge(TestHttpClientLive), + Layer.provideMerge( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, + ), + ), + Layer.provideMerge(ModelManifest.layerTest), + Layer.provideMerge(CodexResetCredit.layerTest), + Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), + Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), + ); + const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe( + Scope.provide(scope), + ); - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - const codexSnapshots = registry.streamChanges.pipe( - Stream.map((providers) => - providers.find((provider) => provider.instanceId === "codex"), - ), - Stream.filter((provider): provider is ServerProvider => provider !== undefined), - ); - const firstError = yield* Stream.toPull( - codexSnapshots.pipe(Stream.filter((provider) => provider.status === "error")), - ); - const currentCodex = (yield* registry.getProviders).find( - (provider) => provider.instanceId === "codex", - ); - const initialCodex = - currentCodex?.status === "error" ? currentCodex : (yield* firstError)[0]; - assert.strictEqual(initialCodex?.status, "error"); - assert.strictEqual(initialCodex?.installed, false); - assert.deepStrictEqual(spawnedCommands, [firstMissing]); - - const pendingRebuild = yield* Stream.toPull( - codexSnapshots.pipe( - Stream.filter((provider) => provider.status === "warning" && !provider.installed), - ), - ); - yield* serverSettings.updateSettings({ - providers: { - codex: { enabled: true, binaryPath: secondMissing }, - }, - }); - // Start the lazy stream only after publishing. A watcher that did - // not subscribe before forking has already lost this update. - yield* Deferred.succeed(allowLazySettingsStream, undefined); - - // Hold the second probe until the aggregator sees the rebuilt - // instance. Its next error must come from the new executable. - yield* Deferred.await(secondProbeStarted); - yield* pendingRebuild; - const rebuiltError = yield* Stream.toPull( - codexSnapshots.pipe(Stream.filter((provider) => provider.status === "error")), - ); - yield* Deferred.succeed(releaseSecondProbe, undefined); - const [reprobedCodex] = yield* rebuiltError; - assert.deepStrictEqual(spawnedCommands, [firstMissing, secondMissing]); - assert.strictEqual(reprobedCodex?.status, "error"); - assert.strictEqual(reprobedCodex?.installed, false); - }).pipe(Effect.provide(runtimeServices)); - }), - ); + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const providers = yield* registry.getProviders; + const ghost = providers.find((provider) => provider.instanceId === "ghost_main"); - it.effect("includes unavailable instance snapshots in getProviders", () => + assert.notStrictEqual(ghost, undefined); + assert.strictEqual(ghost?.driver, "ghostDriver"); + assert.strictEqual(ghost?.availability, "unavailable"); + assert.match(ghost?.unavailableReason ?? "", /ghostDriver/); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + it.effect( + "keeps Cursor disabled and skips provider probing when settings use their defaults", + () => Effect.gen(function* () { const serverSettings = yield* makeMutableServerSettingsService( decodeServerSettings( deepMerge(encodedDefaultServerSettings, { providers: { - codex: { enabled: false }, - claudeAgent: { enabled: false }, - cursor: { enabled: false }, - grok: { enabled: false }, - opencode: { enabled: false }, - }, - providerInstances: { - ghost_main: { - driver: "ghostDriver", - displayName: "A fork-only driver we don't ship", + codex: { + enabled: false, + }, + grok: { enabled: false, - config: { arbitrary: "payload" }, }, - } as unknown as ContractServerSettings["providerInstances"], + }, }), ), ); + let cursorSpawned = false; const scope = yield* Scope.make(); yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); const providerRegistryLayer = ProviderRegistryLive.pipe( @@ -2507,502 +2591,437 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te ), Layer.provideMerge(ModelManifest.layerTest), Layer.provideMerge(CodexResetCredit.layerTest), + Layer.provideMerge(CodexResetCredit.layerTest), Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), - Layer.provideMerge(NodeServices.layer), Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), + Layer.provideMerge( + mockCommandSpawnerLayer((command, args) => { + if (command === "cursor-agent") { + cursorSpawned = true; + } + const joined = args.join(" "); + if (joined === "--version") { + return { + stdout: `${command} 1.0.0\n`, + stderr: "", + code: 0, + }; + } + if (joined === "auth status") { + return { + stdout: '{"authenticated":true}\n', + stderr: "", + code: 0, + }; + } + throw new Error(`Unexpected args: ${command} ${joined}`); + }), + ), ); - const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe( - Scope.provide(scope), - ); + const runtimeServices = yield* Layer.build( + Layer.mergeAll( + Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), + providerRegistryLayer, + ), + ).pipe(Scope.provide(scope)); yield* Effect.gen(function* () { const registry = yield* ProviderRegistry.ProviderRegistry; const providers = yield* registry.getProviders; - const ghost = providers.find((provider) => provider.instanceId === "ghost_main"); + const cursorProvider = providers.find( + (provider) => provider.instanceId === ProviderInstanceId.make("cursor"), + ); - assert.notStrictEqual(ghost, undefined); - assert.strictEqual(ghost?.driver, "ghostDriver"); - assert.strictEqual(ghost?.availability, "unavailable"); - assert.match(ghost?.unavailableReason ?? "", /ghostDriver/); + assert.deepStrictEqual(providers.map((provider) => provider.instanceId).toSorted(), [ + "antigravity", + "claudeAgent", + "codex", + "cursor", + "grok", + "kimi", + "opencode", + ]); + assert.strictEqual(cursorProvider?.enabled, false); + assert.strictEqual(cursorProvider?.status, "disabled"); + assert.strictEqual(cursorProvider?.message, "Cursor is disabled in T3 Code settings."); + assert.strictEqual(cursorSpawned, false); }).pipe(Effect.provide(runtimeServices)); }), - ); + ); - it.effect( - "keeps Cursor disabled and skips provider probing when settings use their defaults", - () => - Effect.gen(function* () { - const serverSettings = yield* makeMutableServerSettingsService( - decodeServerSettings( - deepMerge(encodedDefaultServerSettings, { - providers: { - codex: { - enabled: false, - }, - grok: { - enabled: false, - }, - }, - }), - ), - ); - let cursorSpawned = false; - const scope = yield* Scope.make(); - yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); - const providerRegistryLayer = ProviderRegistryLive.pipe( - Layer.provideMerge(ProviderInstanceRegistryHydrationLive), - Layer.provideMerge(AntigravityInstallation.layer), - Layer.provideMerge( - Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), - ), - Layer.provideMerge( - ServerConfig.layerTest(process.cwd(), { - prefix: "t3-provider-registry-", - }), - ), - Layer.provideMerge(TestHttpClientLive), - Layer.provideMerge( - Layer.succeed( - ProviderEventLoggers.ProviderEventLoggers, - ProviderEventLoggers.NoOpProviderEventLoggers, - ), - ), - Layer.provideMerge(ModelManifest.layerTest), - Layer.provideMerge(CodexResetCredit.layerTest), - Layer.provideMerge(CodexResetCredit.layerTest), - Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive), - Layer.provideMerge(BackgroundPolicyAlwaysRunLayer), - Layer.provideMerge( - mockCommandSpawnerLayer((command, args) => { - if (command === "cursor-agent") { - cursorSpawned = true; - } - const joined = args.join(" "); - if (joined === "--version") { - return { - stdout: `${command} 1.0.0\n`, - stderr: "", - code: 0, - }; - } - if (joined === "auth status") { - return { - stdout: '{"authenticated":true}\n', - stderr: "", - code: 0, - }; - } - throw new Error(`Unexpected args: ${command} ${joined}`); - }), - ), - ); - const runtimeServices = yield* Layer.build( - Layer.mergeAll( - Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings), - providerRegistryLayer, - ), - ).pipe(Scope.provide(scope)); + it.effect("skips codex probes entirely when the provider is disabled", () => + Effect.gen(function* () { + const status = yield* checkCodexProviderStatus(disabledCodexSettings).pipe( + Effect.provide(failingSpawnerLayer("spawn codex ENOENT")), + ); + assert.strictEqual(status.enabled, false); + assert.strictEqual(status.status, "disabled"); + assert.strictEqual(status.installed, false); + assert.strictEqual(status.message, "Codex is disabled in T3 Code settings."); + }), + ); + }); - yield* Effect.gen(function* () { - const registry = yield* ProviderRegistry.ProviderRegistry; - const providers = yield* registry.getProviders; - const cursorProvider = providers.find( - (provider) => provider.instanceId === ProviderInstanceId.make("cursor"), - ); + // ── checkClaudeProviderStatus tests ────────────────────────── - assert.deepStrictEqual(providers.map((provider) => provider.instanceId).toSorted(), [ - "antigravity", - "claudeAgent", - "codex", - "cursor", - "grok", - "opencode", - ]); - assert.strictEqual(cursorProvider?.enabled, false); - assert.strictEqual(cursorProvider?.status, "disabled"); - assert.strictEqual( - cursorProvider?.message, - "Cursor is disabled in T3 Code settings.", - ); - assert.strictEqual(cursorSpawned, false); - }).pipe(Effect.provide(runtimeServices)); + describe("checkClaudeProviderStatus", () => { + it.effect("returns ready when claude is installed and authenticated", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities(), + ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.installed, true); + assert.strictEqual(status.auth.status, "authenticated"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); }), - ); - - it.effect("skips codex probes entirely when the provider is disabled", () => - Effect.gen(function* () { - const status = yield* checkCodexProviderStatus(disabledCodexSettings).pipe( - Effect.provide(failingSpawnerLayer("spawn codex ENOENT")), - ); - assert.strictEqual(status.enabled, false); - assert.strictEqual(status.status, "disabled"); - assert.strictEqual(status.installed, false); - assert.strictEqual(status.message, "Codex is disabled in T3 Code settings."); - }), - ); - }); - - // ── checkClaudeProviderStatus tests ────────────────────────── - - describe("checkClaudeProviderStatus", () => { - it.effect("returns ready when claude is installed and authenticated", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities(), - ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.installed, true); - assert.strictEqual(status.auth.status, "authenticated"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), ), - ); + ), + ); - it.effect("returns ready and labels Bedrock-backed Claude as authenticated", () => - Effect.gen(function* () { - // Bedrock authenticates via external AWS credentials, so the SDK init - // reports only `apiProvider` with no subscription or token. - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ apiProvider: "bedrock" }), - ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.installed, true); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "bedrock"); - assert.strictEqual(status.auth.label, "Amazon Bedrock"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("returns ready and labels Bedrock-backed Claude as authenticated", () => + Effect.gen(function* () { + // Bedrock authenticates via external AWS credentials, so the SDK init + // reports only `apiProvider` with no subscription or token. + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ apiProvider: "bedrock" }), + ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.installed, true); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "bedrock"); + assert.strictEqual(status.auth.label, "Amazon Bedrock"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); + ), + ); - it.effect("returns a display label for claude subscription types", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ subscriptionType: "maxplan" }), - ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "maxplan"); - assert.strictEqual(status.auth.label, "Claude Max Subscription"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("returns a display label for claude subscription types", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ subscriptionType: "maxplan" }), + ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "maxplan"); + assert.strictEqual(status.auth.label, "Claude Max Subscription"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); + ), + ); - it.effect("does not duplicate Claude in full subscription labels", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ - subscriptionType: "Claude Max Subscription", - }), - ); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "Claude Max Subscription"); - assert.strictEqual(status.auth.label, "Claude Max Subscription"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("does not duplicate Claude in full subscription labels", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ + subscriptionType: "Claude Max Subscription", + }), + ); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "Claude Max Subscription"); + assert.strictEqual(status.auth.label, "Claude Max Subscription"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); + ), + ); - it.effect("does not duplicate Claude in provider-prefixed subscription names", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ - subscriptionType: "Claude Max", - }), - ); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "Claude Max"); - assert.strictEqual(status.auth.label, "Claude Max Subscription"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("does not duplicate Claude in provider-prefixed subscription names", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ + subscriptionType: "Claude Max", + }), + ); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "Claude Max"); + assert.strictEqual(status.auth.label, "Claude Max Subscription"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); + ), + ); - it.effect("returns claude auth email from initialization result", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ email: "claude@example.com" }), - ); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.email, "claude@example.com"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: - '{"loggedIn":true,"authMethod":"claude.ai","account":{"email":"claude@example.com"}}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("returns claude auth email from initialization result", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ email: "claude@example.com" }), + ); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.email, "claude@example.com"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: + '{"loggedIn":true,"authMethod":"claude.ai","account":{"email":"claude@example.com"}}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); - - it.effect("runs Claude status probes with the configured CLAUDE_CONFIG_DIR", () => { - const claudeConfigDir = "/tmp/t3code-claude-home"; - const recorded = recordingMockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }); - - return Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - { - ...defaultClaudeSettings, - homePath: claudeConfigDir, - }, - claudeCapabilities(), - ); - assert.strictEqual(status.status, "ready"); - // The home is resolved through the host Path before it reaches the env. - assert.deepStrictEqual( - recorded.commands.map((command) => command.env?.CLAUDE_CONFIG_DIR), - [(yield* Path.Path).resolve(claudeConfigDir)], - ); - }).pipe(Effect.provide(recorded.layer)); + ), + ); + + it.effect("runs Claude status probes with the configured CLAUDE_CONFIG_DIR", () => { + const claudeConfigDir = "/tmp/t3code-claude-home"; + const recorded = recordingMockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); }); - it.effect("includes probed claude slash commands in the provider snapshot", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ - subscriptionType: "maxplan", - slashCommands: [ - { - name: "review", - description: "Review a pull request", - input: { hint: "pr-or-branch" }, - }, - ], - }), - ); + return Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + { + ...defaultClaudeSettings, + homePath: claudeConfigDir, + }, + claudeCapabilities(), + ); + assert.strictEqual(status.status, "ready"); + // The home is resolved through the host Path before it reaches the env. + assert.deepStrictEqual( + recorded.commands.map((command) => command.env?.CLAUDE_CONFIG_DIR), + [(yield* Path.Path).resolve(claudeConfigDir)], + ); + }).pipe(Effect.provide(recorded.layer)); + }); - assert.deepStrictEqual(status.slashCommands.slice(1), [ - { - name: "review", - description: "Review a pull request", - input: { hint: "pr-or-branch" }, - }, - ]); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("includes probed claude slash commands in the provider snapshot", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ + subscriptionType: "maxplan", + slashCommands: [ + { + name: "review", + description: "Review a pull request", + input: { hint: "pr-or-branch" }, + }, + ], + }), + ); + + assert.deepStrictEqual(status.slashCommands.slice(1), [ + { + name: "review", + description: "Review a pull request", + input: { hint: "pr-or-branch" }, + }, + ]); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); + ), + ); - it.effect("deduplicates probed claude slash commands by name", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ - subscriptionType: "maxplan", - slashCommands: [ - { - name: "ui", - description: "Explore and refine UI", - }, - { - name: "ui", - input: { hint: "component-or-screen" }, - }, - ], - }), - ); + it.effect("deduplicates probed claude slash commands by name", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ + subscriptionType: "maxplan", + slashCommands: [ + { + name: "ui", + description: "Explore and refine UI", + }, + { + name: "ui", + input: { hint: "component-or-screen" }, + }, + ], + }), + ); - assert.deepStrictEqual(status.slashCommands, [ - COMPACT_SLASH_COMMAND, - { - name: "ui", - description: "Explore and refine UI", - input: { hint: "component-or-screen" }, - }, - ]); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + assert.deepStrictEqual(status.slashCommands, [ + COMPACT_SLASH_COMMAND, + { + name: "ui", + description: "Explore and refine UI", + input: { hint: "component-or-screen" }, + }, + ]); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); + ), + ); - it.effect("returns an api key label for claude api key auth", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities({ tokenSource: "ANTHROPIC_AUTH_TOKEN" }), - ); - assert.strictEqual(status.status, "ready"); - assert.strictEqual(status.auth.status, "authenticated"); - assert.strictEqual(status.auth.type, "apiKey"); - assert.strictEqual(status.auth.label, "Claude API Key"); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":true,"authMethod":"api-key"}\n', - stderr: "", - code: 0, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("returns an api key label for claude api key auth", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities({ tokenSource: "ANTHROPIC_AUTH_TOKEN" }), + ); + assert.strictEqual(status.status, "ready"); + assert.strictEqual(status.auth.status, "authenticated"); + assert.strictEqual(status.auth.type, "apiKey"); + assert.strictEqual(status.auth.label, "Claude API Key"); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":true,"authMethod":"api-key"}\n', + stderr: "", + code: 0, + }; + throw new Error(`Unexpected args: ${joined}`); + }), ), - ); - - it.effect("returns unavailable when claude is missing", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities(), - ); - assert.strictEqual(status.status, "error"); - assert.strictEqual(status.installed, false); - assert.strictEqual(status.auth.status, "unknown"); - assert.strictEqual(status.message, "Claude Agent CLI (`claude`) was not found on PATH."); - }).pipe(Effect.provide(failingSpawnerLayer("spawn claude ENOENT"))), - ); + ), + ); - it.effect("returns error when version check fails with non-zero exit code", () => { - const secretStderr = "Something went wrong: secret-token-value"; - return Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - claudeCapabilities(), - ); - assert.strictEqual(status.status, "error"); - assert.strictEqual(status.installed, true); - assert.strictEqual(status.message, "Claude Agent CLI is installed but failed to run."); - assert.ok(!(status.message ?? "").includes(secretStderr)); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") - return { - stdout: "", - stderr: secretStderr, - code: 1, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + it.effect("returns unavailable when claude is missing", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities(), ); - }); - - it.effect("returns warning when the Claude initialization result is unavailable", () => - Effect.gen(function* () { - const status = yield* checkClaudeProviderStatus( - defaultClaudeSettings, - noClaudeCapabilities, - ); - assert.strictEqual(status.status, "warning"); - assert.strictEqual(status.installed, true); - assert.strictEqual(status.auth.status, "unknown"); - assert.strictEqual( - status.message, - "Could not verify Claude authentication status from initialization result.", - ); - }).pipe( - Effect.provide( - mockSpawnerLayer((args) => { - const joined = args.join(" "); - if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; - if (joined === "auth status") - return { - stdout: '{"loggedIn":false}\n', - stderr: "", - code: 1, - }; - throw new Error(`Unexpected args: ${joined}`); - }), - ), + assert.strictEqual(status.status, "error"); + assert.strictEqual(status.installed, false); + assert.strictEqual(status.auth.status, "unknown"); + assert.strictEqual(status.message, "Claude Agent CLI (`claude`) was not found on PATH."); + }).pipe(Effect.provide(failingSpawnerLayer("spawn claude ENOENT"))), + ); + + it.effect("returns error when version check fails with non-zero exit code", () => { + const secretStderr = "Something went wrong: secret-token-value"; + return Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + claudeCapabilities(), + ); + assert.strictEqual(status.status, "error"); + assert.strictEqual(status.installed, true); + assert.strictEqual(status.message, "Claude Agent CLI is installed but failed to run."); + assert.ok(!(status.message ?? "").includes(secretStderr)); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") + return { + stdout: "", + stderr: secretStderr, + code: 1, + }; + throw new Error(`Unexpected args: ${joined}`); + }), ), ); }); - }, -); + + it.effect("returns warning when the Claude initialization result is unavailable", () => + Effect.gen(function* () { + const status = yield* checkClaudeProviderStatus( + defaultClaudeSettings, + noClaudeCapabilities, + ); + assert.strictEqual(status.status, "warning"); + assert.strictEqual(status.installed, true); + assert.strictEqual(status.auth.status, "unknown"); + assert.strictEqual( + status.message, + "Could not verify Claude authentication status from initialization result.", + ); + }).pipe( + Effect.provide( + mockSpawnerLayer((args) => { + const joined = args.join(" "); + if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 }; + if (joined === "auth status") + return { + stdout: '{"loggedIn":false}\n', + stderr: "", + code: 1, + }; + throw new Error(`Unexpected args: ${joined}`); + }), + ), + ), + ); + }); +}); diff --git a/apps/server/src/provider/Layers/ProviderRegistry.ts b/apps/server/src/provider/Layers/ProviderRegistry.ts index a8e6caf95aa7..c59848bc1e1d 100644 --- a/apps/server/src/provider/Layers/ProviderRegistry.ts +++ b/apps/server/src/provider/Layers/ProviderRegistry.ts @@ -226,7 +226,7 @@ export const mergeProviderSnapshot = ( }; }; -const haveProvidersChanged = ( +export const haveProvidersChanged = ( previousProviders: ReadonlyArray, nextProviders: ReadonlyArray, ): boolean => !Equal.equals(previousProviders, nextProviders); diff --git a/apps/server/src/provider/Layers/ProviderService.test.ts b/apps/server/src/provider/Layers/ProviderService.test.ts index 9a3fcb8d65f4..00a7cf50ffb2 100644 --- a/apps/server/src/provider/Layers/ProviderService.test.ts +++ b/apps/server/src/provider/Layers/ProviderService.test.ts @@ -499,7 +499,10 @@ for (const [enabled, completed] of [ const turnId = asTurnId("shutdown-recovery-turn"); const scope = yield* Scope.make(); const services = yield* Layer.build( - makeProviderServiceLive().pipe( + makeProviderServiceLive({ + shutdownInterruptGracePeriod: "0 millis", + shutdownGracePeriod: "50 millis", + }).pipe( Layer.provide(NodeServices.layer), Layer.provide( Layer.succeed(ProviderSessionDirectory.ProviderSessionDirectory, directory), @@ -573,10 +576,13 @@ for (const [enabled, completed] of [ assert.deepStrictEqual(binding.value.resumeCursor, session.resumeCursor); assert.equal(binding.value.status, "stopped"); assert.propertyVal(markers[0], "activeTurnId", completed ? null : turnId); - if (enabled && !completed) { + if (!completed) { + // Graceful stopAll still marks working sessions with a resume cursor, + // even when the restart opt-in is off. Crash/machine-restart recovery + // is what the setting gates. assert.propertyVal(markers[0], "continueAfterServerUpdate", turnId); assert.propertyVal(binding.value.runtimePayload, "continueAfterServerUpdate", turnId); - } else if (completed) { + } else { assert.propertyVal( binding.value.runtimePayload, "continueAfterServerUpdate", @@ -587,9 +593,6 @@ for (const [enabled, completed] of [ "continueAfterServerUpdatePrepared", null, ); - } else { - assert.propertyVal(markers[0], "continueAfterServerUpdate", null); - assert.propertyVal(binding.value.runtimePayload, "continueAfterServerUpdate", null); } }).pipe(Effect.provide(NodeServices.layer)), ); @@ -648,6 +651,58 @@ it.effect("ProviderServiceLive catches stopAll failures during shutdown", () => }), ); +it.effect("ProviderServiceLive bounds a provider that wedges during shutdown", () => + Effect.gen(function* () { + const codex = makeFakeCodexAdapter(); + codex.stopAll.mockImplementation(() => Effect.never); + const registry = makeAdapterRegistryMock({ + [CODEX_DRIVER]: codex.adapter, + }); + const providerAdapterLayer = Layer.succeed( + ProviderAdapterRegistry.ProviderAdapterRegistry, + registry, + ); + const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe( + Layer.provide(SqlitePersistenceMemory), + ); + const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer)); + const providerLayer = Layer.mergeAll( + makeProviderServiceLive({ + shutdownInterruptGracePeriod: "0 millis", + shutdownGracePeriod: "50 millis", + }).pipe( + Layer.provide(NodeServices.layer), + Layer.provide(providerAdapterLayer), + Layer.provide(directoryLayer), + Layer.provide(defaultServerSettingsLayer), + Layer.provideMerge(AnalyticsService.layerTest), + Layer.provide(serverConfigTestLayer), + Layer.provide( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, + ), + ), + ), + directoryLayer, + runtimeRepositoryLayer, + NodeServices.layer, + ); + const scope = yield* Scope.make(); + const runtimeServices = yield* Layer.build(providerLayer).pipe(Scope.provide(scope)); + + yield* ProviderService.ProviderService.pipe(Effect.provide(runtimeServices)); + const closeFiber = yield* Scope.close(scope, Exit.void).pipe( + Effect.forkChild({ startImmediately: true }), + ); + yield* advanceTestClock(50); + const closeExit = yield* Fiber.join(closeFiber).pipe(Effect.exit); + + assert.equal(Exit.isSuccess(closeExit), true); + assert.equal(codex.stopAll.mock.calls.length, 1); + }), +); + it.effect("ProviderServiceLive flushes deferred completions during shutdown", () => Effect.gen(function* () { const recordedAnalytics = makeRecordingAnalytics(); @@ -767,6 +822,190 @@ it.effect("ProviderServiceLive flushes deferred completions during shutdown", () }), ); +it.effect("graceful shutdown interrupts working sessions before stopAll", () => + Effect.gen(function* () { + const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-provider-recovery-")); + const dbPath = NodePath.join(tempDir, "runtime.sqlite"); + const persistenceLayer = makeSqlitePersistenceLive(dbPath); + const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe( + Layer.provide(persistenceLayer), + ); + const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer)); + const codex = makeFakeCodexAdapter(); + const providerLayer = makeProviderServiceLive({ + shutdownInterruptGracePeriod: "0 millis", + shutdownGracePeriod: "50 millis", + }).pipe( + Layer.provide( + Layer.succeed( + ProviderAdapterRegistry.ProviderAdapterRegistry, + makeAdapterRegistryMock({ [CODEX_DRIVER]: codex.adapter }), + ), + ), + Layer.provide(directoryLayer), + Layer.provide(defaultServerSettingsLayer), + Layer.provide(AnalyticsService.layerTest), + Layer.provide(serverConfigTestLayer), + Layer.provide( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, + ), + ), + ); + const scope = yield* Scope.make(); + const services = yield* Layer.build( + Layer.mergeAll(providerLayer, runtimeRepositoryLayer, directoryLayer), + ).pipe(Scope.provide(scope)); + const provider = yield* ProviderService.ProviderService.pipe(Effect.provide(services)); + + const runningThreadId = asThreadId("thread-running-on-shutdown"); + const connectingThreadId = asThreadId("thread-connecting-on-shutdown"); + const readyThreadId = asThreadId("thread-ready-on-shutdown"); + const stoppedThreadId = asThreadId("thread-explicitly-stopped"); + for (const threadId of [runningThreadId, connectingThreadId, readyThreadId, stoppedThreadId]) { + yield* provider.startSession(threadId, { + threadId, + provider: CODEX_DRIVER, + providerInstanceId: codexInstanceId, + runtimeMode: "full-access", + }); + } + yield* provider.sendTurn({ + threadId: runningThreadId, + input: "keep working", + interactionMode: "plan", + }); + codex.updateSession(runningThreadId, (session) => ({ + ...session, + status: "running", + activeTurnId: asTurnId("provider-turn-running"), + })); + codex.updateSession(connectingThreadId, (session) => ({ + ...session, + status: "connecting", + })); + + yield* provider.stopSession({ threadId: stoppedThreadId }); + // Model a provider protocol drain that never completes. Shutdown must still + // interrupt working sessions and bound the wedged stopAll. + codex.stopAll.mockImplementation(() => Effect.never); + const closeFiber = yield* Scope.close(scope, Exit.void).pipe( + Effect.forkChild({ startImmediately: true }), + ); + yield* advanceTestClock(50); + yield* Fiber.join(closeFiber); + + const rows = yield* Effect.gen(function* () { + const repository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository; + return yield* repository.list(); + }).pipe(Effect.provide(runtimeRepositoryLayer)); + const byThreadId = new Map(rows.map((row) => [row.threadId, row])); + + assert.equal(byThreadId.get(runningThreadId)?.status, "stopped"); + assert.equal(byThreadId.get(connectingThreadId)?.status, "stopped"); + assert.equal(byThreadId.get(readyThreadId)?.status, "stopped"); + assert.equal(byThreadId.get(stoppedThreadId)?.status, "stopped"); + const runningPayload = byThreadId.get(runningThreadId)?.runtimePayload as + | Record + | null + | undefined; + assert.equal(runningPayload?.continueAfterServerUpdate, "provider-turn-running"); + const readyPayload = byThreadId.get(readyThreadId)?.runtimePayload as + | Record + | null + | undefined; + assert.equal(readyPayload?.continueAfterServerUpdate, undefined); + const stoppedPayload = byThreadId.get(stoppedThreadId)?.runtimePayload as + | Record + | null + | undefined; + assert.equal(stoppedPayload?.continueAfterServerUpdate, undefined); + // Working sessions must receive cooperative interrupt before hard stopAll. + assert.isTrue(codex.interruptTurn.mock.calls.length >= 2); + assert.deepEqual(codex.interruptTurn.mock.calls[0]?.[0], runningThreadId); + + NodeFS.rmSync(tempDir, { recursive: true, force: true }); + }).pipe(Effect.provide(NodeServices.layer)), +); + +it.effect("graceful shutdown stops live bindings missing from adapter listSessions", () => + Effect.gen(function* () { + const tempDir = NodeFS.mkdtempSync( + NodePath.join(NodeOS.tmpdir(), "t3-provider-recovery-orphan-binding-"), + ); + const dbPath = NodePath.join(tempDir, "runtime.sqlite"); + const persistenceLayer = makeSqlitePersistenceLive(dbPath); + const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe( + Layer.provide(persistenceLayer), + ); + const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer)); + const codex = makeFakeCodexAdapter(); + // Adapter has no live sessions — models mid-teardown / empty listSessions. + codex.listSessions.mockImplementation(() => Effect.succeed([])); + const providerLayer = makeProviderServiceLive({ + shutdownInterruptGracePeriod: "0 millis", + shutdownGracePeriod: "50 millis", + }).pipe( + Layer.provide( + Layer.succeed( + ProviderAdapterRegistry.ProviderAdapterRegistry, + makeAdapterRegistryMock({ [CODEX_DRIVER]: codex.adapter }), + ), + ), + Layer.provide(directoryLayer), + Layer.provide(defaultServerSettingsLayer), + Layer.provide(AnalyticsService.layerTest), + Layer.provide(serverConfigTestLayer), + Layer.provide( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, + ), + ), + ); + const scope = yield* Scope.make(); + const services = yield* Layer.build( + Layer.mergeAll(providerLayer, runtimeRepositoryLayer, directoryLayer), + ).pipe(Scope.provide(scope)); + yield* ProviderService.ProviderService.pipe(Effect.provide(services)); + + const orphanThreadId = asThreadId("thread-persisted-running-only"); + const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory.pipe( + Effect.provide(services), + ); + yield* directory.upsert({ + threadId: orphanThreadId, + provider: CODEX_DRIVER, + providerInstanceId: codexInstanceId, + status: "running", + resumeCursor: { threadId: "provider-orphan" }, + runtimePayload: { + activeTurnId: asTurnId("provider-turn-orphan"), + }, + }); + + codex.stopAll.mockImplementation(() => Effect.void); + const closeFiber = yield* Scope.close(scope, Exit.void).pipe( + Effect.forkChild({ startImmediately: true }), + ); + yield* advanceTestClock(50); + yield* Fiber.join(closeFiber); + + const rows = yield* Effect.gen(function* () { + const repository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository; + return yield* repository.list(); + }).pipe(Effect.provide(runtimeRepositoryLayer)); + const orphan = rows.find((row) => row.threadId === orphanThreadId); + assert.isDefined(orphan); + assert.equal(orphan?.status, "stopped"); + const orphanPayload = orphan?.runtimePayload as Record | null | undefined; + assert.equal(orphanPayload?.continueAfterServerUpdate, "provider-turn-orphan"); + + NodeFS.rmSync(tempDir, { recursive: true, force: true }); + }).pipe(Effect.provide(NodeServices.layer)), +); + it.effect("ProviderServiceLive rejects new sessions for disabled providers", () => Effect.gen(function* () { const codex = makeFakeCodexAdapter(); @@ -2855,6 +3094,26 @@ routing.layer("ProviderServiceLive routing", (it) => { assert.equal(runtimePayload.lastRuntimeEvent, "provider.sendTurn"); } } + + yield* Effect.yieldNow; + routing.codex.emit({ + type: "turn.completed", + eventId: asEventId("evt-runtime-status-completed"), + provider: CODEX_DRIVER, + createdAt: "2026-01-01T00:00:01.000Z", + threadId: session.threadId, + turnId: asTurnId(`turn-${String(session.threadId)}`), + status: "completed", + }); + yield* Effect.yieldNow; + yield* advanceTestClock(50); + const completedRuntime = yield* runtimeRepository.getByThreadId({ + threadId: session.threadId, + }); + assert.equal(Option.isSome(completedRuntime), true); + if (Option.isSome(completedRuntime)) { + assert.equal(completedRuntime.value.status, "running"); + } }), ); @@ -3143,6 +3402,7 @@ fanout.layer("ProviderServiceLive fanout", (it) => { threadId: asThreadId("thread-1"), runtimeMode: "full-access", }); + yield* provider.sendTurn({ threadId: session.threadId, input: "hello" }); const eventsRef = yield* Ref.make>([]); const consumer = yield* Stream.runForEach(provider.streamEvents, (event) => @@ -3156,7 +3416,7 @@ fanout.layer("ProviderServiceLive fanout", (it) => { provider: ProviderDriverKind.make("codex"), createdAt: "2026-01-01T00:00:00.000Z", threadId: session.threadId, - turnId: asTurnId("turn-1"), + turnId: asTurnId("turn-thread-1"), payload: { state: "completed" }, }; @@ -3177,6 +3437,18 @@ fanout.layer("ProviderServiceLive fanout", (it) => { ), true, ); + const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository; + const persistedRuntime = yield* runtimeRepository.getByThreadId({ + threadId: session.threadId, + }); + assert.equal(Option.isSome(persistedRuntime), true); + if (Option.isSome(persistedRuntime)) { + assert.equal(persistedRuntime.value.status, "running"); + assert.deepInclude(persistedRuntime.value.runtimePayload, { + activeTurnId: null, + lastRuntimeEvent: "turn.completed", + }); + } }), ); @@ -4822,6 +5094,9 @@ describe("agent browser access", () => { const projectionLayer = Layer.succeed(ProjectionSnapshotQuery.ProjectionSnapshotQuery, { getTurnStartMessage: () => Effect.die("unused"), getImportedAgentSessionSources: () => Effect.die("unused"), + getSessionStopContextById: () => Effect.die("unused"), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), getUserInputActivity: () => Effect.die("unused"), getCommandReadModel: () => Effect.die("unused"), getSnapshot: () => Effect.die("unused"), diff --git a/apps/server/src/provider/Layers/ProviderService.ts b/apps/server/src/provider/Layers/ProviderService.ts index d04dcae7f126..e21c97b1d914 100644 --- a/apps/server/src/provider/Layers/ProviderService.ts +++ b/apps/server/src/provider/Layers/ProviderService.ts @@ -12,8 +12,8 @@ import { EventId, MessageId, - ModelSelection, NonNegativeInt, + ProviderCompactSessionInput, ProviderInterruptTurnInput, ProviderRespondToRequestInput, ProviderRespondToUserInputInput, @@ -32,14 +32,17 @@ import { type ProviderDriverKind, type ProviderRuntimeEvent, type ProviderSession, + ModelSelection, } from "@t3tools/contracts"; import { expandAssistantCitationsForProvider } from "@t3tools/shared/assistantCitations"; import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; import { causeErrorTag } from "@t3tools/shared/observability"; import { getModelSelectionStringOptionValue } from "@t3tools/shared/model"; import { resolveProjectAgentBrowserAccess } from "@t3tools/shared/serverSettings"; +import * as Cause from "effect/Cause"; import * as DateTime from "effect/DateTime"; import * as Deferred from "effect/Deferred"; +import type * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; @@ -68,8 +71,9 @@ import { withMetrics, } from "../../observability/Metrics.ts"; import { - ProviderAdapterRequestError, type ProviderAdapterError, + ProviderAdapterRequestError, + ProviderSessionNotFoundError, ProviderValidationError, ProviderWorkspaceMissingError, } from "../Errors.ts"; @@ -82,6 +86,15 @@ import * as ProviderEventLoggers from "./ProviderEventLoggers.ts"; import * as AnalyticsService from "../../telemetry/AnalyticsService.ts"; import * as McpProviderSession from "../../mcp/McpProviderSession.ts"; import * as McpSessionRegistry from "../../mcp/McpSessionRegistry.ts"; +import { + readPersistedProviderActiveTurnId, + readPersistedProviderCwd, + readPersistedProviderModelSelection, +} from "../ProviderRestartRecovery.ts"; +import { + readRuntimePayload, + SERVER_UPDATE_CONTINUATION_KEY, +} from "../providerSessionContinuation.ts"; import * as ServerSettings from "../../serverSettings.ts"; import * as ProjectionSnapshotQuery from "../../orchestration/Services/ProjectionSnapshotQuery.ts"; const isModelSelection = Schema.is(ModelSelection); @@ -247,6 +260,19 @@ interface PendingCompaction { */ export interface ProviderServiceLiveOptions { readonly canonicalEventLogger?: EventNdjsonLogger; + /** + * Wait this long after cooperative `interruptTurn` on in-flight sessions + * before hard `adapter.stopAll()`. Gives providers time to cancel tools / + * flush before process teardown. Default `30 seconds` — well under ops' + * ~150s main-pid SIGTERM reap window (interrupt grace + stopAll grace must + * fit inside that). + */ + readonly shutdownInterruptGracePeriod?: Duration.Input; + /** + * Maximum time the server gives all provider adapters, collectively, to + * stop during process shutdown (after the interrupt grace). Default `1 minute`. + */ + readonly shutdownGracePeriod?: Duration.Input; /** * Overrides MCP credential issuance. The real issuer reads a module-global * registry that only a running MCP server installs, which makes the @@ -382,6 +408,7 @@ function toRuntimePayloadFromSession( session: ProviderSession, extra?: { readonly modelSelection?: unknown; + readonly interactionMode?: unknown; readonly continueAfterServerUpdate?: TurnId; readonly lastRuntimeEvent?: string; readonly lastRuntimeEventAt?: string; @@ -396,6 +423,7 @@ function toRuntimePayloadFromSession( ? { continueAfterServerUpdate: extra.continueAfterServerUpdate } : {}), ...(extra?.modelSelection !== undefined ? { modelSelection: extra.modelSelection } : {}), + ...(extra?.interactionMode !== undefined ? { interactionMode: extra.interactionMode } : {}), ...(extra?.lastRuntimeEvent !== undefined ? { lastRuntimeEvent: extra.lastRuntimeEvent } : {}), ...(extra?.lastRuntimeEventAt !== undefined ? { lastRuntimeEventAt: extra.lastRuntimeEventAt } @@ -403,28 +431,15 @@ function toRuntimePayloadFromSession( }; } -function readPersistedModelSelection( - runtimePayload: ProviderSessionDirectory.ProviderRuntimeBinding["runtimePayload"], -): ModelSelection | undefined { - if (!runtimePayload || typeof runtimePayload !== "object" || Array.isArray(runtimePayload)) { - return undefined; - } - const raw = "modelSelection" in runtimePayload ? runtimePayload.modelSelection : undefined; - return isModelSelection(raw) ? raw : undefined; +function normalizeProviderCwd(cwd: string): string { + const trimmed = cwd.trim(); + return trimmed.length > 1 ? trimmed.replace(/[\\/]+$/, "") : trimmed; } -function readPersistedCwd( - runtimePayload: ProviderSessionDirectory.ProviderRuntimeBinding["runtimePayload"], -): string | undefined { - if (!runtimePayload || typeof runtimePayload !== "object" || Array.isArray(runtimePayload)) { - return undefined; - } - const rawCwd = "cwd" in runtimePayload ? runtimePayload.cwd : undefined; - if (typeof rawCwd !== "string") return undefined; - const trimmed = rawCwd.trim(); - return trimmed.length > 0 ? trimmed : undefined; +function providerCwdMatches(actual: string | undefined, expected: string | undefined): boolean { + if (expected === undefined) return true; + return actual !== undefined && normalizeProviderCwd(actual) === normalizeProviderCwd(expected); } - const dieOnMissingBindingInstanceId = ( operation: string, payload: { @@ -964,6 +979,72 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( Effect.asVoid, ); + const persistRuntimeEventState = Effect.fn("persistRuntimeEventState")(function* ( + event: ProviderRuntimeEvent, + ) { + const binding = Option.getOrUndefined(yield* directory.getBinding(event.threadId)); + if (!binding || event.providerInstanceId === undefined) return; + if (binding.providerInstanceId !== event.providerInstanceId) { + yield* Effect.logWarning("provider runtime event ignored for stale persisted instance", { + threadId: event.threadId, + eventType: event.type, + eventProviderInstanceId: event.providerInstanceId, + bindingProviderInstanceId: binding.providerInstanceId, + }); + return; + } + + const persistedActiveTurnId = readPersistedProviderActiveTurnId(binding.runtimePayload); + const lifecycle = (() => { + switch (event.type) { + case "turn.started": + return event.turnId === undefined + ? { status: "running" as const } + : { status: "running" as const, activeTurnId: event.turnId }; + case "turn.completed": + case "turn.aborted": + if ( + persistedActiveTurnId !== undefined && + (event.turnId === undefined || event.turnId !== persistedActiveTurnId) + ) { + return undefined; + } + return { status: "running" as const, activeTurnId: null }; + case "session.exited": + return { status: "stopped" as const, activeTurnId: null }; + case "session.state.changed": + switch (event.payload.state) { + case "starting": + return { status: "starting" as const }; + case "error": + return { status: "error" as const, activeTurnId: null }; + case "stopped": + return { status: "stopped" as const, activeTurnId: null }; + case "ready": + case "waiting": + return { status: "running" as const, activeTurnId: null }; + case "running": + return { status: "running" as const }; + } + default: + return undefined; + } + })(); + if (lifecycle === undefined) return; + + yield* directory.upsert({ + threadId: event.threadId, + provider: binding.provider, + providerInstanceId: event.providerInstanceId, + ...(binding.runtimeMode !== undefined ? { runtimeMode: binding.runtimeMode } : {}), + status: lifecycle.status, + runtimePayload: { + ...(lifecycle.activeTurnId !== undefined ? { activeTurnId: lifecycle.activeTurnId } : {}), + lastRuntimeEvent: event.type, + lastRuntimeEventAt: event.createdAt, + }, + }); + }); const isCompactedEvent = ( event: ProviderRuntimeEvent, ): event is Extract => @@ -1046,6 +1127,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( threadId: ThreadId, extra?: { readonly modelSelection?: unknown; + readonly interactionMode?: unknown; readonly continueAfterServerUpdate?: TurnId; readonly lastRuntimeEvent?: string; readonly lastRuntimeEventAt?: string; @@ -1082,6 +1164,15 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( provider: canonicalEvent.provider, eventType: canonicalEvent.type, }); + yield* persistRuntimeEventState(canonicalEvent).pipe( + Effect.catchCause((cause) => + Effect.logWarning("failed to persist provider runtime lifecycle event", { + threadId: canonicalEvent.threadId, + eventType: canonicalEvent.type, + cause, + }), + ), + ); if (canonicalEvent.type === "turn.started") { yield* observeTurnStartedForAnalytics(source, canonicalEvent); } else if (canonicalEvent.type === "model.rerouted") { @@ -1208,6 +1299,16 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( (session) => session.threadId === input.binding.threadId, ); if (existing) { + const persistedCwd = readPersistedProviderCwd(input.binding.runtimePayload); + if (!providerCwdMatches(existing.cwd, persistedCwd)) { + return yield* toValidationError( + input.operation, + [ + `Active provider session for thread '${input.binding.threadId}' is in '${existing.cwd ?? "unknown"}' but persisted cwd is '${persistedCwd ?? "unknown"}'.`, + "Refusing to recover a provider session for the wrong workspace.", + ].join(" "), + ); + } yield* upsertSessionBinding( { ...existing, providerInstanceId: bindingInstanceId }, input.binding.threadId, @@ -1228,8 +1329,10 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( ); } - const persistedCwd = readPersistedCwd(input.binding.runtimePayload); - const persistedModelSelection = readPersistedModelSelection(input.binding.runtimePayload); + const persistedCwd = readPersistedProviderCwd(input.binding.runtimePayload); + const persistedModelSelection = readPersistedProviderModelSelection( + input.binding.runtimePayload, + ); yield* prepareMcpSession(input.binding.threadId, bindingInstanceId); const resumed = yield* adapter @@ -1250,6 +1353,17 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( `Adapter/provider mismatch while recovering thread '${input.binding.threadId}'. Expected '${adapter.provider}', received '${resumed.provider}'.`, ); } + if (!providerCwdMatches(resumed.cwd, persistedCwd)) { + yield* adapter.stopSession(resumed.threadId).pipe(Effect.ignore); + yield* clearMcpSession(input.binding.threadId); + return yield* toValidationError( + input.operation, + [ + `Recovered provider session for thread '${input.binding.threadId}' is in '${resumed.cwd ?? "unknown"}' but persisted cwd is '${persistedCwd ?? "unknown"}'.`, + "Refusing to recover a provider session for the wrong workspace.", + ].join(" "), + ); + } yield* upsertSessionBinding( { ...resumed, providerInstanceId: bindingInstanceId }, @@ -1425,7 +1539,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( const effectiveCwd = input.cwd ?? (persistedBinding?.providerInstanceId === resolvedInstanceId - ? readPersistedCwd(persistedBinding.runtimePayload) + ? readPersistedProviderCwd(persistedBinding.runtimePayload) : undefined); yield* Effect.annotateCurrentSpan({ "provider.kind": resolvedProvider, @@ -1479,6 +1593,17 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( `Adapter/provider mismatch: requested '${adapter.provider}', received '${session.provider}'.`, ); } + if (!providerCwdMatches(session.cwd, effectiveCwd)) { + yield* adapter.stopSession(session.threadId).pipe(Effect.ignore); + yield* clearMcpSession(threadId); + return yield* toValidationError( + "ProviderService.startSession", + [ + `Provider '${adapter.provider}' started in '${session.cwd ?? "unknown"}' but T3 requested '${effectiveCwd}'.`, + "Refusing to persist a provider session for the wrong workspace.", + ].join(" "), + ); + } const sessionWithInstance = { ...session, providerInstanceId: resolvedInstanceId, @@ -1695,6 +1820,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( requestId: turnMetadata.requestId, }), ); + const turnStartedAt = yield* nowIso; yield* directory.upsert({ threadId: input.threadId, provider: routed.adapter.provider, @@ -1703,12 +1829,15 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( ...(turn.resumeCursor !== undefined ? { resumeCursor: turn.resumeCursor } : {}), runtimePayload: { ...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}), + ...(input.interactionMode !== undefined + ? { interactionMode: input.interactionMode } + : {}), activeTurnId: turn.turnId, // Admission and marker consumption must survive the same restart. continueAfterServerUpdate: null, continueAfterServerUpdatePrepared: null, lastRuntimeEvent: "provider.sendTurn", - lastRuntimeEventAt: yield* nowIso, + lastRuntimeEventAt: turnStartedAt, }, }); yield* analytics.record("provider.turn.sent", { @@ -1875,7 +2004,10 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( const routed = yield* resolveRoutableSession({ threadId: input.threadId, operation: "ProviderService.interruptTurn", - allowRecovery: true, + // Interrupt must never resurrect an old persisted session merely to + // cancel it. The orchestration reactor authoritatively clears the + // projected running state even when no live adapter session exists. + allowRecovery: false, }); metricProvider = routed.adapter.provider; yield* Effect.annotateCurrentSpan({ @@ -1884,7 +2016,9 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( "provider.thread_id": input.threadId, "provider.turn_id": input.turnId, }); - yield* routed.adapter.interruptTurn(routed.threadId, input.turnId); + if (routed.isActive) { + yield* routed.adapter.interruptTurn(routed.threadId, input.turnId); + } yield* analytics.record("provider.turn.interrupted", { provider: routed.adapter.provider, }); @@ -1900,6 +2034,38 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( }, ); + const compactSession: ProviderServiceMethod<"compactSession"> = Effect.fn("compactSession")( + function* (rawInput) { + const input = yield* decodeInputOrValidationError({ + operation: "ProviderService.compactSession", + schema: ProviderCompactSessionInput, + payload: rawInput, + }); + const routed = yield* resolveRoutableSession({ + threadId: input.threadId, + operation: "ProviderService.compactSession", + allowRecovery: true, + }); + yield* Effect.annotateCurrentSpan({ + "provider.operation": "compact-session", + "provider.kind": routed.adapter.provider, + "provider.thread_id": input.threadId, + }); + if (routed.adapter.compactSession === undefined) { + return yield* new ProviderValidationError({ + operation: "ProviderService.compactSession", + issue: `Provider ${routed.adapter.provider} does not support manual context compact.`, + }); + } + if (!routed.isActive) { + return yield* new ProviderSessionNotFoundError({ + threadId: input.threadId, + }); + } + yield* routed.adapter.compactSession(routed.threadId); + }, + ); + const respondToRequest: ProviderServiceMethod<"respondToRequest"> = Effect.fn("respondToRequest")( function* (rawInput) { const input = yield* decodeInputOrValidationError({ @@ -2242,6 +2408,8 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( yield* recordCompletedTurnProperties(properties); const threadIds = yield* directory.listThreadIds(); const currentAdapters = yield* getAdapterEntries; + const lastRuntimeEventAt = yield* nowIso; + const activeSessions = yield* Effect.forEach(currentAdapters, ([instanceId, adapter]) => adapter.listSessions().pipe( Effect.map((sessions) => @@ -2252,18 +2420,155 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( ), ), ).pipe(Effect.map((sessionsByAdapter) => sessionsByAdapter.flatMap((sessions) => sessions))); + + // Same payload key as in-app #9167. Startup reconcileProviderSessions + // continues marked threads after this process is replaced (systemd + // restart, deploy). Crash/hard-kill never reaches stopAll, so those + // still settle as interrupted. + const persistedBindings = yield* directory.listBindings().pipe(Effect.orElseSucceed(() => [])); + const bindingByThreadId = new Map( + persistedBindings.map((binding) => [binding.threadId, binding] as const), + ); + const continuationByThreadId = new Map(); + const considerContinuation = ( + threadId: ThreadId, + turnId: TurnId | null | undefined, + resumeCursor: unknown, + ) => { + if (turnId === null || turnId === undefined) return; + if (resumeCursor === null || resumeCursor === undefined) return; + if (continuationByThreadId.has(threadId)) return; + continuationByThreadId.set(threadId, turnId); + }; + + for (const session of activeSessions) { + const working = session.status === "connecting" || session.status === "running"; + if (!working) continue; + const binding = bindingByThreadId.get(session.threadId); + considerContinuation( + session.threadId, + session.activeTurnId ?? readPersistedProviderActiveTurnId(binding?.runtimePayload), + binding?.resumeCursor ?? session.resumeCursor, + ); + } + for (const binding of persistedBindings) { + if (binding.status !== "starting" && binding.status !== "running") continue; + considerContinuation( + binding.threadId, + readPersistedProviderActiveTurnId(binding.runtimePayload), + binding.resumeCursor, + ); + } + + yield* Effect.forEach( + [...continuationByThreadId.entries()], + ([threadId, turnId]) => + Effect.gen(function* () { + const binding = bindingByThreadId.get(threadId); + if (binding === undefined) return; + yield* directory.upsert({ + ...binding, + runtimePayload: { + ...readRuntimePayload(binding.runtimePayload), + [SERVER_UPDATE_CONTINUATION_KEY]: turnId, + }, + }); + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("failed to mark provider session for restart continuation", { + threadId, + cause: Cause.pretty(cause), + }), + ), + ), + { discard: true }, + ); + if (continuationByThreadId.size > 0) { + yield* Effect.logInfo("marked provider sessions to continue after graceful restart", { + continuationCount: continuationByThreadId.size, + }); + } + yield* Effect.forEach(activeSessions, (session) => - Effect.flatMap(nowIso, (lastRuntimeEventAt) => - upsertSessionBinding(session, session.threadId, { - ...(continueAfterRestart && session.status === "running" && session.activeTurnId - ? { continueAfterServerUpdate: session.activeTurnId } - : {}), - lastRuntimeEvent: "provider.stopAll", - lastRuntimeEventAt, - }), - ), + upsertSessionBinding(session, session.threadId, { + ...(continueAfterRestart && session.status === "running" && session.activeTurnId + ? { continueAfterServerUpdate: session.activeTurnId } + : {}), + lastRuntimeEvent: "provider.stopAll", + lastRuntimeEventAt, + }), ).pipe(Effect.asVoid); - yield* Effect.forEach(currentAdapters, ([, adapter]) => adapter.stopAll()).pipe(Effect.asVoid); + + // Cooperative interrupt before hard session teardown so running provider + // turns receive cancel (tools stop, agents can settle). Sequence under ops + // SIGTERM reap (~150s): interrupt → interruptGrace (~30s) → stopAll (~60s). + const workingSessions = activeSessions.filter( + (session) => session.status === "connecting" || session.status === "running", + ); + if (workingSessions.length > 0) { + yield* Effect.logInfo("interrupting in-flight provider turns before stopAll", { + sessionCount: workingSessions.length, + }); + yield* Effect.forEach( + workingSessions, + (session) => + interruptTurn({ + threadId: session.threadId, + ...(session.activeTurnId !== null && session.activeTurnId !== undefined + ? { turnId: session.activeTurnId } + : {}), + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("provider interrupt during shutdown failed", { + threadId: session.threadId, + provider: session.provider, + cause: Cause.pretty(cause), + }), + ), + ), + { concurrency: "unbounded", discard: true }, + ); + + const interruptGrace = options?.shutdownInterruptGracePeriod ?? "30 seconds"; + yield* Effect.logInfo("waiting for cooperative interrupt grace before stopAll", { + interruptGrace: String(interruptGrace), + sessionCount: workingSessions.length, + }); + // Interruptible so a short process timeout can still abort shutdown. + yield* Effect.sleep(interruptGrace).pipe(Effect.interruptible); + } + + const stopAllGrace = options?.shutdownGracePeriod ?? "1 minute"; + const adapterStops = yield* Effect.forEach( + currentAdapters, + ([instanceId, adapter]) => + adapter.stopAll().pipe( + Effect.exit, + Effect.map((exit) => ({ instanceId, exit })), + ), + { concurrency: "unbounded" }, + ).pipe( + // Scope finalizers are uninterruptible by default. Restore + // interruptibility here so the timeout can release a provider whose + // protocol drain never completes. + Effect.interruptible, + Effect.timeoutOption(stopAllGrace), + ); + if (Option.isNone(adapterStops)) { + yield* Effect.logWarning("provider shutdown grace period elapsed", { + timeout: String(stopAllGrace), + sessionCount: activeSessions.length, + }); + } else { + yield* Effect.forEach( + adapterStops.value, + ({ instanceId, exit }) => + exit._tag === "Failure" + ? Effect.logWarning("provider adapter failed during shutdown", { instanceId }) + : Effect.void, + { discard: true }, + ); + } yield* McpSessionRegistry.revokeAllActiveMcpCredentials(); McpProviderSession.clearAllMcpProviderSessions(); const bindings = yield* directory.listBindings().pipe(Effect.orElseSucceed(() => [])); @@ -2307,6 +2612,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( sendTurn, compactThread, interruptTurn, + compactSession, respondToRequest, respondToUserInput, stopSession, diff --git a/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts b/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts index 2538e05e37dc..df4198759501 100644 --- a/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts +++ b/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts @@ -17,6 +17,7 @@ import * as Scope from "effect/Scope"; import * as Stream from "effect/Stream"; import { afterEach, describe, expect, it, vi } from "vite-plus/test"; +import { OrphanSessionRecovery } from "../../orchestration/Services/OrphanSessionRecovery.ts"; import { ProjectionSnapshotQuery } from "../../orchestration/Services/ProjectionSnapshotQuery.ts"; import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts"; import * as ProviderSessionRuntime from "../../persistence/ProviderSessionRuntime.ts"; @@ -110,6 +111,7 @@ function makeReadModel( hasActionableProposedPlan: false, latestTurn: null, messages: [], + queuedMessages: [], session: thread.session, backgroundLiveness: thread.backgroundLiveness ?? null, activities: [], @@ -178,6 +180,8 @@ describe("ProviderSessionReaper", () => { readonly stopSessionImplementation?: (input: { readonly threadId: ThreadId; }) => ReturnType; + readonly orphanHasLiveProcess?: boolean; + readonly onOrphanSettle?: (threadId: ThreadId) => void; }) { const stoppedThreadIds = new Set(); const stopSession = vi.fn( @@ -194,6 +198,7 @@ describe("ProviderSessionReaper", () => { sendTurn: () => unsupported(), compactThread: () => unsupported(), interruptTurn: () => unsupported(), + compactSession: () => unsupported(), respondToRequest: () => unsupported(), respondToUserInput: () => unsupported(), stopSession, @@ -231,6 +236,18 @@ describe("ProviderSessionReaper", () => { Layer.provideMerge(providerSessionDirectoryLayer), Layer.provideMerge(runtimeRepositoryLayer), Layer.provideMerge(Layer.succeed(ProviderService, providerService)), + Layer.provideMerge( + Layer.succeed(OrphanSessionRecovery, { + hasLiveProcess: () => Effect.succeed(input.orphanHasLiveProcess ?? true), + settleThread: (request) => + Effect.sync(() => { + input.onOrphanSettle?.(request.threadId); + }), + settleIfOrphan: () => Effect.succeed(false), + settleAllAfterServerRestart: () => + Effect.succeed({ settledSessions: 0, settledRuntimes: 0 }), + }), + ), Layer.provideMerge( Layer.succeed(ProjectionSnapshotQuery, { getUserInputActivity: () => Effect.die("unused"), @@ -247,6 +264,7 @@ describe("ProviderSessionReaper", () => { getFirstActiveThreadIdByProjectId: () => Effect.die("unused"), getImportedAgentSessionSources: () => Effect.die("unused"), getThreadCheckpointContext: () => Effect.die("unused"), + getSessionStopContextById: () => Effect.die("unused"), getFullThreadDiffContext: () => Effect.die("unused"), getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), @@ -259,6 +277,8 @@ describe("ProviderSessionReaper", () => { getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), }), ), Layer.provideMerge(NodeServices.layer), @@ -315,7 +335,7 @@ describe("ProviderSessionReaper", () => { expect(harness.stoppedThreadIds.has(threadId)).toBe(true); }); - it("skips stale sessions when the thread still has an active turn", async () => { + it("skips stale sessions when the thread still has an active turn and a live process", async () => { const threadId = ThreadId.make("thread-reaper-active-turn"); const turnId = TurnId.make("turn-reaper-active"); const now = "2026-01-01T00:00:00.000Z"; @@ -356,7 +376,7 @@ describe("ProviderSessionReaper", () => { ); await startReaper(); - await Effect.runPromise(drainFibers); + await runtime!.runPromise(drainFibers); expect(harness.stopSession).not.toHaveBeenCalled(); const remaining = await runtime!.runPromise(repository.getByThreadId({ threadId })); @@ -404,13 +424,68 @@ describe("ProviderSessionReaper", () => { ); await startReaper(); - await Effect.runPromise(drainFibers); + await runtime!.runPromise(drainFibers); expect(harness.stopSession).not.toHaveBeenCalled(); const remaining = await runtime!.runPromise(repository.getByThreadId({ threadId })); expect(Option.isSome(remaining)).toBe(true); }); + it("force-settles stale sessions with an active turn but no live process", async () => { + const threadId = ThreadId.make("thread-reaper-orphan-active-turn"); + const turnId = TurnId.make("turn-reaper-orphan"); + const now = "2026-01-01T00:00:00.000Z"; + const settled: ThreadId[] = []; + const harness = await createHarness({ + readModel: makeReadModel([ + { + id: threadId, + session: { + threadId, + status: "running", + providerName: "claudeAgent", + runtimeMode: "full-access", + activeTurnId: turnId, + lastError: null, + updatedAt: now, + }, + }, + ]), + orphanHasLiveProcess: false, + onOrphanSettle: (id) => { + settled.push(id); + }, + }); + const repository = await runtime!.runPromise( + Effect.service(ProviderSessionRuntime.ProviderSessionRuntimeRepository), + ); + + await runtime!.runPromise( + repository.upsert({ + threadId, + providerName: "claudeAgent", + providerInstanceId: null, + adapterKey: "claudeAgent", + runtimeMode: "full-access", + status: "running", + lastSeenAt: "2026-04-14T00:00:00.000Z", + resumeCursor: { + opaque: "resume-orphan-active-turn", + }, + runtimePayload: null, + }), + ); + + await startReaper(); + await waitFor(() => settled.length === 1); + + expect(settled).toEqual([threadId]); + // Harness still tracks stopSession for non-orphan path; orphan path uses recovery. + void harness; + const remaining = await runtime!.runPromise(repository.getByThreadId({ threadId })); + expect(Option.isSome(remaining)).toBe(true); + }); + it.each(["ready", "interrupted", "error"] as const)( "gives a long turn a full idle window after becoming %s", async (status) => { @@ -557,7 +632,7 @@ describe("ProviderSessionReaper", () => { ); await startReaper(); - await Effect.runPromise(drainFibers); + await runtime!.runPromise(drainFibers); expect(harness.stopSession).not.toHaveBeenCalled(); const remaining = await runtime!.runPromise(repository.getByThreadId({ threadId })); diff --git a/apps/server/src/provider/Layers/ProviderSessionReaper.ts b/apps/server/src/provider/Layers/ProviderSessionReaper.ts index 8f04bd1821fd..e0977cc428ed 100644 --- a/apps/server/src/provider/Layers/ProviderSessionReaper.ts +++ b/apps/server/src/provider/Layers/ProviderSessionReaper.ts @@ -5,6 +5,7 @@ import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Schedule from "effect/Schedule"; +import { OrphanSessionRecovery } from "../../orchestration/Services/OrphanSessionRecovery.ts"; import { ProjectionSnapshotQuery } from "../../orchestration/Services/ProjectionSnapshotQuery.ts"; import { ProviderSessionDirectory } from "../Services/ProviderSessionDirectory.ts"; import { @@ -27,6 +28,7 @@ const makeProviderSessionReaper = (options?: ProviderSessionReaperLiveOptions) = const providerService = yield* ProviderService; const directory = yield* ProviderSessionDirectory; const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; + const orphanSessionRecovery = yield* OrphanSessionRecovery; const inactivityThresholdMs = Math.max( 1, @@ -73,6 +75,38 @@ const makeProviderSessionReaper = (options?: ProviderSessionReaperLiveOptions) = continue; } if (thread?.session?.activeTurnId != null) { + // Active turns used to be skipped forever, which deadlocked zombies + // (process gone, activeTurnId still set). Force-settle when there is + // no live provider process. + const live = yield* orphanSessionRecovery.hasLiveProcess(binding.threadId); + if (!live) { + yield* orphanSessionRecovery + .settleThread({ + threadId: binding.threadId, + reason: "reaper_orphan_active_turn", + status: "interrupted", + }) + .pipe( + Effect.tap(() => + Effect.logInfo("provider.session.reaped", { + threadId: binding.threadId, + provider: binding.provider, + idleDurationMs, + reason: "orphan_active_turn", + }), + ), + Effect.catchCause((cause) => + Effect.logWarning("provider.session.reaper.orphan-settle-failed", { + threadId: binding.threadId, + provider: binding.provider, + idleDurationMs, + cause, + }), + ), + ); + reapedCount += 1; + continue; + } yield* Effect.logDebug("provider.session.reaper.skipped-active-turn", { threadId: binding.threadId, activeTurnId: thread.session.activeTurnId, diff --git a/apps/server/src/provider/ProviderRestartRecovery.test.ts b/apps/server/src/provider/ProviderRestartRecovery.test.ts new file mode 100644 index 000000000000..27eb34000572 --- /dev/null +++ b/apps/server/src/provider/ProviderRestartRecovery.test.ts @@ -0,0 +1,38 @@ +import { ModelSelection, ProviderInstanceId, TurnId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + readPersistedProviderActiveTurnId, + readPersistedProviderCwd, + readPersistedProviderInteractionMode, + readPersistedProviderModelSelection, +} from "./ProviderRestartRecovery.ts"; + +describe("ProviderRestartRecovery", () => { + it("reads persisted session fields from the runtime payload", () => { + const modelSelection: ModelSelection = { + instanceId: ProviderInstanceId.make("codex-work"), + model: "gpt-5.4", + options: [{ id: "reasoningEffort", value: "high" }], + }; + const runtimePayload = { + cwd: " /tmp/project ", + modelSelection, + interactionMode: "plan", + activeTurnId: TurnId.make("turn-live"), + }; + + expect(readPersistedProviderCwd(runtimePayload)).toBe("/tmp/project"); + expect(readPersistedProviderModelSelection(runtimePayload)).toEqual(modelSelection); + expect(readPersistedProviderInteractionMode(runtimePayload)).toBe("plan"); + expect(readPersistedProviderActiveTurnId(runtimePayload)).toBe(TurnId.make("turn-live")); + }); + + it("ignores missing or malformed payload fields", () => { + expect(readPersistedProviderCwd(null)).toBeUndefined(); + expect(readPersistedProviderCwd({ cwd: " " })).toBeUndefined(); + expect(readPersistedProviderModelSelection({})).toBeUndefined(); + expect(readPersistedProviderInteractionMode({ interactionMode: "nope" })).toBeUndefined(); + expect(readPersistedProviderActiveTurnId({ activeTurnId: null })).toBeUndefined(); + }); +}); diff --git a/apps/server/src/provider/ProviderRestartRecovery.ts b/apps/server/src/provider/ProviderRestartRecovery.ts new file mode 100644 index 000000000000..087bd60cae44 --- /dev/null +++ b/apps/server/src/provider/ProviderRestartRecovery.ts @@ -0,0 +1,41 @@ +import { ModelSelection, ProviderInteractionMode, TurnId } from "@t3tools/contracts"; +import * as Schema from "effect/Schema"; + +const isModelSelection = Schema.is(ModelSelection); +const isProviderInteractionMode = Schema.is(ProviderInteractionMode); +const isTurnId = Schema.is(TurnId); + +function isRecord(value: unknown): value is Record { + return value !== null && typeof value === "object" && !Array.isArray(value); +} + +export function readPersistedProviderCwd(runtimePayload: unknown): string | undefined { + if (!isRecord(runtimePayload)) return undefined; + const cwd = runtimePayload.cwd; + if (typeof cwd !== "string") return undefined; + const trimmed = cwd.trim(); + return trimmed.length > 0 ? trimmed : undefined; +} + +export function readPersistedProviderModelSelection( + runtimePayload: unknown, +): ModelSelection | undefined { + if (!isRecord(runtimePayload)) return undefined; + return isModelSelection(runtimePayload.modelSelection) + ? runtimePayload.modelSelection + : undefined; +} + +export function readPersistedProviderInteractionMode( + runtimePayload: unknown, +): ProviderInteractionMode | undefined { + if (!isRecord(runtimePayload)) return undefined; + return isProviderInteractionMode(runtimePayload.interactionMode) + ? runtimePayload.interactionMode + : undefined; +} + +export function readPersistedProviderActiveTurnId(runtimePayload: unknown): TurnId | undefined { + if (!isRecord(runtimePayload)) return undefined; + return isTurnId(runtimePayload.activeTurnId) ? runtimePayload.activeTurnId : undefined; +} diff --git a/apps/server/src/provider/Services/ProviderAdapter.ts b/apps/server/src/provider/Services/ProviderAdapter.ts index c9b62fd79525..4360d100f6ad 100644 --- a/apps/server/src/provider/Services/ProviderAdapter.ts +++ b/apps/server/src/provider/Services/ProviderAdapter.ts @@ -93,6 +93,12 @@ export interface ProviderAdapterShape { */ readonly interruptTurn: (threadId: ThreadId, turnId?: TurnId) => Effect.Effect; + /** + * Manually compact provider context for a session, when supported. + * Omit on adapters that only auto-compact or have no compact RPC. + */ + readonly compactSession?: (threadId: ThreadId) => Effect.Effect; + /** * Respond to an interactive approval request. */ diff --git a/apps/server/src/provider/Services/ProviderService.ts b/apps/server/src/provider/Services/ProviderService.ts index c189e2916ff1..d89dc69c9567 100644 --- a/apps/server/src/provider/Services/ProviderService.ts +++ b/apps/server/src/provider/Services/ProviderService.ts @@ -12,6 +12,7 @@ * @module ProviderService */ import type { + ProviderCompactSessionInput, ProviderInterruptTurnInput, ProviderInstanceId, ProviderRespondToRequestInput, @@ -67,6 +68,13 @@ export interface ProviderServiceShape { input: ProviderInterruptTurnInput, ) => Effect.Effect; + /** + * Manually compact provider context for a thread session. + */ + readonly compactSession: ( + input: ProviderCompactSessionInput, + ) => Effect.Effect; + /** * Respond to a provider approval request. */ diff --git a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts index cb9433b5bf4a..27c227b45d36 100644 --- a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts +++ b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts @@ -7,7 +7,10 @@ import { makeAcpPlanUpdatedEvent, makeAcpRequestOpenedEvent, makeAcpRequestResolvedEvent, + makeAcpTokenUsageUpdatedEvent, makeAcpToolCallEvent, + normalizeAcpPromptUsage, + normalizeAcpUsageUpdate, } from "./AcpCoreRuntimeEvents.ts"; describe("AcpCoreRuntimeEvents", () => { @@ -223,6 +226,62 @@ describe("AcpCoreRuntimeEvents", () => { }); }); + it("maps _meta.totalTokens-style usage updates without a window size", () => { + expect(normalizeAcpUsageUpdate({ used: 139_982 })).toEqual({ + usedTokens: 139_982, + lastUsedTokens: 139_982, + }); + expect(normalizeAcpUsageUpdate({ used: 42_000, size: 256_000 })).toEqual({ + usedTokens: 42_000, + lastUsedTokens: 42_000, + maxTokens: 256_000, + }); + expect(normalizeAcpUsageUpdate({ used: 0 })).toBeUndefined(); + }); + + it("maps ACP prompt usage to last in/out token fields", () => { + expect( + normalizeAcpPromptUsage({ + inputTokens: 1_000, + outputTokens: 400, + thoughtTokens: 100, + cachedReadTokens: 200, + totalTokens: 1_500, + }), + ).toEqual({ + usedTokens: 1_500, + lastUsedTokens: 1_500, + inputTokens: 1_000, + lastInputTokens: 1_000, + outputTokens: 400, + lastOutputTokens: 400, + reasoningOutputTokens: 100, + lastReasoningOutputTokens: 100, + cachedInputTokens: 200, + lastCachedInputTokens: 200, + }); + }); + + it("builds a thread.token-usage.updated runtime event", () => { + const stamp = { eventId: "event-1" as never, createdAt: "2026-03-27T00:00:00.000Z" }; + expect( + makeAcpTokenUsageUpdatedEvent({ + stamp, + provider: ProviderDriverKind.make("grok"), + threadId: "thread-1" as never, + turnId: TurnId.make("turn-1"), + usage: { usedTokens: 139_982, lastUsedTokens: 139_982 }, + method: "session/update", + rawPayload: { _meta: { totalTokens: 139_982 } }, + }), + ).toMatchObject({ + type: "thread.token-usage.updated", + payload: { + usage: { usedTokens: 139_982, lastUsedTokens: 139_982 }, + }, + }); + }); + it("maps thoughts to the reasoning stream", () => { expect( makeAcpContentDeltaEvent({ diff --git a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts index 79def1125305..83e696dcadf7 100644 --- a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts +++ b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts @@ -9,8 +9,10 @@ import { type ProviderRuntimeEvent, type RuntimeRequestId, type ThreadId, + type ThreadTokenUsageSnapshot, type TurnId, } from "@t3tools/contracts"; +import type * as EffectAcpSchema from "effect-acp/schema"; import { type AcpPermissionRequest, @@ -232,3 +234,100 @@ export function makeAcpContentDeltaEvent(input: { }, }; } + +function nonNegativeInt(value: unknown): number | undefined { + if (typeof value !== "number" || !Number.isFinite(value) || value < 0) { + return undefined; + } + return Math.round(value); +} + +/** + * Map ACP prompt-turn `Usage` (PromptResponse.usage / end-turn strawman) to T3's + * thread token snapshot. Prefer this for per-turn in/out stats. + */ +export function normalizeAcpPromptUsage( + usage: EffectAcpSchema.Usage | null | undefined, +): ThreadTokenUsageSnapshot | undefined { + if (usage === null || usage === undefined) { + return undefined; + } + + const inputTokens = nonNegativeInt(usage.inputTokens); + const outputTokens = nonNegativeInt(usage.outputTokens); + const thoughtTokens = nonNegativeInt(usage.thoughtTokens ?? undefined); + const cachedReadTokens = nonNegativeInt(usage.cachedReadTokens ?? undefined); + const totalTokens = nonNegativeInt(usage.totalTokens); + + const usedTokens = + totalTokens !== undefined && totalTokens > 0 + ? totalTokens + : (inputTokens ?? 0) + (outputTokens ?? 0) + (thoughtTokens ?? 0); + + if (usedTokens <= 0) { + return undefined; + } + + return { + usedTokens, + lastUsedTokens: usedTokens, + ...(inputTokens !== undefined ? { inputTokens, lastInputTokens: inputTokens } : {}), + ...(outputTokens !== undefined ? { outputTokens, lastOutputTokens: outputTokens } : {}), + ...(thoughtTokens !== undefined + ? { reasoningOutputTokens: thoughtTokens, lastReasoningOutputTokens: thoughtTokens } + : {}), + ...(cachedReadTokens !== undefined + ? { cachedInputTokens: cachedReadTokens, lastCachedInputTokens: cachedReadTokens } + : {}), + }; +} + +/** + * Map ACP `sessionUpdate: "usage_update"` (context window used/size) to a token snapshot. + * Does not include per-turn in/out — only context fill. + */ +export function normalizeAcpUsageUpdate(input: { + readonly used: number; + readonly size?: number; +}): ThreadTokenUsageSnapshot | undefined { + const usedTokens = nonNegativeInt(input.used); + const maxTokens = input.size === undefined ? undefined : nonNegativeInt(input.size); + if (usedTokens === undefined || usedTokens <= 0) { + return undefined; + } + return { + usedTokens, + lastUsedTokens: usedTokens, + ...(maxTokens !== undefined && maxTokens > 0 ? { maxTokens } : {}), + }; +} + +export function makeAcpTokenUsageUpdatedEvent(input: { + readonly stamp: AcpEventStamp; + readonly provider: ProviderDriverKind; + readonly threadId: ThreadId; + readonly turnId: TurnId | undefined; + readonly usage: ThreadTokenUsageSnapshot; + readonly method?: string; + readonly rawPayload?: unknown; +}): ProviderRuntimeEvent { + return { + type: "thread.token-usage.updated", + ...input.stamp, + provider: input.provider, + threadId: input.threadId, + turnId: input.turnId, + payload: { + usage: input.usage, + }, + ...(input.rawPayload === undefined + ? {} + : { + raw: { + source: "acp.jsonrpc" as const, + method: input.method ?? "session/update", + payload: input.rawPayload, + }, + }), + }; +} diff --git a/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts b/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts index 57323e2675e0..091243a4adf4 100644 --- a/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts +++ b/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts @@ -10,10 +10,13 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; import * as Fiber from "effect/Fiber"; +import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Scope from "effect/Scope"; +import * as Sink from "effect/Sink"; import * as TestClock from "effect/testing/TestClock"; import * as Stream from "effect/Stream"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; import { describe, expect } from "vite-plus/test"; import * as AcpSessionRuntime from "./AcpSessionRuntime.ts"; @@ -32,6 +35,57 @@ const mockRuntimeOptions = { } satisfies AcpSessionRuntime.AcpSessionRuntimeOptions; describe("AcpSessionRuntime", () => { + it.effect("passes an exact environment to the ACP child when extension is disabled", () => { + let spawnedCommand: unknown; + const spawner = ChildProcessSpawner.make((command) => { + spawnedCommand = command; + return Effect.succeed( + ChildProcessSpawner.makeHandle({ + pid: ChildProcessSpawner.ProcessId(1), + exitCode: Effect.never, + isRunning: Effect.succeed(true), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.drain, + stdout: Stream.never, + stderr: Stream.never, + all: Stream.never, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.never, + }), + ); + }); + const exactEnvironment = { PATH: "/project/bin", KEEP: "value" }; + + return Layer.build( + AcpSessionRuntime.layer({ + spawn: { + command: "/project/bin/agent", + args: ["acp"], + env: exactEnvironment, + extendEnv: false, + }, + cwd: "/project", + clientInfo: { name: "t3-test", version: "0.0.0" }, + authMethodId: "test", + }).pipe( + Layer.provide(Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner)), + Layer.provideMerge(NodeServices.layer), + ), + ).pipe( + Effect.tap(() => + Effect.sync(() => { + const command = spawnedCommand as { + readonly options: { readonly env?: NodeJS.ProcessEnv; readonly extendEnv?: boolean }; + }; + expect(command.options.env).toEqual(exactEnvironment); + expect(command.options.extendEnv).toBe(false); + }), + ), + Effect.scoped, + ); + }); + for (const setupMethod of ["session/new", "session/resume"] as const) { it.effect(`buffers root metadata while ${setupMethod} startup is still pending`, () => Effect.gen(function* () { @@ -552,9 +606,12 @@ describe("AcpSessionRuntime", () => { }); expect(promptResult).toMatchObject({ stopReason: "end_turn" }); - const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4))); - expect(notes).toHaveLength(4); - expect(notes.map((note) => note._tag)).toEqual([ + const notes = Array.from( + yield* Stream.runCollect( + Stream.takeUntil(runtime.getEvents(), (note) => note._tag === "AssistantItemCompleted"), + ), + ); + expect(notes.map((note) => note._tag).filter((tag) => tag !== "UsageUpdated")).toEqual([ "PlanUpdated", "AssistantItemStarted", "ContentDelta", @@ -938,6 +995,52 @@ describe("AcpSessionRuntime", () => { ); }); + it.effect("uses session/set_mode when the agent has no mode config option", () => { + const requestEvents: Array = []; + return Effect.gen(function* () { + const runtime = yield* AcpSessionRuntime.AcpSessionRuntime; + yield* runtime.start(); + + yield* runtime.setMode("architect"); + + const setModeRequest = requestEvents.find( + (event) => event.method === "session/set_mode" && event.status === "succeeded", + ); + expect(setModeRequest?.payload).toMatchObject({ + sessionId: "mock-session-1", + modeId: "architect", + }); + expect( + requestEvents.some( + (event) => + event.method === "session/set_config_option" && + (event.payload as { configId?: string } | undefined)?.configId === "mode", + ), + ).toBe(false); + + const modeState = yield* runtime.getModeState; + expect(modeState?.currentModeId).toBe("architect"); + }).pipe( + Effect.provide( + AcpSessionRuntime.layer({ + authMethodId: "test", + spawn: { + command: mockAgentCommand, + args: mockAgentArgs, + }, + cwd: process.cwd(), + clientInfo: { name: "t3-test", version: "0.0.0" }, + requestLogger: (event) => + Effect.sync(() => { + requestEvents.push(event); + }), + }), + ), + Effect.scoped, + Effect.provide(NodeServices.layer), + ); + }); + it.effect("emits low-level ACP protocol logs for raw and decoded messages", () => { const protocolEvents: Array = []; return Effect.gen(function* () { @@ -985,12 +1088,16 @@ describe("AcpSessionRuntime", () => { ); }); - it.effect("fails session startup when session/load returns an error", () => + it.effect("falls back to a fresh session when session/load fails", () => Effect.gen(function* () { const runtime = yield* AcpSessionRuntime.AcpSessionRuntime; - const error = yield* runtime.start().pipe(Effect.flip); + const started = yield* runtime.start(); - expect(error._tag).toBe("AcpRequestError"); + // session/load fails, but the resume is best-effort: startup recovers via + // session/new and yields the mock agent's fresh sessionId. This holds for + // any load failure (typed JSON-RPC errors and decode defects alike), + // matching how real agents reject a stale resume sessionId. + expect(started.sessionId).toBe("mock-session-1"); }).pipe( Effect.provide( AcpSessionRuntime.layer({ @@ -999,7 +1106,7 @@ describe("AcpSessionRuntime", () => { command: mockAgentCommand, args: mockAgentArgs, env: { - T3_ACP_FAIL_LOAD_SESSION: "1", + T3_ACP_FAIL_LOAD_SESSION_INVALID_PARAMS: "1", }, }, cwd: process.cwd(), @@ -1020,8 +1127,12 @@ describe("AcpSessionRuntime", () => { yield* runtime.prompt({ prompt: [{ type: "text", text: "hi" }], }); - const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4))); - expect(notes.map((note) => note._tag)).toEqual([ + const notes = Array.from( + yield* Stream.runCollect( + Stream.takeUntil(runtime.getEvents(), (note) => note._tag === "AssistantItemCompleted"), + ), + ); + expect(notes.map((note) => note._tag).filter((tag) => tag !== "UsageUpdated")).toEqual([ "PlanUpdated", "AssistantItemStarted", "ContentDelta", diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts index b5ee1708a902..4a8ab7d03289 100644 --- a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts +++ b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts @@ -337,6 +337,85 @@ describe("AcpRuntimeModel", () => { }, }, ]); + + const usageResult = parseSessionUpdateEvent({ + sessionId: "session-1", + update: { + sessionUpdate: "usage_update", + used: 53000, + size: 200000, + }, + } satisfies EffectAcpSchema.SessionNotification); + + expect(usageResult.events).toEqual([ + { + _tag: "UsageUpdated", + used: 53000, + size: 200000, + rawPayload: { + sessionId: "session-1", + update: { + sessionUpdate: "usage_update", + used: 53000, + size: 200000, + }, + }, + }, + ]); + + const grokMetaUsage = parseSessionUpdateEvent({ + sessionId: "session-1", + update: { + sessionUpdate: "agent_message_chunk", + content: { + type: "text", + text: "hello from grok", + }, + _meta: { + totalTokens: 139_982, + eventId: "evt-1", + }, + }, + } satisfies EffectAcpSchema.SessionNotification); + + expect(grokMetaUsage.events).toEqual([ + { + _tag: "ContentDelta", + text: "hello from grok", + rawPayload: { + sessionId: "session-1", + update: { + sessionUpdate: "agent_message_chunk", + content: { + type: "text", + text: "hello from grok", + }, + _meta: { + totalTokens: 139_982, + eventId: "evt-1", + }, + }, + }, + }, + { + _tag: "UsageUpdated", + used: 139_982, + rawPayload: { + sessionId: "session-1", + update: { + sessionUpdate: "agent_message_chunk", + content: { + type: "text", + text: "hello from grok", + }, + _meta: { + totalTokens: 139_982, + eventId: "evt-1", + }, + }, + }, + }, + ]); }); it("keeps thought chunks separate from assistant text", () => { diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.ts b/apps/server/src/provider/acp/AcpRuntimeModel.ts index 89c02dc7f949..c0145621736c 100644 --- a/apps/server/src/provider/acp/AcpRuntimeModel.ts +++ b/apps/server/src/provider/acp/AcpRuntimeModel.ts @@ -119,6 +119,14 @@ export type AcpParsedSessionEvent = readonly text: string; readonly rawPayload: unknown; } + | { + /** ACP `usage_update`, or `_meta.totalTokens` on ordinary session updates + * (Grok, Cursor, Kimi). */ + readonly _tag: "UsageUpdated"; + readonly used: number; + readonly size?: number; + readonly rawPayload: unknown; + } | { readonly _tag: "ThoughtDelta"; readonly text: string; @@ -869,6 +877,25 @@ export function parseSessionUpdateEvent(params: EffectAcpSchema.SessionNotificat } break; } + case "usage_update": { + const used = + typeof upd.used === "number" && Number.isFinite(upd.used) + ? Math.round(upd.used) + : undefined; + const size = + typeof upd.size === "number" && Number.isFinite(upd.size) + ? Math.round(upd.size) + : undefined; + if (used !== undefined && used >= 0 && size !== undefined && size > 0) { + events.push({ + _tag: "UsageUpdated", + used, + size, + rawPayload: params, + }); + } + break; + } case "agent_thought_chunk": { if (upd.content.type === "text" && upd.content.text.length > 0) { events.push({ @@ -883,5 +910,42 @@ export function parseSessionUpdateEvent(params: EffectAcpSchema.SessionNotificat break; } + appendUsageFromSessionMeta(params, events); + return { ...(modeId !== undefined ? { modeId } : {}), events }; } + +function totalTokensFromMeta(value: unknown): number | undefined { + if (!isRecord(value)) { + return undefined; + } + const totalTokens = value.totalTokens; + if (typeof totalTokens !== "number" || !Number.isFinite(totalTokens) || totalTokens <= 0) { + return undefined; + } + return Math.round(totalTokens); +} + +/** + * ACP agents may report a running total on `_meta.totalTokens` of ordinary + * session updates instead of (or as well as) `usage_update`. + */ +function appendUsageFromSessionMeta( + params: EffectAcpSchema.SessionNotification, + events: Array, +): void { + if (events.some((event) => event._tag === "UsageUpdated")) { + return; + } + const used = + totalTokensFromMeta(isRecord(params.update) ? params.update._meta : undefined) ?? + totalTokensFromMeta(params._meta); + if (used === undefined) { + return; + } + events.push({ + _tag: "UsageUpdated", + used, + rawPayload: params, + }); +} diff --git a/apps/server/src/provider/acp/AcpSessionRuntime.ts b/apps/server/src/provider/acp/AcpSessionRuntime.ts index b5894192eed9..4e44df63d867 100644 --- a/apps/server/src/provider/acp/AcpSessionRuntime.ts +++ b/apps/server/src/provider/acp/AcpSessionRuntime.ts @@ -1,3 +1,5 @@ +import * as NodeTimersPromises from "node:timers/promises"; + import * as Cause from "effect/Cause"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; @@ -49,11 +51,21 @@ function formatConfigOptionValue(value: string | boolean): string { return JSON.stringify(value); } +const summarizeSessionLoadFailure = (cause: Cause.Cause): string => + Cause.pretty(cause).split("\n")[0]?.trim().slice(0, 200) ?? "unknown"; + export interface AcpSessionEventStreamBarrier { readonly _tag: "EventStreamBarrier"; readonly acknowledge: Deferred.Deferred; } +export interface AcpSessionPromptOptions { + /** Deliver the prompt while a turn is still running instead of queueing behind it. */ + readonly steer?: boolean; + /** Settles once `session/prompt` is registered as the active prompt. */ + readonly dispatched?: Deferred.Deferred; +} + export type AcpSessionRuntimeEvent = | AcpParsedSessionEvent | AcpSessionEventStreamBarrier @@ -74,6 +86,7 @@ export interface AcpSpawnInput { readonly args: ReadonlyArray; readonly cwd?: string; readonly env?: NodeJS.ProcessEnv; + readonly forceKillAfter?: Duration.Input; readonly extendEnv?: boolean; } @@ -223,23 +236,36 @@ export class AcpSessionRuntime extends Context.Service< * Concurrent calls share the same in-flight startup and a failed startup may be retried. */ readonly start: () => Effect.Effect; + /** Resolves when the spawned ACP child exits. Process status read failures map to `undefined`. */ + readonly processExit: Effect.Effect; /** Stream of parsed root-session events and connection failures. */ readonly getEvents: () => Stream.Stream; - /** Waits for queued events to be processed, or for the runtime scope to close. */ + /** + * Waits until the live JSON-RPC reader has gone idle and the event consumer + * has processed every queued event. `session/prompt` (and Grok's + * `prompt_complete`) can resolve while trailing `session/update` lines are + * still in the stdout pipe or parser. + */ readonly drainEvents: Effect.Effect; /** Latest mode state observed from session setup and `session/update` notifications. */ readonly getModeState: Effect.Effect; /** Latest configuration options observed from session setup and configuration writes. */ readonly getConfigOptions: Effect.Effect>; /** - * Sends a prompt turn to the active session. `options.dispatched` settles once the - * `session/prompt` RPC is registered as the active prompt, so a caller that forks this - * effect knows when a later `cancel` will target this prompt. + * Sends a prompt turn to the active session. + * + * Prompts are serialized: a prompt waits for the preceding turn to settle + * before it reaches the agent. `steer: true` opts out of that wait so the + * prompt is delivered while a turn is still running — only meaningful for + * agents that accept mid-turn prompts (see `makeXAiPromptCompletionRuntime`). + * `options.dispatched` settles once the `session/prompt` RPC is registered as + * the active prompt, so a caller that forks this effect knows when a later + * `cancel` will target this prompt. * @see https://agentclientprotocol.com/protocol/schema#session/prompt */ readonly prompt: ( payload: Omit, - options?: { readonly dispatched?: Deferred.Deferred }, + options?: AcpSessionPromptOptions, ) => Effect.Effect; /** * Sends a real ACP `session/cancel` notification for the active session. @@ -358,6 +384,11 @@ export const make = ( const promptSerializationSemaphore = yield* Semaphore.make(1); const promptDispatchSemaphore = yield* Semaphore.make(1); const activePromptRef = yield* Ref.make>(Option.none()); + // A steering prompt runs alongside the turn it interrupts, so more than one + // prompt fiber can be in flight; `cancel` has to reach all of them. + const activePromptFibersRef = yield* Ref.make< + ReadonlyArray> + >([]); const sessionLoadGateRef = yield* Ref.make>(Option.none()); const ensureConnected = Effect.gen(function* () { @@ -435,6 +466,7 @@ export const make = ( ...(options.spawn.cwd ? { cwd: options.spawn.cwd } : {}), ...(options.spawn.env ? { env: options.spawn.env } : {}), extendEnv: options.spawn.extendEnv ?? true, + ...(options.spawn.forceKillAfter ? { forceKillAfter: options.spawn.forceKillAfter } : {}), shell: spawnCommand.shell, }), ) @@ -714,6 +746,28 @@ export const make = ( | EffectAcpSchema.LoadSessionResponse | EffectAcpSchema.NewSessionResponse | EffectAcpSchema.ResumeSessionResponse; + + const createSession = (): Effect.Effect< + { + readonly sessionId: string; + readonly result: EffectAcpSchema.NewSessionResponse; + }, + EffectAcpErrors.AcpError + > => { + const createPayload = { + cwd: options.cwd, + mcpServers: options.mcpServers ?? [], + ...(options.additionalDirectories && options.additionalDirectories.length > 0 + ? { additionalDirectories: options.additionalDirectories } + : {}), + } satisfies EffectAcpSchema.NewSessionRequest; + return runLoggedRequest( + "session/new", + createPayload, + acp.agent.createSession(createPayload), + ).pipe(Effect.map((created) => ({ sessionId: created.sessionId, result: created }))); + }; + if (options.resumeSessionId && options.resumeMethod === "resume") { if (!initializeResult.agentCapabilities?.sessionCapabilities?.resume) { return yield* new EffectAcpErrors.AcpTransportError({ @@ -751,8 +805,9 @@ export const make = ( ), ); } else if (options.resumeSessionId) { + const resumeSessionId = options.resumeSessionId; const loadPayload = { - sessionId: options.resumeSessionId, + sessionId: resumeSessionId, cwd: options.cwd, mcpServers: options.mcpServers ?? [], } satisfies EffectAcpSchema.LoadSessionRequest; @@ -773,8 +828,7 @@ export const make = ( }), ); - sessionId = options.resumeSessionId; - sessionSetupResult = yield* Effect.gen(function* () { + const loaded = yield* Effect.gen(function* () { yield* logRequest({ method: "session/load", payload: loadPayload, @@ -823,22 +877,38 @@ export const make = ( ); return loaded; - }).pipe(Effect.ensuring(Ref.set(sessionLoadGateRef, Option.none()))); - } else { - const createPayload = { - cwd: options.cwd, - mcpServers: options.mcpServers ?? [], - ...(options.additionalDirectories && options.additionalDirectories.length > 0 - ? { additionalDirectories: options.additionalDirectories } - : {}), - } satisfies EffectAcpSchema.NewSessionRequest; - const created = yield* runLoggedRequest( - "session/new", - createPayload, - acp.agent.createSession(createPayload), + }).pipe( + Effect.ensuring(Ref.set(sessionLoadGateRef, Option.none())), + Effect.sandbox, + // `session/load` is a best-effort resume of the agent's in-memory + // context. If it fails for ANY reason — the agent rejected the stale + // sessionId (some agents throw a decode defect rather than returning a + // clean JSON-RPC error), a protocol mismatch, or a transport blip — + // recover with a fresh session instead of bricking the thread on every + // turn. The transcript stays intact in the orchestration store; only + // the agent's working context is lost. Genuine infrastructure failures + // (dead process, bad cwd) resurface when `createSession` fails too. + Effect.matchEffect({ + onFailure: (cause) => + Effect.gen(function* () { + yield* Effect.logWarning( + "ACP session/load failed to resume the persisted sessionId; starting a fresh session.", + { + resumeSessionId, + failure: summarizeSessionLoadFailure(cause), + }, + ); + return yield* createSession(); + }), + onSuccess: (result) => Effect.succeed({ sessionId: resumeSessionId, result }), + }), ); + sessionId = loaded.sessionId; + sessionSetupResult = loaded.result; + } else { + const created = yield* createSession(); sessionId = created.sessionId; - sessionSetupResult = created; + sessionSetupResult = created.result; } yield* Ref.set(modeStateRef, parseSessionModeState(sessionSetupResult)); @@ -904,9 +974,26 @@ export const make = ( if (yield* Ref.get(stoppingRef)) { return; } - const acknowledge = yield* Deferred.make(); - yield* Queue.offer(eventQueue, { _tag: "EventStreamBarrier", acknowledge }); - yield* Effect.raceFirst(Deferred.await(acknowledge), Deferred.await(runtimeClosed)); + const drainQueued = Effect.gen(function* () { + const acknowledge = yield* Deferred.make(); + yield* Queue.offer(eventQueue, { _tag: "EventStreamBarrier", acknowledge }); + yield* Effect.raceFirst(Deferred.await(acknowledge), Deferred.await(runtimeClosed)); + }); + // Pump Node I/O (stdout callbacks) and the Effect scheduler until a + // cycle sees an empty queue. One barrier is not enough: prompt_complete + // can settle before the next agent_message_chunk in the same burst. + const maxCycles = 16; + for (let cycle = 0; cycle < maxCycles; cycle += 1) { + yield* Effect.promise(() => NodeTimersPromises.setImmediate()); + for (let yieldAttempt = 0; yieldAttempt < 4; yieldAttempt += 1) { + yield* Effect.yieldNow; + } + const queued = yield* Queue.size(eventQueue); + yield* drainQueued; + if (cycle > 0 && queued === 0) { + return; + } + } }); const retireRuntime = Effect.fn("AcpSessionRuntime.retireRuntime")(function* ( @@ -920,9 +1007,12 @@ export const make = ( const started = yield* getStartedState; const activePrompt = yield* Ref.get(activePromptRef); if (options.cancelBehavior !== "wait-for-prompt") { - if (Option.isSome(activePrompt)) { - yield* Fiber.interrupt(activePrompt.value.fiber).pipe(Effect.ignore); - } + const activePromptFibers = yield* Ref.get(activePromptFibersRef); + yield* Effect.forEach( + activePromptFibers, + (fiber) => Fiber.interrupt(fiber).pipe(Effect.ignore), + { concurrency: "unbounded", discard: true }, + ); // Write cancel before a replacement prompt can reach the agent. yield* acp.agent.cancel({ sessionId: started.sessionId }).pipe(Effect.ignore); return; @@ -973,85 +1063,118 @@ export const make = ( handleExtNotification: acp.handleExtNotification, initialize: () => ensureConnected.pipe(Effect.andThen(sendInitialize)), start: () => start, + processExit: child.exitCode.pipe( + Effect.map(Number), + Effect.catchCause(() => Effect.void.pipe(Effect.as(undefined))), + ), getEvents: () => Stream.fromQueue(eventQueue), drainEvents, getModeState: Ref.get(modeStateRef), getConfigOptions: Ref.get(configOptionsRef), - prompt: (payload, promptOptions?) => - promptSerializationSemaphore.withPermit( - Effect.acquireUseRelease( - promptDispatchSemaphore.withPermit( - Effect.gen(function* () { - const started = yield* getStartedState; - yield* closeActiveAssistantSegment({ queue: eventQueue, assistantSegmentRef }); - const requestPayload = { - sessionId: started.sessionId, - ...payload, - } satisfies EffectAcpSchema.PromptRequest; - const completed = yield* Deferred.make(); - const fiber = yield* runLoggedRequest( - "session/prompt", - requestPayload, - acp.agent.prompt(requestPayload), - ).pipe(Effect.forkIn(runtimeScope)); - const active = { fiber, completed } satisfies AcpActivePrompt; - yield* Ref.set(activePromptRef, Option.some(active)); - if (promptOptions?.dispatched) { - yield* Deferred.succeed(promptOptions.dispatched, undefined); - } - return active; - }), - ), - (activePrompt) => - Fiber.join(activePrompt.fiber).pipe( - Effect.catchCause((cause) => - options.cancelBehavior !== "wait-for-prompt" && Cause.hasInterruptsOnly(cause) - ? Effect.succeed({ - stopReason: "cancelled", - } satisfies EffectAcpSchema.PromptResponse) - : Effect.failCause(cause), - ), - Effect.tap(() => - closeActiveAssistantSegment({ queue: eventQueue, assistantSegmentRef }), - ), - ), - (activePrompt, result) => - Effect.gen(function* () { - if ( - options.cancelBehavior === "wait-for-prompt" && - Exit.isFailure(result) && - Cause.hasInterrupts(result.cause) - ) { - yield* retireRuntime( - new EffectAcpErrors.AcpTransportError({ - method: "session/prompt", - detail: "The ACP prompt stopped before the agent confirmed completion.", - cause: undefined, - }), - ); - } - yield* Fiber.interrupt(activePrompt.fiber).pipe(Effect.ignore); - yield* Ref.set(activePromptRef, Option.none()); - yield* Deferred.succeed(activePrompt.completed, undefined); - }), + prompt: (payload, promptOptions?) => { + const sendPrompt = Effect.acquireUseRelease( + promptDispatchSemaphore.withPermit( + Effect.gen(function* () { + const started = yield* getStartedState; + yield* closeActiveAssistantSegment({ queue: eventQueue, assistantSegmentRef }); + const requestPayload = { + sessionId: started.sessionId, + ...payload, + } satisfies EffectAcpSchema.PromptRequest; + const completed = yield* Deferred.make(); + const fiber = yield* runLoggedRequest( + "session/prompt", + requestPayload, + acp.agent.prompt(requestPayload), + ).pipe(Effect.forkIn(runtimeScope)); + const active = { fiber, completed } satisfies AcpActivePrompt; + yield* Ref.set(activePromptRef, Option.some(active)); + yield* Ref.update(activePromptFibersRef, (fibers) => [...fibers, fiber]); + if (promptOptions?.dispatched) { + yield* Deferred.succeed(promptOptions.dispatched, undefined); + } + return active; + }), ), - ), + (activePrompt) => + Fiber.join(activePrompt.fiber).pipe( + Effect.catchCause((cause) => + options.cancelBehavior !== "wait-for-prompt" && Cause.hasInterruptsOnly(cause) + ? Effect.succeed({ + stopReason: "cancelled", + } satisfies EffectAcpSchema.PromptResponse) + : Effect.failCause(cause), + ), + Effect.tap(() => + closeActiveAssistantSegment({ queue: eventQueue, assistantSegmentRef }), + ), + ), + (activePrompt, result) => + Effect.gen(function* () { + if ( + options.cancelBehavior === "wait-for-prompt" && + Exit.isFailure(result) && + Cause.hasInterrupts(result.cause) + ) { + yield* retireRuntime( + new EffectAcpErrors.AcpTransportError({ + method: "session/prompt", + detail: "The ACP prompt stopped before the agent confirmed completion.", + cause: undefined, + }), + ); + } + yield* Fiber.interrupt(activePrompt.fiber).pipe(Effect.ignore); + yield* Ref.update(activePromptFibersRef, (fibers) => + fibers.filter((fiber) => fiber !== activePrompt.fiber), + ); + yield* Ref.set(activePromptRef, Option.none()); + yield* Deferred.succeed(activePrompt.completed, undefined); + }), + ); + // A steer must reach the agent while the turn it interrupts still runs, + // so it deliberately skips the serialization permit. + return promptOptions?.steer === true + ? sendPrompt + : promptSerializationSemaphore.withPermit(sendPrompt); + }, cancel: options.cancelBehavior === "wait-for-prompt" ? promptDispatchSemaphore.withPermit(cancel) : cancel, setMode: (modeId) => - Ref.get(modeStateRef).pipe( - Effect.flatMap((modeState) => { - if (modeState?.currentModeId === modeId) { - return Effect.succeed({} satisfies EffectAcpSchema.SetSessionModeResponse); - } - return setConfigOption("mode", modeId).pipe( - Effect.tap(() => updateCurrentModeId(modeId)), - Effect.as({} satisfies EffectAcpSchema.SetSessionModeResponse), - ); - }), - ), + Effect.gen(function* () { + const normalizedModeId = modeId.trim(); + if (!normalizedModeId) { + return {} satisfies EffectAcpSchema.SetSessionModeResponse; + } + const modeState = yield* Ref.get(modeStateRef); + if (modeState?.currentModeId === normalizedModeId) { + return {} satisfies EffectAcpSchema.SetSessionModeResponse; + } + const started = yield* getStartedState; + const requestPayload = { + sessionId: started.sessionId, + modeId: normalizedModeId, + } satisfies EffectAcpSchema.SetSessionModeRequest; + return yield* runLoggedRequest( + "session/set_mode", + requestPayload, + acp.agent.setSessionMode(requestPayload), + ).pipe( + Effect.tap(() => updateCurrentModeId(normalizedModeId)), + Effect.as({} satisfies EffectAcpSchema.SetSessionModeResponse), + Effect.catch((error) => { + if (error._tag === "AcpRequestError" && error.code === -32601) { + return setConfigOption("mode", normalizedModeId).pipe( + Effect.tap(() => updateCurrentModeId(normalizedModeId)), + Effect.as({} satisfies EffectAcpSchema.SetSessionModeResponse), + ); + } + return Effect.fail(error); + }), + ); + }), setConfigOption, setModel: (model) => getStartedState.pipe( @@ -1228,7 +1351,7 @@ function updateModeState(modeState: AcpSessionModeState, nextModeId: string): Ac : modeState; } -const assistantItemId = (sessionId: string, runtimeId: string, segmentIndex: number) => +export const assistantItemId = (sessionId: string, runtimeId: string, segmentIndex: number) => `assistant:${sessionId}:runtime:${runtimeId}:segment:${segmentIndex}`; const ensureActiveAssistantSegment = ({ diff --git a/apps/server/src/provider/acp/CursorAcpSupport.test.ts b/apps/server/src/provider/acp/CursorAcpSupport.test.ts index 93c1da9c5884..9a6e58d8dc9c 100644 --- a/apps/server/src/provider/acp/CursorAcpSupport.test.ts +++ b/apps/server/src/provider/acp/CursorAcpSupport.test.ts @@ -75,6 +75,21 @@ describe("buildCursorAcpSpawnInput", () => { }); }); + it("uses a complete non-extending environment when one is supplied", () => { + expect( + buildCursorAcpSpawnInput(undefined, "/tmp/project", { + PATH: "/project/bin", + KEEP: "value", + }), + ).toEqual({ + command: "cursor-agent", + args: ["acp"], + cwd: "/tmp/project", + env: { PATH: "/project/bin", KEEP: "value" }, + extendEnv: false, + }); + }); + it("forces approval in full-access mode", () => { expect(buildCursorAcpSpawnInput(undefined, "/tmp/project", undefined, "full-access")).toEqual({ command: "cursor-agent", diff --git a/apps/server/src/provider/acp/CursorAcpSupport.ts b/apps/server/src/provider/acp/CursorAcpSupport.ts index e3f741d34260..64abd367cd5a 100644 --- a/apps/server/src/provider/acp/CursorAcpSupport.ts +++ b/apps/server/src/provider/acp/CursorAcpSupport.ts @@ -60,7 +60,7 @@ export function buildCursorAcpSpawnInput( "acp", ], cwd, - ...(environment ? { env: environment } : {}), + ...(environment ? { env: environment, extendEnv: false } : {}), }; } diff --git a/apps/server/src/provider/acp/GrokAcpSupport.test.ts b/apps/server/src/provider/acp/GrokAcpSupport.test.ts index 3f64128c5849..3c443cf80b09 100644 --- a/apps/server/src/provider/acp/GrokAcpSupport.test.ts +++ b/apps/server/src/provider/acp/GrokAcpSupport.test.ts @@ -8,12 +8,14 @@ import { grokAcpSpawnArgs, isValidGrokReasoningEffortToken, resolveGrokAcpBaseModelId, + resolveGrokReasoningEffortSelection, + resolveGrokRequestedModeId, } from "./GrokAcpSupport.ts"; describe("resolveGrokAcpBaseModelId", () => { it("normalizes empty and custom Grok model ids", () => { - expect(resolveGrokAcpBaseModelId(undefined)).toBe("grok-build"); - expect(resolveGrokAcpBaseModelId(" ")).toBe("grok-build"); + expect(resolveGrokAcpBaseModelId(undefined)).toBe("grok-4.6"); + expect(resolveGrokAcpBaseModelId(" ")).toBe("grok-4.6"); expect(resolveGrokAcpBaseModelId(" grok-test-custom-model ")).toBe("grok-test-custom-model"); }); }); @@ -62,9 +64,36 @@ describe("buildGrokAcpSpawnInput", () => { XAI_API_KEY: "secret", GROK_OAUTH2_REFERRER: "t3code", }, + extendEnv: false, }); }); + it("forwards reasoning effort as a process-level agent flag", () => { + const spawn = buildGrokAcpSpawnInput( + { binaryPath: "grok" }, + "/tmp/project", + undefined, + undefined, + { + reasoningEffort: "medium", + }, + ); + expect(spawn.args).toEqual(["agent", "--reasoning-effort", "medium", "stdio"]); + }); + + it("ignores unknown effort values on spawn", () => { + const spawn = buildGrokAcpSpawnInput( + { binaryPath: "grok" }, + "/tmp/project", + undefined, + undefined, + { + reasoningEffort: "turbo", + }, + ); + expect(spawn.args).toEqual(["agent", "stdio"]); + }); + it("puts Supervised on the Grok argv so config always-approve cannot win", () => { const spawn = buildGrokAcpSpawnInput( { binaryPath: "/usr/local/bin/grok" }, @@ -238,3 +267,23 @@ describe("applyGrokAcpModelSelection", () => { }), ); }); + +describe("resolveGrokReasoningEffortSelection", () => { + it("reads reasoningEffort and effort option ids", () => { + expect(resolveGrokReasoningEffortSelection([{ id: "reasoningEffort", value: "High" }])).toBe( + "high", + ); + expect(resolveGrokReasoningEffortSelection([{ id: "effort", value: "low" }])).toBe("low"); + expect(resolveGrokReasoningEffortSelection([{ id: "reasoningEffort", value: "nope" }])).toBe( + undefined, + ); + }); +}); + +describe("resolveGrokRequestedModeId", () => { + it("pins Build and unset to agent; Plan to plan; never ask", () => { + expect(resolveGrokRequestedModeId("plan")).toBe("plan"); + expect(resolveGrokRequestedModeId("default")).toBe("agent"); + expect(resolveGrokRequestedModeId(undefined)).toBe("agent"); + }); +}); diff --git a/apps/server/src/provider/acp/GrokAcpSupport.ts b/apps/server/src/provider/acp/GrokAcpSupport.ts index e35003835269..c7a4bcb1b7ec 100644 --- a/apps/server/src/provider/acp/GrokAcpSupport.ts +++ b/apps/server/src/provider/acp/GrokAcpSupport.ts @@ -1,4 +1,17 @@ -import { type GrokSettings, ProviderDriverKind, type RuntimeMode } from "@t3tools/contracts"; +import { + GROK_DEFAULT_MODEL, + type GrokSettings, + type ModelSelection, + type ProviderInteractionMode, + type ProviderOptionSelection, + ProviderDriverKind, + type RuntimeMode, +} from "@t3tools/contracts"; +import { + getModelSelectionStringOptionValue, + getProviderOptionStringSelectionValue, + normalizeModelSlug, +} from "@t3tools/shared/model"; import * as Crypto from "effect/Crypto"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; @@ -6,11 +19,15 @@ import * as Scope from "effect/Scope"; import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; import * as EffectAcpErrors from "effect-acp/errors"; import type * as EffectAcpSchema from "effect-acp/schema"; -import { normalizeModelSlug } from "@t3tools/shared/model"; import * as AcpSessionRuntime from "./AcpSessionRuntime.ts"; import { makeXAiPromptCompletionRuntime } from "./XAiAcpExtension.ts"; +/** Preferred Grok ACP mode when the T3 thread is in Plan. */ +export const GROK_PLAN_MODE_ID = "plan"; +/** Preferred Grok ACP mode when the T3 thread is in Build (default). */ +export const GROK_AGENT_MODE_ID = "agent"; + const GROK_API_KEY_ENV = "XAI_API_KEY"; const GROK_OAUTH2_REFERRER_ENV = "GROK_OAUTH2_REFERRER"; const T3_CODE_OAUTH_REFERRER = "t3code"; @@ -18,6 +35,19 @@ const GROK_AUTH_METHOD_API_KEY = "xai.api_key"; const GROK_AUTH_METHOD_CACHED_TOKEN = "cached_token"; const GROK_DRIVER_KIND = ProviderDriverKind.make("grok"); +/** Grok ACP applies reasoning effort through `session/set_mode` mode ids. */ +const GROK_REASONING_EFFORT_MODE_IDS = new Set([ + "none", + "minimal", + "low", + "medium", + "high", + "xhigh", + "max", +]); + +export const GROK_REASONING_EFFORT_OPTION_ID = "reasoningEffort"; + type GrokAcpRuntimeGrokSettings = Pick; interface GrokAcpRuntimeInput extends Omit< @@ -28,6 +58,8 @@ interface GrokAcpRuntimeInput extends Omit< readonly grokSettings: GrokAcpRuntimeGrokSettings | null | undefined; readonly environment?: NodeJS.ProcessEnv; readonly runtimeMode?: RuntimeMode; + /** Optional process-level default applied via `grok agent --reasoning-effort`. */ + readonly reasoningEffort?: string | null | undefined; } export function grokAcpSpawnArgs(runtimeMode?: RuntimeMode): ReadonlyArray { @@ -45,20 +77,75 @@ export function grokAcpSpawnArgs(runtimeMode?: RuntimeMode): ReadonlyArray, + reasoningEffort?: string | null, +): ReadonlyArray { + const effort = reasoningEffort?.trim().toLowerCase(); + if (!effort || !GROK_REASONING_EFFORT_MODE_IDS.has(effort)) { + return args; + } + const agentIndex = args.indexOf("agent"); + if (agentIndex === -1) { + return [...args, "--reasoning-effort", effort]; + } + return [ + ...args.slice(0, agentIndex + 1), + "--reasoning-effort", + effort, + ...args.slice(agentIndex + 1), + ]; +} + +export function resolveGrokReasoningEffortSelection( + selections: ReadonlyArray | null | undefined, +): string | undefined { + const fromReasoning = getProviderOptionStringSelectionValue( + selections, + GROK_REASONING_EFFORT_OPTION_ID, + ); + const raw = fromReasoning ?? getProviderOptionStringSelectionValue(selections, "effort"); + const trimmed = raw?.trim().toLowerCase(); + if (!trimmed || !GROK_REASONING_EFFORT_MODE_IDS.has(trimmed)) { + return undefined; + } + return trimmed; +} + +export function resolveGrokReasoningEffortFromModelSelection( + modelSelection: ModelSelection | null | undefined, +): string | undefined { + if (!modelSelection) { + return undefined; + } + const raw = + getModelSelectionStringOptionValue(modelSelection, GROK_REASONING_EFFORT_OPTION_ID) ?? + getModelSelectionStringOptionValue(modelSelection, "effort"); + const trimmed = raw?.trim().toLowerCase(); + if (!trimmed || !GROK_REASONING_EFFORT_MODE_IDS.has(trimmed)) { + return undefined; + } + return trimmed; +} + export function buildGrokAcpSpawnInput( grokSettings: GrokAcpRuntimeGrokSettings | null | undefined, cwd: string, environment?: NodeJS.ProcessEnv, runtimeMode?: RuntimeMode, + options?: { + readonly reasoningEffort?: string | null | undefined; + }, ): AcpSessionRuntime.AcpSpawnInput { return { command: grokSettings?.binaryPath || "grok", - args: [...grokAcpSpawnArgs(runtimeMode)], + args: withReasoningEffort(grokAcpSpawnArgs(runtimeMode), options?.reasoningEffort), cwd, env: { ...environment, [GROK_OAUTH2_REFERRER_ENV]: T3_CODE_OAUTH_REFERRER, }, + ...(environment ? { extendEnv: false } : {}), }; } @@ -84,6 +171,7 @@ export const makeGrokAcpRuntime = ( input.cwd, input.environment, input.runtimeMode, + { reasoningEffort: input.reasoningEffort }, ), authMethodId: resolveGrokAuthMethodId(input.environment), }).pipe( @@ -106,8 +194,8 @@ export const GROK_DEFAULT_MODEL_SLUG = "grok-build"; export function resolveGrokAcpBaseModelId(model: string | null | undefined): string { const trimmed = model?.trim(); - const base = trimmed && trimmed.length > 0 ? trimmed : GROK_DEFAULT_MODEL_SLUG; - return normalizeModelSlug(base, GROK_DRIVER_KIND) ?? GROK_DEFAULT_MODEL_SLUG; + const base = trimmed && trimmed.length > 0 ? trimmed : GROK_DEFAULT_MODEL; + return normalizeModelSlug(base, GROK_DRIVER_KIND) ?? GROK_DEFAULT_MODEL; } const GROK_REASONING_EFFORT_TOKEN = /^[a-z0-9][a-z0-9._-]{0,31}$/i; @@ -186,3 +274,25 @@ export function applyGrokAcpModelSelection(input: { .setSessionModel(targetModelId, reasoningMeta) .pipe(Effect.mapError(input.mapError), Effect.as(targetModelId)); } + +/** + * Maps T3 interaction mode onto Grok ACP session modes. + * Build/default/unset always targets agent mode; Plan targets plan mode. + * Never selects ask mode — that was leaving Grok read-only/approval-heavy in Build. + * + * Kept in lockstep with `resolveGrokAcpModeIdForInteractionMode` in GrokPlanMode. + */ +export function resolveGrokRequestedModeId( + interactionMode: ProviderInteractionMode | undefined, +): string { + return interactionMode === "plan" ? GROK_PLAN_MODE_ID : GROK_AGENT_MODE_ID; +} + +export function applyGrokAcpSessionMode(input: { + readonly runtime: Pick; + readonly interactionMode: ProviderInteractionMode | undefined; + readonly mapError: (cause: EffectAcpErrors.AcpError) => E; +}): Effect.Effect { + const modeId = resolveGrokRequestedModeId(input.interactionMode); + return input.runtime.setMode(modeId).pipe(Effect.mapError(input.mapError), Effect.as(modeId)); +} diff --git a/apps/server/src/provider/acp/GrokPlanMode.test.ts b/apps/server/src/provider/acp/GrokPlanMode.test.ts new file mode 100644 index 000000000000..3fb80865433d --- /dev/null +++ b/apps/server/src/provider/acp/GrokPlanMode.test.ts @@ -0,0 +1,81 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + extractGrokPlanMarkdownFromToolWrite, + interactionModeFromGrokAcpModeId, + isGrokExitPlanModePermission, + resolveGrokAcpModeIdForInteractionMode, + resolveGrokSessionPlanMarkdownPath, +} from "./GrokPlanMode.ts"; + +describe("GrokPlanMode", () => { + it("maps Grok ACP mode ids onto app interaction modes", () => { + expect(interactionModeFromGrokAcpModeId("plan")).toBe("plan"); + expect(interactionModeFromGrokAcpModeId("Architect")).toBe("plan"); + expect(interactionModeFromGrokAcpModeId("default")).toBe("default"); + expect(interactionModeFromGrokAcpModeId("code")).toBe("default"); + expect(interactionModeFromGrokAcpModeId("agent")).toBe("default"); + expect(interactionModeFromGrokAcpModeId("high")).toBeUndefined(); + }); + + it("resolves interaction modes back to Grok ACP mode ids", () => { + expect(resolveGrokAcpModeIdForInteractionMode("plan")).toBe("plan"); + expect(resolveGrokAcpModeIdForInteractionMode("default")).toBe("agent"); + // Unset must still leave ask — Build threads often omit interactionMode. + expect(resolveGrokAcpModeIdForInteractionMode(undefined)).toBe("agent"); + }); + + it("detects exit_plan_mode permission requests from real Grok payloads", () => { + expect( + isGrokExitPlanModePermission({ + sessionId: "s1", + toolCall: { + toolCallId: "t1", + title: "Plan: Exit", + rawInput: { variant: "ExitPlanMode" }, + _meta: { + "x.ai/tool": { + name: "exit_plan_mode", + kind: "exit_plan", + }, + }, + }, + options: [], + }), + ).toBe(true); + + expect( + isGrokExitPlanModePermission({ + sessionId: "s1", + toolCall: { + toolCallId: "t2", + title: "run_terminal_command", + rawInput: { command: "ls" }, + }, + options: [], + }), + ).toBe(false); + }); + + it("extracts plan markdown from plan.md write tool payloads", () => { + const markdown = extractGrokPlanMarkdownFromToolWrite({ + title: "write", + rawInput: { + file_path: + "/home/user/.grok/sessions/%2Ftmp%2Fproject/019f5d24-302d-74f0-917f-56a954f98e49/plan.md", + content: "# Plan\n\n- step one\n", + }, + }); + expect(markdown).toBe("# Plan\n\n- step one\n"); + }); + + it("builds the on-disk plan.md path for a Grok session", () => { + expect( + resolveGrokSessionPlanMarkdownPath({ + homeDir: "/home/user", + cwd: "/tmp/project", + sessionId: "session-1", + }), + ).toBe("/home/user/.grok/sessions/%2Ftmp%2Fproject/session-1/plan.md"); + }); +}); diff --git a/apps/server/src/provider/acp/GrokPlanMode.ts b/apps/server/src/provider/acp/GrokPlanMode.ts new file mode 100644 index 000000000000..c0c7608e6fef --- /dev/null +++ b/apps/server/src/provider/acp/GrokPlanMode.ts @@ -0,0 +1,163 @@ +import type { ProviderInteractionMode } from "@t3tools/contracts"; +import type * as EffectAcpSchema from "effect-acp/schema"; + +const GROK_PLAN_MODE_ALIASES = ["plan", "architect"] as const; +const GROK_DEFAULT_MODE_ALIASES = [ + "default", + "code", + "agent", + "build", + "normal", + "ask", + "implement", + "chat", +] as const; + +function normalizeModeId(modeId: string): string { + return modeId.trim().toLowerCase(); +} + +/** + * Maps a Grok/ACP session mode id onto T3's app-level interaction mode. + * Returns undefined for unrelated mode ids (e.g. effort levels). + */ +export function interactionModeFromGrokAcpModeId( + modeId: string, +): ProviderInteractionMode | undefined { + const normalized = normalizeModeId(modeId); + if (!normalized) { + return undefined; + } + if ((GROK_PLAN_MODE_ALIASES as ReadonlyArray).includes(normalized)) { + return "plan"; + } + if ((GROK_DEFAULT_MODE_ALIASES as ReadonlyArray).includes(normalized)) { + return "default"; + } + return undefined; +} + +/** + * Maps T3 interaction mode onto the Grok ACP session mode that should own tools. + * + * Grok sessions start in **ask** (approval-heavy / effectively read-only tools). + * Build/default (and any non-plan mode, including undefined) must pin **agent**. + * Plan maps to plan. Never return ask — that is what left Build threads stuck. + */ +export function resolveGrokAcpModeIdForInteractionMode( + interactionMode: ProviderInteractionMode | undefined, +): string { + if (interactionMode === "plan") { + return "plan"; + } + // Build / default / unset — never ask, never ACP "default". + return "agent"; +} + +function toolMetaName(params: EffectAcpSchema.RequestPermissionRequest): string | undefined { + const meta = params.toolCall._meta; + if (!meta || typeof meta !== "object") { + return undefined; + } + const xaiTool = (meta as Record)["x.ai/tool"]; + if (!xaiTool || typeof xaiTool !== "object") { + return undefined; + } + const name = (xaiTool as Record).name; + return typeof name === "string" && name.trim().length > 0 ? name.trim() : undefined; +} + +function toolMetaKind(params: EffectAcpSchema.RequestPermissionRequest): string | undefined { + const meta = params.toolCall._meta; + if (!meta || typeof meta !== "object") { + return undefined; + } + const xaiTool = (meta as Record)["x.ai/tool"]; + if (!xaiTool || typeof xaiTool !== "object") { + return undefined; + } + const kind = (xaiTool as Record).kind; + return typeof kind === "string" && kind.trim().length > 0 ? kind.trim() : undefined; +} + +/** + * Detects Grok's exit_plan_mode / ExitPlanMode permission requests used to + * present a plan for user approval. + */ +export function isGrokExitPlanModePermission( + params: EffectAcpSchema.RequestPermissionRequest, +): boolean { + const title = params.toolCall.title?.trim().toLowerCase() ?? ""; + const metaName = toolMetaName(params)?.toLowerCase() ?? ""; + const metaKind = toolMetaKind(params)?.toLowerCase() ?? ""; + const rawInput = params.toolCall.rawInput; + const rawVariant = + rawInput && typeof rawInput === "object" && !Array.isArray(rawInput) + ? String((rawInput as Record).variant ?? "") + .trim() + .toLowerCase() + : ""; + + return ( + metaName === "exit_plan_mode" || + metaKind === "exit_plan" || + title === "exit_plan_mode" || + title === "plan: exit" || + title.includes("exit plan") || + rawVariant === "exitplanmode" + ); +} + +/** + * Detects plan-file writes so we can capture plan markdown before exit_plan_mode. + */ +export function extractGrokPlanMarkdownFromToolWrite( + toolCall: { + readonly title?: string | null; + readonly rawInput?: unknown; + readonly _meta?: unknown; + }, + options?: { + readonly sessionId?: string; + }, +): string | undefined { + const rawInput = toolCall.rawInput; + if (!rawInput || typeof rawInput !== "object" || Array.isArray(rawInput)) { + return undefined; + } + const record = rawInput as Record; + const filePath = + typeof record.file_path === "string" + ? record.file_path + : typeof record.path === "string" + ? record.path + : undefined; + const content = typeof record.content === "string" ? record.content : undefined; + if (!filePath || content === undefined) { + return undefined; + } + const normalizedPath = filePath.replaceAll("\\", "/"); + const isPlanFile = + normalizedPath.endsWith("/plan.md") || + normalizedPath.endsWith("plan.md") || + (options?.sessionId !== undefined && normalizedPath.includes(options.sessionId)); + if (!isPlanFile) { + // Still accept when meta names the write as plan mode plan file via title. + const title = toolCall.title?.toLowerCase() ?? ""; + if (!title.includes("plan.md")) { + return undefined; + } + } + const trimmed = content.trim(); + return trimmed.length > 0 ? content : undefined; +} + +export function resolveGrokSessionPlanMarkdownPath(input: { + readonly homeDir: string; + readonly cwd: string; + readonly sessionId: string; +}): string { + // Grok encodes the cwd as a URL-encoded path segment under ~/.grok/sessions. + const encodedCwd = encodeURIComponent(input.cwd); + return `${input.homeDir.replace(/\/$/, "")}/.grok/sessions/${encodedCwd}/${input.sessionId}/plan.md`; +} diff --git a/apps/server/src/provider/acp/KimiAcpCliProbe.test.ts b/apps/server/src/provider/acp/KimiAcpCliProbe.test.ts new file mode 100644 index 000000000000..c4fc197a7de1 --- /dev/null +++ b/apps/server/src/provider/acp/KimiAcpCliProbe.test.ts @@ -0,0 +1,59 @@ +/** + * Optional integration check against a real Kimi Code CLI install. + * Enable with T3_KIMI_ACP_PROBE=1 and optionally set T3_KIMI_BINARY. + */ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import { describe, expect } from "vite-plus/test"; + +import { checkKimiProviderStatus } from "../Layers/KimiProvider.ts"; +import * as AcpSessionRuntime from "./AcpSessionRuntime.ts"; + +describe.runIf(process.env.T3_KIMI_ACP_PROBE === "1")("Kimi ACP CLI probe", () => { + it.effect("authenticates and discovers models from session config", () => + Effect.gen(function* () { + const runtime = yield* AcpSessionRuntime.AcpSessionRuntime; + const started = yield* runtime.start(); + const modelOption = started.sessionSetupResult.configOptions?.find( + (option) => option.id === "model", + ); + expect(started.initializeResult.agentInfo?.name).toContain("Kimi"); + expect(modelOption?.type).toBe("select"); + if (modelOption?.type === "select") { + expect(modelOption.options.length).toBeGreaterThan(0); + } + }).pipe( + Effect.provide( + AcpSessionRuntime.layer({ + spawn: { + command: process.env.T3_KIMI_BINARY ?? "kimi", + args: ["acp"], + cwd: process.cwd(), + }, + cwd: process.cwd(), + clientInfo: { name: "t3-kimi-probe", version: "0.0.0" }, + authMethodId: "login", + }), + ), + Effect.scoped, + Effect.provide(NodeServices.layer), + ), + ); + + it.effect("completes the deployed provider status probe", () => + checkKimiProviderStatus({ + enabled: true, + binaryPath: process.env.T3_KIMI_BINARY ?? "kimi", + customModels: [], + }).pipe( + Effect.tap((snapshot) => + Effect.sync(() => { + expect(snapshot.status).toBe("ready"); + expect(snapshot.models.length).toBeGreaterThan(0); + }), + ), + Effect.provide(NodeServices.layer), + ), + ); +}); diff --git a/apps/server/src/provider/acp/KimiAcpSupport.test.ts b/apps/server/src/provider/acp/KimiAcpSupport.test.ts new file mode 100644 index 000000000000..55fe63767527 --- /dev/null +++ b/apps/server/src/provider/acp/KimiAcpSupport.test.ts @@ -0,0 +1,44 @@ +import { it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import { describe, expect } from "vite-plus/test"; + +import { applyKimiAcpModelSelection, buildKimiAcpSpawnInput } from "./KimiAcpSupport.ts"; + +describe("buildKimiAcpSpawnInput", () => { + it("builds the configured Kimi ACP command", () => { + expect( + buildKimiAcpSpawnInput({ binaryPath: "/opt/kimi/bin/kimi" }, "/tmp/project", { + KIMI_CODE_HOME: "/tmp/kimi-home", + }), + ).toEqual({ + command: "/opt/kimi/bin/kimi", + args: ["acp"], + cwd: "/tmp/project", + forceKillAfter: "1 second", + env: { KIMI_CODE_HOME: "/tmp/kimi-home" }, + }); + }); +}); + +describe("applyKimiAcpModelSelection", () => { + it.effect("sets the model before negotiated Kimi config options", () => + Effect.gen(function* () { + const calls: Array> = []; + const runtime = { + setModel: (model: string) => Effect.sync(() => calls.push(["model", model])), + setConfigOption: (id: string, value: string | boolean) => + Effect.sync(() => calls.push(["config", id, value])), + }; + yield* applyKimiAcpModelSelection({ + runtime: runtime as never, + model: "kimi-code/k3", + selections: [{ id: "thinking", value: "on" }], + mapError: ({ cause }) => cause, + }); + expect(calls).toEqual([ + ["model", "kimi-code/k3"], + ["config", "thinking", "on"], + ]); + }), + ); +}); diff --git a/apps/server/src/provider/acp/KimiAcpSupport.ts b/apps/server/src/provider/acp/KimiAcpSupport.ts new file mode 100644 index 000000000000..33252ab95f1f --- /dev/null +++ b/apps/server/src/provider/acp/KimiAcpSupport.ts @@ -0,0 +1,87 @@ +import { type KimiSettings, type ProviderOptionSelection } from "@t3tools/contracts"; +import * as Crypto from "effect/Crypto"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Scope from "effect/Scope"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; +import type * as EffectAcpErrors from "effect-acp/errors"; + +import * as AcpSessionRuntime from "./AcpSessionRuntime.ts"; + +const KIMI_ACP_FORCE_KILL_AFTER = "1 second"; + +export interface KimiAcpRuntimeInput extends Omit< + AcpSessionRuntime.AcpSessionRuntimeOptions, + "authMethodId" | "clientCapabilities" | "spawn" +> { + readonly childProcessSpawner: ChildProcessSpawner.ChildProcessSpawner["Service"]; + readonly environment?: NodeJS.ProcessEnv; +} + +export function buildKimiAcpSpawnInput( + settings: Pick, + cwd: string, + environment?: NodeJS.ProcessEnv, +): AcpSessionRuntime.AcpSpawnInput { + return { + command: settings.binaryPath || "kimi", + args: ["acp"], + cwd, + forceKillAfter: KIMI_ACP_FORCE_KILL_AFTER, + ...(environment ? { env: environment } : {}), + }; +} + +export const makeKimiAcpRuntime = ( + settings: Pick, + input: KimiAcpRuntimeInput, +): Effect.Effect< + AcpSessionRuntime.AcpSessionRuntime["Service"], + EffectAcpErrors.AcpError, + Crypto.Crypto | Scope.Scope +> => + Effect.gen(function* () { + const acpContext = yield* Layer.build( + AcpSessionRuntime.layer({ + ...input, + spawn: buildKimiAcpSpawnInput(settings, input.cwd, input.environment), + authMethodId: "login", + }).pipe( + Layer.provide( + Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner), + ), + ), + ); + return yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe( + Effect.provide(acpContext), + ); + }); + +export function applyKimiAcpModelSelection(input: { + readonly runtime: AcpSessionRuntime.AcpSessionRuntime["Service"]; + readonly model: string | null | undefined; + readonly selections: ReadonlyArray | null | undefined; + readonly mapError: (context: { + readonly cause: EffectAcpErrors.AcpError; + readonly step: "set-config-option" | "set-model"; + readonly configId?: string; + }) => E; +}): Effect.Effect { + return Effect.gen(function* () { + const model = input.model?.trim(); + if (model) { + yield* input.runtime + .setModel(model) + .pipe(Effect.mapError((cause) => input.mapError({ cause, step: "set-model" }))); + } + for (const selection of input.selections ?? []) { + yield* input.runtime + .setConfigOption(selection.id, selection.value) + .pipe( + Effect.mapError((cause) => + input.mapError({ cause, step: "set-config-option", configId: selection.id }), + ), + ); + } + }); +} diff --git a/apps/server/src/provider/acp/XAiAcpExtension.test.ts b/apps/server/src/provider/acp/XAiAcpExtension.test.ts index 28f5f29f4987..e99fa027e0a6 100644 --- a/apps/server/src/provider/acp/XAiAcpExtension.test.ts +++ b/apps/server/src/provider/acp/XAiAcpExtension.test.ts @@ -6,7 +6,10 @@ import * as NodeURL from "node:url"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; +import * as TestClock from "effect/testing/TestClock"; import { describe, expect } from "vite-plus/test"; import { @@ -358,6 +361,44 @@ describe("XAiAcpExtension", () => { }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), ); + it.effect("steers a running turn instead of queueing behind it", () => + Effect.gen(function* () { + const runtime = yield* makePromptCompletionRuntime({ T3_ACP_XAI_SEND_NOW_QUEUE: "1" }); + yield* runtime.start(); + + const runningTurn = yield* runtime + .prompt({ prompt: [{ type: "text", text: "long task" }] }) + .pipe(Effect.forkChild({ startImmediately: true })); + + const steerResult = yield* runtime + .prompt({ prompt: [{ type: "text", text: "actually, do this" }] }, { steer: true }) + .pipe(Effect.timeout("10 seconds")); + + expect(steerResult.stopReason).toBe("end_turn"); + const runningTurnResult = yield* Fiber.join(runningTurn).pipe(Effect.timeout("10 seconds")); + expect(runningTurnResult.stopReason).toBe("cancelled"); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); + + it.effect("keeps a non-steering prompt queued behind the running turn", () => + Effect.gen(function* () { + const runtime = yield* makePromptCompletionRuntime({ T3_ACP_XAI_SEND_NOW_QUEUE: "1" }); + yield* runtime.start(); + + yield* runtime + .prompt({ prompt: [{ type: "text", text: "long task" }] }) + .pipe(Effect.forkChild({ startImmediately: true })); + + const queuedFiber = yield* runtime + .prompt({ prompt: [{ type: "text", text: "follow-up" }] }) + .pipe(Effect.timeout("1 second"), Effect.option, Effect.forkChild); + + yield* TestClock.adjust("1 second"); + const queued = yield* Fiber.join(queuedFiber); + expect(Option.isNone(queued)).toBe(true); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); + it("extracts plan markdown from exit_plan_mode payloads", () => { const decode = Schema.decodeUnknownSync(XAiExitPlanModeRequest); const direct = decode({ diff --git a/apps/server/src/provider/acp/XAiAcpExtension.ts b/apps/server/src/provider/acp/XAiAcpExtension.ts index 620545569aaa..1e15dd6f8802 100644 --- a/apps/server/src/provider/acp/XAiAcpExtension.ts +++ b/apps/server/src/provider/acp/XAiAcpExtension.ts @@ -415,6 +415,18 @@ function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); } +/** Prefer non-empty planContent from the extension request; otherwise undefined. */ +export function extractXAiExitPlanModePlanMarkdown( + params: XAiExitPlanModeRequest, +): string | undefined { + const planContent = unwrapExitPlanModeParams(params).planContent; + if (typeof planContent !== "string") { + return undefined; + } + const trimmedContent = planContent.trim(); + return trimmedContent.length > 0 ? planContent : undefined; +} + /** * Adds Grok's private prompt-completion fallback around a standards-only ACP runtime. * The underlying runtime remains unaware of xAI methods and metadata. @@ -466,6 +478,16 @@ export const makeXAiPromptCompletionRuntime = Effect.fn("makeXAiPromptCompletion ...payload._meta, promptId: fallback.promptId, requestId: fallback.promptId, + // Grok's "send now": cancel whatever the agent is still doing and + // take this prompt as the next turn, keeping background tasks and + // the queue alive. Without it the agent queues the prompt behind + // the running turn and answers it only once that turn finishes. + // + // Sent on every prompt, not just steers: it is a no-op on an idle + // session, and it also covers the windows where the agent is busy + // but T3 believes otherwise — a Stop whose cancellation is still + // winding down, or a resumed/reconnected session. + sendNow: true, }, } satisfies Omit; diff --git a/apps/server/src/provider/builtInDrivers.ts b/apps/server/src/provider/builtInDrivers.ts index 60e3402eed42..b270235a4e2d 100644 --- a/apps/server/src/provider/builtInDrivers.ts +++ b/apps/server/src/provider/builtInDrivers.ts @@ -24,6 +24,7 @@ import { ClaudeDriver, type ClaudeDriverEnv } from "./Drivers/ClaudeDriver.ts"; import { CodexDriver, type CodexDriverEnv } from "./Drivers/CodexDriver.ts"; import { CursorDriver, type CursorDriverEnv } from "./Drivers/CursorDriver.ts"; import { GrokDriver, type GrokDriverEnv } from "./Drivers/GrokDriver.ts"; +import { KimiDriver, type KimiDriverEnv } from "./Drivers/KimiDriver.ts"; import { OpenCodeDriver, type OpenCodeDriverEnv } from "./Drivers/OpenCodeDriver.ts"; import { AntigravityDriver, type AntigravityDriverEnv } from "./Drivers/AntigravityDriver.ts"; import type { AnyProviderDriver } from "./ProviderDriver.ts"; @@ -38,6 +39,7 @@ export type BuiltInDriversEnv = | CodexDriverEnv | CursorDriverEnv | GrokDriverEnv + | KimiDriverEnv | OpenCodeDriverEnv | AntigravityDriverEnv; @@ -51,6 +53,7 @@ export const BUILT_IN_DRIVERS: ReadonlyArray { + let spawnedCommand: unknown; + const spawner = ChildProcessSpawner.make((command) => { + spawnedCommand = command; + return Effect.succeed( + ChildProcessSpawner.makeHandle({ + pid: ChildProcessSpawner.ProcessId(987_654), + exitCode: Effect.never, + isRunning: Effect.succeed(true), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.drain, + stdout: Stream.encodeText( + Stream.make("opencode server listening on http://127.0.0.1:4310\n"), + ), + stderr: Stream.empty, + all: Stream.empty, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.empty, + }), + ); + }); + const runtimeLayer = OpenCodeRuntimeLive.pipe( + Layer.provide(Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner)), + ); + + return Effect.gen(function* () { + const originalFetch = globalThis.fetch; + globalThis.fetch = Object.assign( + async () => + new Response(JSON.stringify({ healthy: true, version: "1.15.13" }), { + status: 200, + headers: { "content-type": "application/json" }, + }), + originalFetch, + ); + const runtime = yield* OpenCodeRuntime; + const sessionScope = yield* Scope.make(); + const server = yield* runtime + .startOpenCodeServerProcess({ + binaryPath: "/project/bin/opencode", + directory: "/project/worktree", + cwd: "/project/worktree", + environment: { + PATH: "/project/bin", + KEEP: "value", + // Upstream #4242: a caller-supplied config wins. Forcing "{}" here + // used to clobber the user's opencode config and hide their + // providers; only an unset value falls back to the empty config. + OPENCODE_CONFIG_CONTENT: '{"provider":{}}', + }, + port: 4310, + }) + .pipe( + Effect.provideService(Scope.Scope, sessionScope), + Effect.ensuring( + Effect.sync(() => { + globalThis.fetch = originalFetch; + }), + ), + ); + + expect(server.url).toBe("http://127.0.0.1:4310"); + expect(server.version).toBe("1.15.13"); + const command = spawnedCommand as { + readonly options: { + readonly cwd?: string; + readonly env?: NodeJS.ProcessEnv; + readonly extendEnv?: boolean; + }; + }; + expect(command.options.cwd).toBe("/project/worktree"); + expect(command.options.extendEnv).toBe(false); + expect(command.options.env).toEqual({ + PATH: "/project/bin", + KEEP: "value", + OPENCODE_CONFIG_CONTENT: '{"provider":{}}', + }); + const closeFiber = yield* Scope.close(sessionScope, Exit.void).pipe(Effect.forkChild); + yield* TestClock.adjust("1 second"); + yield* Fiber.join(closeFiber); + }).pipe(Effect.provide(runtimeLayer)); +}); diff --git a/apps/server/src/provider/opencodeRuntime.ts b/apps/server/src/provider/opencodeRuntime.ts index 6d7187792a99..8998ca4c2dbc 100644 --- a/apps/server/src/provider/opencodeRuntime.ts +++ b/apps/server/src/provider/opencodeRuntime.ts @@ -221,6 +221,7 @@ export interface OpenCodeRuntimeShape { readonly directory: string; readonly serverPassword?: string; readonly environment?: NodeJS.ProcessEnv; + readonly cwd?: string; readonly port?: number; readonly hostname?: string; readonly timeoutMs?: number; @@ -236,6 +237,7 @@ export interface OpenCodeRuntimeShape { readonly serverUrl?: string | null; readonly serverPassword?: string; readonly environment?: NodeJS.ProcessEnv; + readonly cwd?: string; readonly port?: number; readonly hostname?: string; readonly timeoutMs?: number; @@ -672,6 +674,7 @@ const makeOpenCodeRuntime = Effect.gen(function* () { const child = yield* spawner .spawn( ChildProcess.make(spawnCommand.command, spawnCommand.args, { + ...(input.cwd ? { cwd: input.cwd } : {}), detached: hostPlatform !== "win32", shell: spawnCommand.shell, env: { @@ -866,6 +869,7 @@ const makeOpenCodeRuntime = Effect.gen(function* () { directory: input.directory, ...(input.serverPassword !== undefined ? { serverPassword: input.serverPassword } : {}), ...(input.environment !== undefined ? { environment: input.environment } : {}), + ...(input.cwd !== undefined ? { cwd: input.cwd } : {}), ...(input.port !== undefined ? { port: input.port } : {}), ...(input.hostname !== undefined ? { hostname: input.hostname } : {}), ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}), diff --git a/apps/server/src/provider/providerSessionContinuation.ts b/apps/server/src/provider/providerSessionContinuation.ts new file mode 100644 index 000000000000..a622dfb6c404 --- /dev/null +++ b/apps/server/src/provider/providerSessionContinuation.ts @@ -0,0 +1,32 @@ +import { TurnId } from "@t3tools/contracts"; + +/** Runtime payload key shared by in-app server updates and graceful process stop. */ +export const SERVER_UPDATE_CONTINUATION_KEY = "continueAfterServerUpdate"; +export const SERVER_UPDATE_CONTINUATION_PROMPT = "Continue where you left off."; + +export function readRuntimePayload(runtimePayload: unknown): Record { + return runtimePayload !== null && + typeof runtimePayload === "object" && + !Array.isArray(runtimePayload) + ? (runtimePayload as Record) + : {}; +} + +export function hasServerUpdateContinuationMarker( + runtimePayload: unknown, +): runtimePayload is Record { + return ( + runtimePayload !== null && + typeof runtimePayload === "object" && + !Array.isArray(runtimePayload) && + SERVER_UPDATE_CONTINUATION_KEY in runtimePayload + ); +} + +export function readServerUpdateContinuationTurnId(runtimePayload: unknown): TurnId | null { + if (!hasServerUpdateContinuationMarker(runtimePayload)) { + return null; + } + const value = runtimePayload[SERVER_UPDATE_CONTINUATION_KEY]; + return typeof value === "string" && value.length > 0 ? TurnId.make(value) : null; +} diff --git a/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs b/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs index fa567d75cf8a..1bad5ca46978 100644 --- a/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs +++ b/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs @@ -124,6 +124,12 @@ rl.on("line", (line) => { : fixture.responses.turnStart.turn; activeTurn = turn; turnStartCount += 1; + // Append-only sidecar the tests read to tell a steered follow-up (no new + // turn) apart from one that opened a second provider turn. + NodeFS.appendFileSync( + `${process.env.T3_CODEX_COLLAB_SCRIPT}.turns`, + `${JSON.stringify({ turnId: turn.id })}\n`, + ); write({ id, result: { ...fixture.responses.turnStart, turn } }); const rootThreadId = script.rootThreadId; if (script.onlyFirstTurnStarts !== true || turnStartCount === 1) { @@ -151,6 +157,18 @@ rl.on("line", (line) => { } return; } + if (method === "turn/steer") { + // The fork appends follow-up input to the running turn instead of + // opening a second provider turn. `rejectSteer` models a turn that + // cannot accept steering (review, manual compact), which sends the + // runtime back to turn/start. + if (script.rejectSteer === true) { + write({ id, error: { code: -32000, message: "turn is not steerable" } }); + return; + } + write({ id, result: { turnId: message.params?.expectedTurnId } }); + return; + } if (method === "turn/interrupt") { // Record which thread/turn was interrupted (append-only sidecar file the // test reads) so Stop coverage can assert every live child was reached. diff --git a/apps/server/src/provider/testUtils/pollUntil.ts b/apps/server/src/provider/testUtils/pollUntil.ts new file mode 100644 index 000000000000..645ebeb1620a --- /dev/null +++ b/apps/server/src/provider/testUtils/pollUntil.ts @@ -0,0 +1,53 @@ +import * as Clock from "effect/Clock"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as TestClock from "effect/testing/TestClock"; + +const describeValue = (value: unknown) => { + try { + const text = JSON.stringify(value); + if (text === undefined) { + return String(value); + } + return text.length > 2_000 ? `${text.slice(0, 2_000)}…` : text; + } catch { + return String(value); + } +}; + +export interface PollUntilOptions { + readonly poll: Effect.Effect; + readonly until: (value: A) => boolean; + readonly description: string; + readonly timeout?: Duration.Input; + readonly interval?: Duration.Input; +} + +/** + * Polls asynchronous OS work using real time even when an Effect test uses + * TestClock. This gives child processes and libuv callbacks time to progress. + */ +export const pollUntil = (options: PollUntilOptions) => + Effect.gen(function* () { + const timeoutMillis = Duration.toMillis(options.timeout ?? "10 seconds"); + const interval = options.interval ?? "25 millis"; + const startedAt = yield* TestClock.withLive(Clock.currentTimeMillis); + + for (;;) { + const value = yield* options.poll; + if (options.until(value)) { + return value; + } + + const now = yield* TestClock.withLive(Clock.currentTimeMillis); + if (now - startedAt >= timeoutMillis) { + return yield* Effect.die( + new Error( + `Timed out after ${timeoutMillis}ms waiting for ${options.description}. ` + + `Last polled value: ${describeValue(value)}`, + ), + ); + } + yield* TestClock.withLive(Effect.sleep(interval)); + } + }); diff --git a/apps/server/src/pullRequest/PullRequestService.test.ts b/apps/server/src/pullRequest/PullRequestService.test.ts index 3117c0072a78..bfbf70d63eb3 100644 --- a/apps/server/src/pullRequest/PullRequestService.test.ts +++ b/apps/server/src/pullRequest/PullRequestService.test.ts @@ -3922,6 +3922,144 @@ it.effect("carries an armed auto-merge through to the detail, and silence as sil }), ); +it("names an Azure DevOps repository by its own name, not its project path", () => { + // `az repos pr list --repository` takes a name and detects the organisation and project from + // the checkout; the recorded `org/project/_git/repo` path is refused, and the repository then + // reads as unavailable on the page. + const selector = PullRequestService.repositoryIdentityOf({ + repositoryIdentity: { + provider: "azure-devops", + displayName: "contoso/payments/_git/checkout", + owner: "contoso", + name: "checkout", + }, + } as never); + assert.strictEqual(selector, "checkout"); +}); + +it("falls back to the path's last segment where an Azure identity has no name", () => { + const selector = PullRequestService.repositoryIdentityOf({ + repositoryIdentity: { + provider: "azure-devops", + displayName: "contoso/payments/_git/checkout", + }, + } as never); + assert.strictEqual(selector, "checkout"); +}); + +it("lists origin and upstream so a fork PR is still this project's", () => { + const names = PullRequestService.repositoriesOf({ + repositoryIdentity: { + provider: "github", + displayName: "pingdotgg/t3code", + owner: "pingdotgg", + name: "t3code", + remotes: [ + { + remoteName: "origin", + remoteUrl: "https://github.com/patroza/t3code.git", + owner: "patroza", + name: "t3code", + canonicalKey: "github.com/patroza/t3code", + }, + { + remoteName: "upstream", + remoteUrl: "https://github.com/pingdotgg/t3code.git", + owner: "pingdotgg", + name: "t3code", + canonicalKey: "github.com/pingdotgg/t3code", + }, + ], + }, + } as never); + assert.deepStrictEqual(names.toSorted(), ["patroza/t3code", "pingdotgg/t3code"]); +}); + +it.effect("reads a fork pull request against origin, not the upstream identity", () => + Effect.gen(function* () { + let requested: string | null = null; + const fork = project({ + id: "p1", + title: "t3code", + workspaceRoot: "/t3code", + repository: "pingdotgg/t3code", + }); + const identity = fork.repositoryIdentity!; + const withRemotes = { + ...fork, + repositoryIdentity: { + ...identity, + remotes: [ + { + remoteName: "origin", + remoteUrl: "https://github.com/patroza/t3code.git", + owner: "patroza", + name: "t3code", + canonicalKey: "github.com/patroza/t3code", + }, + { + remoteName: "upstream", + remoteUrl: "https://github.com/pingdotgg/t3code.git", + owner: "pingdotgg", + name: "t3code", + canonicalKey: "github.com/pingdotgg/t3code", + }, + ], + }, + }; + const service = yield* makeService({ + projects: [withRemotes], + providers: [ + fakeProvider("github", { + getChangeRequest: (input) => { + requested = input.repository; + return Effect.succeed({ + ...changeRequest(410, "2026-08-15T00:00:00Z"), + url: "https://github.com/patroza/t3code/pull/410", + body: "", + changedFiles: 1, + mergedAt: null, + closedAt: null, + reviewers: [], + checks: [], + mergeCapabilities: { merge: true, squash: true, rebase: true }, + viewerPermissions: { + actions: ["merge"], + comment: true, + resolve: true, + verdicts: ["comment", "approve", "request-changes"], + requestReviewers: true, + }, + }); + }, + }), + ], + }); + + const detail = yield* service.detail({ + projectId: "p1" as ProjectId, + repository: "patroza/t3code", + number: 410, + }); + + assert.strictEqual(requested, "patroza/t3code"); + assert.strictEqual(detail.repository, "patroza/t3code"); + assert.strictEqual(detail.number, 410); + }), +); + +it("keeps a GitLab identity's whole path, because a nested group is part of the name", () => { + const selector = PullRequestService.repositoryIdentityOf({ + repositoryIdentity: { + provider: "gitlab", + displayName: "group/subgroup/service", + owner: "group", + name: "service", + }, + } as never); + assert.strictEqual(selector, "group/subgroup/service"); +}); + it.effect("narrows the rows of a host that ignored the filters it was handed", () => Effect.gen(function* () { const service = yield* makeService({ diff --git a/apps/server/src/pullRequest/PullRequestService.ts b/apps/server/src/pullRequest/PullRequestService.ts index 37716da44005..df69631d1936 100644 --- a/apps/server/src/pullRequest/PullRequestService.ts +++ b/apps/server/src/pullRequest/PullRequestService.ts @@ -529,6 +529,34 @@ function withRateLimitBackoff( Record, never>; } +export function repositoryIdentityOf(project: OrchestrationProjectShell): string | null { + const identity = project.repositoryIdentity; + if (!identity) return null; + if (identity.provider === "azure-devops") { + const segments = (identity.displayName ?? "").split("/").filter((part) => part !== "_git"); + return identity.name || segments.at(-1) || null; + } + if (identity.displayName) return identity.displayName; + return identity.owner && identity.name ? `${identity.owner}/${identity.name}` : null; +} + +/** + * Every repository this checkout answers to. A fork records both origin and + * upstream; the primary identity prefers upstream, but a change request on the + * fork is still this project's. + */ +export function repositoriesOf(project: OrchestrationProjectShell): ReadonlyArray { + const names = new Set(); + const primary = repositoryIdentityOf(project); + if (primary) names.add(primary.toLowerCase()); + for (const remote of project.repositoryIdentity?.remotes ?? []) { + if (remote.owner && remote.name) { + names.add(`${remote.owner}/${remote.name}`.toLowerCase()); + } + } + return [...names]; +} + export const make = Effect.gen(function* () { const mergedPullRequests = yield* PubSub.sliding(64); const pullRequestRefreshes = yield* SubscriptionRef.make(0); @@ -686,17 +714,25 @@ export const make = Effect.gen(function* () { const own = supported[0]; const repository = ref.repository.trim(); const host = ref.host?.trim().toLowerCase(); - if (own !== undefined && own.repository.toLowerCase() === repository.toLowerCase()) { - // Hostless references only ever meant the project's own repository, and a hosted one - // naming it still is; either way the project serves itself. - if (host === undefined || host === own.host) return Effect.succeed(own); + if (own !== undefined) { + const requested = repository.toLowerCase(); + // Upstream is the primary identity on a fork; origin is still ours. + if ( + (own.repository.toLowerCase() === requested || + repositoriesOf(own.project).includes(requested)) && + (host === undefined || host === own.host) + ) { + return Effect.succeed( + requested === own.repository.toLowerCase() + ? own + : { ...own, repository: ref.repository.trim() }, + ); + } } if (host === undefined) { if (own === undefined) { return Effect.fail(new PullRequestUnavailableError({ reason: "provider-unsupported" })); } - // The repository travels through the client, so it is checked against the project's - // own remote rather than being handed to a provider verbatim. return Effect.fail( new PullRequestOperationError({ operation: "resolveRepository", diff --git a/apps/server/src/relay/AgentAwarenessRelay.test.ts b/apps/server/src/relay/AgentAwarenessRelay.test.ts index 1e7cdc3f00e6..f5f784e34984 100644 --- a/apps/server/src/relay/AgentAwarenessRelay.test.ts +++ b/apps/server/src/relay/AgentAwarenessRelay.test.ts @@ -27,6 +27,7 @@ import * as Option from "effect/Option"; import * as Queue from "effect/Queue"; import * as Stream from "effect/Stream"; import * as Tracer from "effect/Tracer"; +import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient"; import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; @@ -624,7 +625,6 @@ describe.sequential("signRelayAgentActivityPublishProof", () => { it.effect("publishes agent activity to the relay transport URL, not the relay issuer", () => Effect.scoped( Effect.gen(function* () { - const originalFetch = globalThis.fetch; const events = yield* Queue.unbounded(); let resolveFetchSeen: (url: URL) => void = () => {}; const fetchSeen = new Promise((resolve) => { @@ -712,7 +712,7 @@ describe.sequential("signRelayAgentActivityPublishProof", () => { }, } satisfies ExecutionEnvironmentDescriptor; - globalThis.fetch = ((input: Parameters[0]) => { + const testFetch = ((input: Parameters[0]) => { const url = new URL( typeof input === "string" || input instanceof URL ? input @@ -721,11 +721,6 @@ describe.sequential("signRelayAgentActivityPublishProof", () => { resolveFetchSeen(url); return Promise.resolve(Response.json({ ok: true, deliveries: [] })); }) as unknown as typeof fetch; - yield* Effect.addFinalizer(() => - Effect.sync(() => { - globalThis.fetch = originalFetch; - }), - ); const layer = Layer.mergeAll( Layer.succeed(ServerSecretStore.ServerSecretStore, secrets.store), @@ -792,6 +787,7 @@ describe.sequential("signRelayAgentActivityPublishProof", () => { ), ), Effect.provideService(RelayClientTracer, Option.some(collectingTracer(productSpans))), + Effect.provideService(FetchHttpClient.Fetch, testFetch), Effect.withTracer(collectingTracer(userSpans)), ); }), diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts index afb4adfef79c..bfd8c4c1ac32 100644 --- a/apps/server/src/server.test.ts +++ b/apps/server/src/server.test.ts @@ -10,6 +10,7 @@ import { AuthStandardClientScopes, AuthEnvironmentBootstrapTokenType, AuthTokenExchangeGrantType, + AI_USAGE_UNAVAILABLE, CommandId, DEFAULT_SERVER_SETTINGS, type DpopFailureReason, @@ -50,6 +51,7 @@ import { computeDpopJwkThumbprint, type DpopPublicJwk, } from "@t3tools/shared/dpop"; +import { appendOmegentT3ProductHandshake } from "@t3tools/shared/productFamily"; import { RELAY_HEALTH_REQUEST_TYP, RELAY_MINT_REQUEST_TYP } from "@t3tools/shared/relayJwt"; import * as RelayClient from "@t3tools/shared/relayClient"; import { assert, it } from "@effect/vitest"; @@ -99,13 +101,15 @@ const encodeTestJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unk import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; import * as ServerConfig from "./config.ts"; import * as DeviceService from "./device/DeviceService.ts"; -import { HTTP_ROUTER_CONFIG, makeRoutesLayer } from "./server.ts"; +import { HTTP_ROUTER_CONFIG, isCommandReadinessExemptPath, makeRoutesLayer } from "./server.ts"; +import * as IdentityService from "./identity/IdentityService.ts"; import { isThreadDetailEvent, resolveAvailableEditorsForConfig, resolveFileManagerRevealKindForConfig, } from "./ws.ts"; import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts"; +import * as GrokTranscriptResync from "./externalSessions/GrokTranscriptResync.ts"; import * as GitManager from "./git/GitManager.ts"; import * as EnvironmentTheme from "./environmentTheme.ts"; import * as UsageLimitSources from "./usage/UsageLimitSources.ts"; @@ -114,10 +118,12 @@ import * as ExternalLauncher from "./process/externalLauncher.ts"; import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts"; import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts"; import { + OrchestrationCommandInvariantError, OrchestrationListenerCallbackError, OrchestrationThreadSettleBlockedError, } from "./orchestration/Errors.ts"; import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts"; +import * as WorktreeLifecycle from "./orchestration/Services/WorktreeLifecycle.ts"; import { ThreadDeletionReactor } from "./orchestration/Services/ThreadDeletionReactor.ts"; import * as PullRequestSyncReactor from "./orchestration/PullRequestSyncReactor.ts"; import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite.ts"; @@ -142,11 +148,13 @@ import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts"; import * as ServerSettings from "./serverSettings.ts"; import * as TerminalManager from "./terminal/Manager.ts"; import * as PreviewManager from "./preview/Manager.ts"; +import * as PortExposure from "./preview/PortExposure.ts"; import * as PortScanner from "./preview/PortScanner.ts"; import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts"; import * as NativeAppIconResolver from "./assets/NativeAppIconResolver.ts"; import * as ProjectFaviconResolver from "./project/ProjectFaviconResolver.ts"; import * as T3ProjectFileLoader from "./project/T3ProjectFileLoader.ts"; +import * as ProjectLifecycleScriptRunner from "./project/ProjectLifecycleScriptRunner.ts"; import * as ProjectSetupScriptRunner from "./project/ProjectSetupScriptRunner.ts"; import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts"; import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; @@ -167,6 +175,8 @@ import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import * as PairingGrantStore from "./auth/PairingGrantStore.ts"; import * as CloudManagedEndpointRuntime from "./cloud/ManagedEndpointRuntime.ts"; import * as CloudCliTokenManager from "./cloud/CliTokenManager.ts"; +import * as AiUsageMonitorModule from "./aiUsage/AiUsageMonitor.ts"; +import * as HostResourceProbe from "./diagnostics/HostResourceProbe.ts"; import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts"; import * as HostResources from "./resourceTelemetry/HostResources.ts"; import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; @@ -342,6 +352,8 @@ const makeDefaultOrchestrationReadModel = () => { settledAt: null, latestTurn: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, session: null, activities: [], proposedPlans: [], @@ -532,6 +544,7 @@ const buildAppUnderTest = (options?: { threadDeletionReactor?: Partial; analyticsService?: Partial; projectionSnapshotQuery?: Partial; + worktreeLifecycle?: Partial; checkpointDiffQuery?: Partial; browserTraceCollector?: Partial; serverLifecycleEvents?: Partial; @@ -643,6 +656,7 @@ const buildAppUnderTest = (options?: { kind: "git" as const, rootPath: input.cwd, metadataPath: null, + bare: false, freshness: { source: "live-local" as const, observedAt: TEST_EPOCH, @@ -672,6 +686,7 @@ const buildAppUnderTest = (options?: { input.requestedKind === "auto" || !input.requestedKind ? "git" : input.requestedKind, rootPath: input.cwd, metadataPath: null, + bare: false, freshness: { source: "live-local", observedAt: TEST_EPOCH, @@ -705,10 +720,19 @@ const buildAppUnderTest = (options?: { ), NativeAppIconResolver.layer, ); + const projectLifecycleScriptRunnerLayer = Layer.mock( + ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner, + )({ + runWorktreeRemove: () => Effect.succeed({ status: "no-script" as const }), + runPrMerged: () => Effect.succeed({ status: "no-script" as const }), + }); const gitWorkflowLayer = GitWorkflowService.layer.pipe( Layer.provideMerge(vcsDriverRegistryLayer), Layer.provideMerge(gitVcsDriverLayer), Layer.provideMerge(gitManagerLayer), + // Merge so VcsStatusBroadcaster (which also depends on this service) can + // be provided from the same gitWorkflowLayer output. + Layer.provideMerge(projectLifecycleScriptRunnerLayer), ); const vcsProvisioningLayer = VcsProvisioningService.layer.pipe( Layer.provide(vcsDriverRegistryLayer), @@ -749,6 +773,7 @@ const buildAppUnderTest = (options?: { ).pipe( Layer.provide( Layer.mergeAll( + IdentityService.layerWithPeople([]), Layer.mock(Keybindings.Keybindings)({ loadConfigState: Effect.succeed({ keybindings: [], @@ -872,6 +897,23 @@ const buildAppUnderTest = (options?: { error: Option.none(), }), }), + Layer.mock(HostResourceProbe.HostResourceProbe)({ + read: Effect.succeed({ + status: "supported", + checkedAt: "1970-01-01T00:00:00.000Z", + source: "os", + hostname: "test-host", + platform: "linux", + cpuPercent: 25, + memoryUsedPercent: 50, + memoryUsedBytes: 4_000, + memoryAvailableBytes: 4_000, + memoryTotalBytes: 8_000, + loadAverage: { m1: 0.5, m5: 0.4, m15: 0.3 }, + logicalCores: 4, + message: null, + }), + }), ]), Layer.provide( Layer.mock(TraceDiagnostics.TraceDiagnostics)({ @@ -943,6 +985,14 @@ const buildAppUnderTest = (options?: { registerTerminalProcesses: () => Effect.void, unregisterTerminal: () => Effect.void, }), + Layer.mock(PortExposure.PreviewPortExposure)({ + resolve: () => Effect.die("PreviewPortExposure not stubbed in this test"), + }), + Layer.mock(AiUsageMonitorModule.AiUsageMonitor)({ + current: () => Effect.succeed(AI_USAGE_UNAVAILABLE), + subscribe: () => Effect.void, + retain: Effect.void, + }), ), ), Layer.provide( @@ -961,6 +1011,9 @@ const buildAppUnderTest = (options?: { latestSequence: Effect.succeed(0), ...options?.layers?.orchestrationEngine, }), + Layer.mock(GrokTranscriptResync.GrokTranscriptResync)({ + resyncThread: () => Effect.void, + }), Layer.mock(ThreadDeletionReactor)({ start: () => Effect.void, drainThrough: () => Effect.void, @@ -974,42 +1027,54 @@ const buildAppUnderTest = (options?: { ), ), Layer.provide( - Layer.mock(ProjectionSnapshotQuery.ProjectionSnapshotQuery)({ - getUserInputActivity: () => Effect.die("unused"), - getCommandReadModel: () => Effect.succeed(makeDefaultOrchestrationReadModel()), - getSnapshot: () => Effect.succeed(makeDefaultOrchestrationReadModel()), - getShellSnapshot: () => - Effect.succeed({ - snapshotSequence: 0, - projects: [], - threads: [], - updatedAt: "1970-01-01T00:00:00.000Z", - }), - getArchivedShellSnapshot: () => - Effect.succeed({ - snapshotSequence: 0, - projects: [], - threads: [], - updatedAt: "1970-01-01T00:00:00.000Z", - }), - searchThreads: () => Effect.succeed({ matches: [] }), - getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }), - getProjectShellById: () => Effect.succeed(Option.none()), - getThreadShellById: () => Effect.succeed(Option.none()), - getThreadDetailById: () => Effect.succeed(Option.none()), - getThreadDetailSnapshot: () => Effect.succeed(Option.none()), - getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }), - getEventReplayStats: ({ fromSequenceExclusive, toSequenceInclusive }) => - Effect.succeed({ - eventCount: Math.max(0, toSequenceInclusive - fromSequenceExclusive), - payloadBytes: 0, - }), - getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()), - getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()), - getImportedAgentSessionSources: () => Effect.succeed([]), - getThreadCheckpointContext: () => Effect.succeed(Option.none()), - ...options?.layers?.projectionSnapshotQuery, - }), + Layer.mergeAll( + Layer.mock(WorktreeLifecycle.WorktreeLifecycle)({ + previewCleanup: () => Effect.succeed({ candidate: null }), + cleanupThreadWorktree: () => Effect.die("unused worktree cleanup"), + restoreThreadWorktree: (_input, commitUnarchive) => commitUnarchive, + ...options?.layers?.worktreeLifecycle, + }), + Layer.mock(ProjectionSnapshotQuery.ProjectionSnapshotQuery)({ + getUserInputActivity: () => Effect.die("unused"), + getCommandReadModel: () => Effect.succeed(makeDefaultOrchestrationReadModel()), + getSnapshot: () => Effect.succeed(makeDefaultOrchestrationReadModel()), + getShellSnapshot: () => + Effect.succeed({ + snapshotSequence: 0, + projects: [], + threads: [], + updatedAt: "1970-01-01T00:00:00.000Z", + }), + getArchivedShellSnapshot: () => + Effect.succeed({ + snapshotSequence: 0, + projects: [], + threads: [], + updatedAt: "1970-01-01T00:00:00.000Z", + }), + searchThreads: () => Effect.succeed({ matches: [] }), + getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }), + getProjectShellById: () => Effect.succeed(Option.none()), + getThreadShellById: () => Effect.succeed(Option.none()), + getThreadDetailById: () => Effect.succeed(Option.none()), + getThreadDetailSnapshot: () => Effect.succeed(Option.none()), + getThreadLifecycleById: () => Effect.succeed(Option.none()), + getThreadActivitiesPage: () => Effect.die("unused"), + getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }), + getEventReplayStats: ({ fromSequenceExclusive, toSequenceInclusive }) => + Effect.succeed({ + eventCount: Math.max(0, toSequenceInclusive - fromSequenceExclusive), + payloadBytes: 0, + }), + getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()), + getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()), + getImportedAgentSessionSources: () => Effect.succeed([]), + getThreadCheckpointContext: () => Effect.succeed(Option.none()), + getFullThreadDiffContext: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.succeed(Option.none()), + ...options?.layers?.projectionSnapshotQuery, + }), + ), ), Layer.provide( Layer.mock(CheckpointDiffQuery.CheckpointDiffQuery)({ @@ -1271,6 +1336,15 @@ const appendSessionCookieToWsUrl = (url: string, sessionCookieHeader: string) => return isAbsoluteUrl ? next.toString() : `${next.pathname}${next.search}${next.hash}`; }; +const appendWsSearchParams = (url: string, params: Record) => { + const isAbsoluteUrl = /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(url); + const next = new URL(url, "http://localhost"); + for (const [key, value] of Object.entries(params)) { + next.searchParams.set(key, value); + } + return isAbsoluteUrl ? next.toString() : `${next.pathname}${next.search}${next.hash}`; +}; + const getHttpServerUrl = (pathname = "") => Effect.gen(function* () { const server = yield* HttpServer.HttpServer; @@ -1630,17 +1704,19 @@ const crossOriginClientOrigin = "http://remote-client.test:3773"; const getWsServerUrl = ( pathname = "", - options?: { authenticated?: boolean; credential?: string }, + options?: { authenticated?: boolean; credential?: string; productHandshake?: boolean }, ) => Effect.gen(function* () { const server = yield* HttpServer.HttpServer; const address = server.address as HttpServer.TcpAddress; const baseUrl = `ws://127.0.0.1:${address.port}${pathname}`; + const withProduct = + options?.productHandshake === false ? baseUrl : appendOmegentT3ProductHandshake(baseUrl); if (options?.authenticated === false) { - return baseUrl; + return withProduct; } return appendSessionCookieToWsUrl( - baseUrl, + withProduct, yield* getAuthenticatedSessionCookieHeader(options?.credential), ); }); @@ -1713,6 +1789,17 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); + it("exempts bootstrap paths from command readiness", () => { + assert.isTrue(isCommandReadinessExemptPath("/oauth/token")); + assert.isTrue(isCommandReadinessExemptPath("/oauth/token?grant_type=client_credentials")); + assert.isTrue(isCommandReadinessExemptPath("/.well-known/t3/environment")); + assert.isTrue(isCommandReadinessExemptPath("/api/t3-connect/health")); + assert.isTrue(isCommandReadinessExemptPath("/api/connect/health")); + assert.isFalse(isCommandReadinessExemptPath("/")); + assert.isFalse(isCommandReadinessExemptPath("/api/orchestration/snapshot")); + assert.isFalse(isCommandReadinessExemptPath("/api/auth/session")); + }); + it.effect("serves static index content for GET / when staticDir is configured", () => Effect.gen(function* () { const fileSystem = yield* FileSystem.FileSystem; @@ -1729,6 +1816,61 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); + it.effect("returns 503 when staticDir is set but index.html is missing", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const staticDir = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-router-static-empty-", + }); + + yield* buildAppUnderTest({ config: { staticDir } }); + + const response = yield* HttpClient.get("/"); + assert.equal(response.status, 503); + assert.include(yield* response.text, "Web assets unavailable"); + assert.equal(response.headers["retry-after"], "1"); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("recovers to a populated static tree when the boot staticDir loses index.html", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const emptyDir = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-router-static-stale-", + }); + const recoveredDir = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-router-static-recovered-", + }); + yield* fileSystem.writeFileString( + path.join(recoveredDir, "index.html"), + "recovered-static", + ); + + // Boot with an empty staticDir (simulates dist/client wiped mid-deploy). + // resolveStaticDir is not used when staticDir is explicit, so patch recovery + // by placing a monorepo-shaped sibling is not available here — instead we + // prove the 503 path still runs for a truly empty tree, and the happy path + // above still serves once index returns. Full monorepo recovery is covered + // by resolveStaticDir preferring apps/web/dist when client index is gone. + yield* buildAppUnderTest({ config: { staticDir: emptyDir } }); + const missing = yield* HttpClient.get("/"); + assert.equal(missing.status, 503); + + // A later request against a tree that gained index.html works without restart + // because each request re-reads disk for the configured staticDir. + yield* fileSystem.writeFileString( + path.join(emptyDir, "index.html"), + "recovered-static", + ); + const recovered = yield* HttpClient.get("/"); + assert.equal(recovered.status, 200); + assert.include(yield* recovered.text, "recovered-static"); + // Keep recoveredDir referenced so scoped cleanup order stays stable. + assert.isTrue(yield* fileSystem.exists(path.join(recoveredDir, "index.html"))); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + it.effect("revalidates static files without sending unchanged bodies", () => Effect.gen(function* () { const fileSystem = yield* FileSystem.FileSystem; @@ -4164,7 +4306,9 @@ it.layer(NodeServices.layer)("server router seam", (it) => { assert.equal(overbroadPairingBody.requiredScope, "orchestration:read"); assert.equal(pairingResponse.status, 200); assert.equal(wsTicketResponse.status, 200); - const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?wsTicket=${encodeURIComponent(wsTicketBody.ticket)}`; + const wsUrl = appendWsSearchParams(yield* getWsServerUrl("/ws", { authenticated: false }), { + wsTicket: wsTicketBody.ticket, + }); const rpcError = yield* Effect.flip( Effect.scoped(withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({}))), ); @@ -4514,7 +4658,9 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }); assert.equal(ticketResponse.status, 200); const { ticket } = (yield* ticketResponse.json) as { ticket: string }; - const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?wsTicket=${encodeURIComponent(ticket)}`; + const wsUrl = appendWsSearchParams(yield* getWsServerUrl("/ws", { authenticated: false }), { + wsTicket: ticket, + }); const frames: string[] = []; yield* withWsRpcClient( wsUrl, @@ -4978,7 +5124,9 @@ it.layer(NodeServices.layer)("server router seam", (it) => { const { cookie } = yield* bootstrapBrowserSession(); assert.isDefined(cookie); const sessionToken = extractSessionTokenFromSetCookie(cookie ?? ""); - const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?token=${encodeURIComponent(sessionToken)}`; + const wsUrl = appendWsSearchParams(yield* getWsServerUrl("/ws", { authenticated: false }), { + token: sessionToken, + }); const error = yield* Effect.flip( Effect.scoped(withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({}))), @@ -5006,7 +5154,9 @@ it.layer(NodeServices.layer)("server router seam", (it) => { const wsTicketBody = yield* responseJsonEffect<{ readonly ticket: string; }>(wsTicketResponse); - const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?wsTicket=${encodeURIComponent(wsTicketBody.ticket)}`; + const wsUrl = appendWsSearchParams(yield* getWsServerUrl("/ws", { authenticated: false }), { + wsTicket: wsTicketBody.ticket, + }); const response = yield* Effect.scoped( withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({})), @@ -5845,7 +5995,9 @@ it.layer(NodeServices.layer)("server router seam", (it) => { headers: { authorization: `Bearer ${token.body.access_token ?? ""}` }, }); const { ticket } = yield* responseJsonEffect<{ readonly ticket: string }>(ticketResponse); - const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?wsTicket=${encodeURIComponent(ticket)}`; + const wsUrl = appendWsSearchParams(yield* getWsServerUrl("/ws", { authenticated: false }), { + wsTicket: ticket, + }); yield* Effect.scoped( withWsRpcClient(wsUrl, (client) => Effect.gen(function* () { @@ -7742,6 +7894,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { operation: "pull", command: "git pull --ff-only", cwd: "/tmp/repo", + failureKind: "unknown", detail: "upstream missing", }); let invalidationCalls = 0; @@ -7822,6 +7975,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { operation: "commit", command: "git commit", cwd: "/tmp/repo", + failureKind: "unknown", detail: "nothing to commit", }); let invalidationCalls = 0; @@ -8139,6 +8293,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => { settledAt: null, latestTurn: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, session: null, activities: [], proposedPlans: [], @@ -8320,6 +8476,57 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); + it.effect( + "fails a thread subscription as permanently deleted when the thread row is deleted", + () => + Effect.gen(function* () { + yield* buildAppUnderTest({ + layers: { + projectionSnapshotQuery: { + getThreadLifecycleById: () => + Effect.succeed( + Option.some({ deletedAt: "2026-01-01T00:00:01.000Z", archivedAt: null }), + ), + }, + }, + }); + + const wsUrl = yield* getWsServerUrl("/ws"); + const result = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: defaultThreadId, + }).pipe(Stream.runCollect), + ).pipe(Effect.result), + ); + + assertTrue(result._tag === "Failure"); + assertTrue(result.failure._tag === "OrchestrationGetSnapshotError"); + assert.equal(result.failure.reason, "thread-deleted"); + assert.equal(result.failure.message, `Thread ${defaultThreadId} was deleted`); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("fails a thread subscription as retriable when no thread row exists yet", () => + Effect.gen(function* () { + yield* buildAppUnderTest({}); + + const wsUrl = yield* getWsServerUrl("/ws"); + const result = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: defaultThreadId, + }).pipe(Stream.runCollect), + ).pipe(Effect.result), + ); + + assertTrue(result._tag === "Failure"); + assertTrue(result.failure._tag === "OrchestrationGetSnapshotError"); + assert.equal(result.failure.reason, "thread-missing"); + assert.equal(result.failure.message, `Thread ${defaultThreadId} was not found`); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + it.effect("buffers shell events published while the fallback snapshot loads", () => Effect.gen(function* () { const liveEvents = yield* PubSub.unbounded(); @@ -9571,6 +9778,102 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); + it.effect("subscribeThread replaces a stale cursor with a fresh snapshot", () => + Effect.gen(function* () { + const snapshotSequence = 5_000; + const thread = makeDefaultOrchestrationReadModel().threads[0]!; + const liveEvents = yield* PubSub.unbounded(); + let replayCalls = 0; + const messageEvent = { + sequence: snapshotSequence + 1, + eventId: EventId.make("event-stale-cursor-message"), + aggregateKind: "thread", + aggregateId: defaultThreadId, + occurredAt: "2026-01-01T00:00:01.000Z", + commandId: null, + causationEventId: null, + correlationId: null, + metadata: {}, + type: "thread.message-sent", + payload: { + threadId: defaultThreadId, + messageId: MessageId.make("message-stale-cursor"), + role: "user", + text: "Published while loading the replacement snapshot", + turnId: null, + streaming: false, + createdAt: "2026-01-01T00:00:01.000Z", + updatedAt: "2026-01-01T00:00:01.000Z", + }, + } satisfies Extract; + + yield* buildAppUnderTest({ + layers: { + projectionSnapshotQuery: { + getThreadDetailSnapshot: () => + Effect.gen(function* () { + yield* Effect.sleep("25 millis"); + yield* PubSub.publish(liveEvents, messageEvent); + return Option.some({ + snapshotSequence, + thread, + }); + }), + }, + orchestrationEngine: { + // Oversized thread-local event count forces a snapshot instead of + // catch-up replay (THREAD_RESUME_MAX_EVENTS). Live events published + // while that snapshot loads must still drain after it. + latestSequence: Effect.succeed(snapshotSequence), + streamDomainEvents: Stream.fromPubSub(liveEvents), + getThreadReplayStats: () => + Effect.succeed({ + eventCount: 1_001, + payloadBytes: 1_000, + hasCreateEvent: false, + }), + readThreadEvents: () => Stream.die("Oversized resume must not replay thread events"), + readEvents: () => { + replayCalls += 1; + return Stream.empty; + }, + }, + }, + }); + + const wsUrl = yield* getWsServerUrl("/ws"); + const result = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: defaultThreadId, + afterSequence: 1, + requestCompletionMarker: true, + }).pipe(Stream.take(3), Stream.runCollect), + ), + ).pipe(Effect.timeout("2 seconds")); + + assert.equal(replayCalls, 0); + assert.equal(result[0]?.kind, "snapshot"); + if (result[0]?.kind === "snapshot") { + assert.equal(result[0].snapshot.snapshotSequence, snapshotSequence); + assert.equal(result[0].snapshot.thread.id, defaultThreadId); + } + // Live events buffered during snapshot load are drained via the same + // queue as the completion marker, so their relative order is not fixed. + // Both must appear after the snapshot; the global replay must not run. + const afterSnapshot = Array.from(result).slice(1); + assert.ok( + afterSnapshot.some((item) => item.kind === "synchronized"), + "expected synchronized completion marker after snapshot", + ); + const liveEvent = afterSnapshot.find((item) => item.kind === "event"); + assert.equal(liveEvent?.kind, "event"); + if (liveEvent?.kind === "event") { + assert.equal(liveEvent.event.sequence, snapshotSequence + 1); + } + }).pipe(Effect.provide(NodeHttpServer.layerTest), TestClock.withLive), + ); + it.effect("subscribeShell coalesces a per-thread burst without stalling other threads", () => Effect.gen(function* () { const busyThreadId = ThreadId.make("thread-busy"); @@ -10513,6 +10816,13 @@ it.layer(NodeServices.layer)("server router seam", (it) => { refName: "t3code/bootstrap-refName", path: "/tmp/bootstrap-worktree", }, + preparation: { + _tag: "degraded" as const, + attempts: 1, + command: "git hook run post-checkout", + detail: "ERR_PNPM_LOCKFILE_CONFIG_MISMATCH: catalogs differ", + exitCode: 17, + }, }; }), ); @@ -10551,6 +10861,17 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }), readEvents: () => Stream.empty, }, + projectionSnapshotQuery: { + getThreadShellById: (threadId) => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + worktreePath: "/tmp/bootstrap-worktree", + }), + ), + ), + }, projectSetupScriptRunner: { runForThread, }, @@ -10598,7 +10919,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { ), ); - assert.equal(response.sequence, 5); + assert.equal(response.sequence, 6); assert.deepEqual( dispatchedCommands.map((command) => command.type), [ @@ -10606,6 +10927,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { "thread.meta.update", "thread.activity.append", "thread.activity.append", + "thread.activity.append", "thread.turn.start", ], ); @@ -10614,6 +10936,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { refName: fetchedOriginCommit, newRefName: "t3code/bootstrap-refName", baseRefName: "main", + deferDependencyInstall: true, path: null, }); assert.deepEqual(fetchRemote.mock.calls[0]?.[0], { @@ -10651,9 +10974,18 @@ it.layer(NodeServices.layer)("server router seam", (it) => { ); assert.deepEqual( setupActivities.map((command) => command.activity.kind), - ["setup-script.requested", "setup-script.started"], + ["worktree-preparation.failed", "setup-script.requested", "setup-script.started"], ); - const finalCommand = dispatchedCommands[4]; + const preparationFailure = setupActivities[0]; + assert.equal(preparationFailure?.activity.tone, "error"); + assert.deepInclude(preparationFailure?.activity.payload, { + attempts: 1, + command: "git hook run post-checkout", + detail: "ERR_PNPM_LOCKFILE_CONFIG_MISMATCH: catalogs differ", + exitCode: 17, + worktreePath: "/tmp/bootstrap-worktree", + }); + const finalCommand = dispatchedCommands[5]; assertTrue(finalCommand?.type === "thread.turn.start"); if (finalCommand?.type === "thread.turn.start") { assert.equal(finalCommand.bootstrap, undefined); @@ -10712,6 +11044,20 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }), readEvents: () => Stream.empty, }, + // The fork's bootstrap waits for the worktree to appear in the + // projection before starting the provider; satisfy it the same way + // the neighbouring bootstrap tests do. + projectionSnapshotQuery: { + getThreadShellById: (threadId) => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + worktreePath: "/tmp/bootstrap-worktree", + }), + ), + ), + }, }, }); @@ -10779,37 +11125,46 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); - it.effect("records setup-script failures without aborting bootstrap turn start", () => + it.effect("checks out the base branch directly when bootstrap reuses it", () => Effect.gen(function* () { const dispatchedCommands: Array = []; + const fetchRemote = vi.fn( + (_: Parameters[0]) => Effect.void, + ); + const listRefs = vi.fn((_: Parameters[0]) => + Effect.succeed({ + refs: [ + { + name: "feature/base", + current: false, + isDefault: false, + worktreePath: null, + }, + ], + isRepo: true, + hasPrimaryRemote: true, + nextCursor: null, + totalCount: 1, + }), + ); const createWorktree = vi.fn( (_: Parameters[0]) => Effect.succeed({ worktree: { - refName: "t3code/bootstrap-refName", - path: "/tmp/bootstrap-worktree", + refName: "feature/base", + path: "/tmp/reuse-worktree", }, }), ); - const runForThread = vi.fn( - ( - input: Parameters< - ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]["runForThread"] - >[0], - ) => - Effect.fail( - new ProjectSetupScriptRunner.ProjectSetupScriptOperationError({ - threadId: input.threadId, - worktreePath: input.worktreePath, - operation: "openTerminal", - cause: { message: "pty unavailable" }, - }), - ), - ); yield* buildAppUnderTest({ layers: { + vcsDriver: { + isInsideWorkTree: () => Effect.succeed(true), + }, gitVcsDriver: { + fetchRemote, + listRefs, createWorktree, }, orchestrationEngine: { @@ -10820,8 +11175,16 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }), readEvents: () => Stream.empty, }, - projectSetupScriptRunner: { - runForThread, + projectionSnapshotQuery: { + getThreadShellById: (threadId) => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + worktreePath: "/tmp/reuse-worktree", + }), + ), + ), }, }, }); @@ -10832,10 +11195,10 @@ it.layer(NodeServices.layer)("server router seam", (it) => { withWsRpcClient(wsUrl, (client) => client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ type: "thread.turn.start", - commandId: CommandId.make("cmd-bootstrap-turn-start-setup-failure"), - threadId: ThreadId.make("thread-bootstrap-setup-failure"), + commandId: CommandId.make("cmd-bootstrap-reuse-branch"), + threadId: ThreadId.make("thread-bootstrap-reuse-branch"), message: { - messageId: MessageId.make("msg-bootstrap-setup-failure"), + messageId: MessageId.make("msg-bootstrap-reuse-branch"), role: "user", text: "hello", attachments: [], @@ -10850,37 +11213,649 @@ it.layer(NodeServices.layer)("server router seam", (it) => { modelSelection: defaultModelSelection, runtimeMode: "full-access", interactionMode: "default", - branch: "main", + branch: "feature/base", worktreePath: null, createdAt, }, prepareWorktree: { projectCwd: "/tmp/project", - baseBranch: "main", + baseBranch: "feature/base", branch: "t3code/bootstrap-refName", + startFromOrigin: true, + reuseBaseBranch: true, }, - runSetupScript: true, }, createdAt, }), ), ); - assert.equal(response.sequence, 4); + assert.equal(response.sequence, 3); assert.deepEqual( dispatchedCommands.map((command) => command.type), - ["thread.create", "thread.meta.update", "thread.activity.append", "thread.turn.start"], - ); - const setupFailureActivity = dispatchedCommands.find( - (command): command is Extract => - command.type === "thread.activity.append", + ["thread.create", "thread.meta.update", "thread.turn.start"], ); - assert.equal(setupFailureActivity?.activity.kind, "setup-script.failed"); - assert.deepEqual(setupFailureActivity?.activity.payload, { - detail: "pty unavailable", - worktreePath: "/tmp/bootstrap-worktree", + // Reuse wins over the requested new branch and origin refresh. + assert.equal(fetchRemote.mock.calls.length, 0); + assert.equal(listRefs.mock.calls.length, 1); + assert.deepEqual(createWorktree.mock.calls[0]?.[0], { + cwd: "/tmp/project", + refName: "feature/base", + path: null, }); - assertTrue(dispatchedCommands.every((command) => command.type !== "thread.delete")); + const metaUpdate = dispatchedCommands[1]; + assertTrue(metaUpdate?.type === "thread.meta.update"); + if (metaUpdate?.type === "thread.meta.update") { + assert.equal(metaUpdate.branch, "feature/base"); + assert.equal(metaUpdate.worktreePath, "/tmp/reuse-worktree"); + } + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("materializes a reused remote base branch as its derived local branch", () => + Effect.gen(function* () { + const dispatchedCommands: Array = []; + const listRefs = vi.fn((_: Parameters[0]) => + Effect.succeed({ + refs: [ + { + name: "origin/feature/base", + isRemote: true, + remoteName: "origin", + current: false, + isDefault: false, + worktreePath: null, + }, + ], + isRepo: true, + hasPrimaryRemote: true, + nextCursor: null, + totalCount: 1, + }), + ); + const createWorktree = vi.fn( + (_: Parameters[0]) => + Effect.succeed({ + worktree: { + refName: "feature/base", + path: "/tmp/reuse-worktree", + }, + }), + ); + + yield* buildAppUnderTest({ + layers: { + vcsDriver: { + isInsideWorkTree: () => Effect.succeed(true), + }, + gitVcsDriver: { + listRefs, + createWorktree, + }, + orchestrationEngine: { + dispatch: (command) => + Effect.sync(() => { + dispatchedCommands.push(command); + return { sequence: dispatchedCommands.length }; + }), + readEvents: () => Stream.empty, + }, + projectionSnapshotQuery: { + getThreadShellById: (threadId) => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + worktreePath: "/tmp/reuse-worktree", + }), + ), + ), + }, + }, + }); + + const createdAt = "2026-01-01T00:00:00.000Z"; + const wsUrl = yield* getWsServerUrl("/ws"); + yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-bootstrap-reuse-remote-branch"), + threadId: ThreadId.make("thread-bootstrap-reuse-remote-branch"), + message: { + messageId: MessageId.make("msg-bootstrap-reuse-remote-branch"), + role: "user", + text: "hello", + attachments: [], + }, + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + bootstrap: { + createThread: { + projectId: defaultProjectId, + title: "Bootstrap Thread", + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + branch: "origin/feature/base", + worktreePath: null, + createdAt, + }, + prepareWorktree: { + projectCwd: "/tmp/project", + baseBranch: "origin/feature/base", + reuseBaseBranch: true, + }, + }, + createdAt, + }), + ), + ); + + assert.deepEqual(createWorktree.mock.calls[0]?.[0], { + cwd: "/tmp/project", + refName: "origin/feature/base", + newRefName: "feature/base", + path: null, + }); + const metaUpdate = dispatchedCommands[1]; + assertTrue(metaUpdate?.type === "thread.meta.update"); + if (metaUpdate?.type === "thread.meta.update") { + assert.equal(metaUpdate.branch, "feature/base"); + } + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("resumes a replayed bootstrap after its thread was already created", () => + Effect.gen(function* () { + const dispatchedCommands: Array = []; + const threadId = ThreadId.make("thread-bootstrap-replay"); + + yield* buildAppUnderTest({ + layers: { + orchestrationEngine: { + dispatch: (command) => + Effect.suspend(() => { + dispatchedCommands.push(command); + return command.type === "thread.create" + ? Effect.fail( + new OrchestrationCommandInvariantError({ + commandType: "thread.create", + detail: `Thread '${threadId}' already exists and cannot be created twice.`, + }), + ) + : Effect.succeed({ sequence: dispatchedCommands.length }); + }), + readEvents: () => Stream.empty, + }, + projectionSnapshotQuery: { + getThreadShellById: () => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + }), + ), + ), + }, + }, + }); + + const createdAt = "2026-01-01T00:00:00.000Z"; + const wsUrl = yield* getWsServerUrl("/ws"); + const response = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-bootstrap-replay"), + threadId, + message: { + messageId: MessageId.make("msg-bootstrap-replay"), + role: "user", + text: "hello after reconnect", + attachments: [], + }, + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + bootstrap: { + createThread: { + projectId: defaultProjectId, + title: "Bootstrap Replay", + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + branch: "main", + worktreePath: null, + createdAt, + }, + }, + createdAt, + }), + ), + ); + + assert.equal(response.sequence, 2); + assert.deepEqual( + dispatchedCommands.map((command) => command.type), + ["thread.create", "thread.turn.start"], + ); + assertTrue(dispatchedCommands.every((command) => command.type !== "thread.delete")); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("reuses the existing worktree when a replayed bootstrap already prepared it", () => + Effect.gen(function* () { + const dispatchedCommands: Array = []; + const threadId = ThreadId.make("thread-bootstrap-replay-worktree"); + const fs = yield* FileSystem.FileSystem; + // Path must exist: bootstrap reuses only when the recorded worktree is still on disk. + const existingWorktreePath = yield* fs.makeTempDirectoryScoped(); + const createWorktree = vi.fn( + (_: Parameters[0]) => + Effect.die(new Error("fatal: a branch named 't3code/replay' already exists")), + ); + const refreshStatus = vi.fn((_: string) => + Effect.succeed({ + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "t3code/replay", + hasWorkingTreeChanges: false, + workingTree: { + files: [], + insertions: 0, + deletions: 0, + }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + pr: null, + }), + ); + const runForThread = vi.fn( + ( + _: Parameters< + ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]["runForThread"] + >[0], + ) => + Effect.succeed({ + status: "started" as const, + scriptId: "setup", + scriptName: "Setup", + terminalId: "setup-setup", + cwd: existingWorktreePath, + }), + ); + + yield* buildAppUnderTest({ + layers: { + gitVcsDriver: { + createWorktree, + }, + vcsStatusBroadcaster: { + refreshStatus, + }, + orchestrationEngine: { + dispatch: (command) => + Effect.suspend(() => { + dispatchedCommands.push(command); + return command.type === "thread.create" + ? Effect.fail( + new OrchestrationCommandInvariantError({ + commandType: "thread.create", + detail: `Thread '${threadId}' already exists and cannot be created twice.`, + }), + ) + : Effect.succeed({ sequence: dispatchedCommands.length }); + }), + readEvents: () => Stream.empty, + }, + projectionSnapshotQuery: { + getThreadShellById: () => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + branch: "t3code/replay", + worktreePath: existingWorktreePath, + }), + ), + ), + }, + projectSetupScriptRunner: { + runForThread, + }, + }, + }); + + const createdAt = "2026-01-01T00:00:00.000Z"; + const wsUrl = yield* getWsServerUrl("/ws"); + const response = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-bootstrap-replay-worktree"), + threadId, + message: { + messageId: MessageId.make("msg-bootstrap-replay-worktree"), + role: "user", + text: "hello after replay", + attachments: [], + }, + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + bootstrap: { + createThread: { + projectId: defaultProjectId, + title: "Bootstrap Replay Worktree", + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + branch: "main", + worktreePath: null, + createdAt, + }, + prepareWorktree: { + projectCwd: "/tmp/project", + baseBranch: "main", + branch: "t3code/replay", + startFromOrigin: true, + }, + runSetupScript: true, + }, + createdAt, + }), + ), + ); + + assert.equal(response.sequence, 2); + assert.deepEqual( + dispatchedCommands.map((command) => command.type), + ["thread.create", "thread.turn.start"], + ); + assert.equal(createWorktree.mock.calls.length, 0); + assert.equal(runForThread.mock.calls.length, 0); + assert.deepEqual(refreshStatus.mock.calls[0]?.[0], existingWorktreePath); + assertTrue(dispatchedCommands.every((command) => command.type !== "thread.delete")); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("recreates a missing worktree path for a replayed bootstrap with a branch", () => + Effect.gen(function* () { + const dispatchedCommands: Array = []; + const threadId = ThreadId.make("thread-bootstrap-recreate-worktree"); + const missingWorktreePath = "/tmp/does-not-exist-bootstrap-worktree"; + const createWorktree = vi.fn( + (input: Parameters[0]) => + Effect.succeed({ + worktree: { + refName: input.newRefName ?? input.refName, + path: input.path ?? missingWorktreePath, + }, + }), + ); + const refreshStatus = vi.fn((_: string) => + Effect.succeed({ + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "t3code/recreate", + hasWorkingTreeChanges: false, + workingTree: { + files: [], + insertions: 0, + deletions: 0, + }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + pr: null, + }), + ); + const runForThread = vi.fn( + ( + _: Parameters< + ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]["runForThread"] + >[0], + ) => + Effect.succeed({ + status: "started" as const, + scriptId: "setup", + scriptName: "Setup", + terminalId: "setup-setup", + cwd: missingWorktreePath, + }), + ); + + yield* buildAppUnderTest({ + layers: { + gitVcsDriver: { + createWorktree, + }, + vcsStatusBroadcaster: { + refreshStatus, + }, + orchestrationEngine: { + dispatch: (command) => + Effect.suspend(() => { + dispatchedCommands.push(command); + return command.type === "thread.create" + ? Effect.fail( + new OrchestrationCommandInvariantError({ + commandType: "thread.create", + detail: `Thread '${threadId}' already exists and cannot be created twice.`, + }), + ) + : Effect.succeed({ sequence: dispatchedCommands.length }); + }), + readEvents: () => Stream.empty, + }, + projectionSnapshotQuery: { + getThreadShellById: () => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + branch: "t3code/recreate", + worktreePath: missingWorktreePath, + }), + ), + ), + }, + projectSetupScriptRunner: { + runForThread, + }, + }, + }); + + const createdAt = "2026-01-01T00:00:00.000Z"; + const wsUrl = yield* getWsServerUrl("/ws"); + const response = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-bootstrap-recreate-worktree"), + threadId, + message: { + messageId: MessageId.make("msg-bootstrap-recreate-worktree"), + role: "user", + text: "hello after gc", + attachments: [], + }, + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + bootstrap: { + createThread: { + projectId: defaultProjectId, + title: "Bootstrap Recreate Worktree", + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + branch: "main", + worktreePath: null, + createdAt, + }, + prepareWorktree: { + projectCwd: "/tmp/project", + baseBranch: "main", + branch: "t3code/recreate", + startFromOrigin: true, + }, + runSetupScript: true, + }, + createdAt, + }), + ), + ); + + // create (failed duplicate) + meta.update + setup-script.requested/started + turn.start + assert.equal(response.sequence, 5); + assert.deepEqual( + dispatchedCommands.map((command) => command.type), + [ + "thread.create", + "thread.meta.update", + "thread.activity.append", + "thread.activity.append", + "thread.turn.start", + ], + ); + // Re-add at the same path for the existing branch; no origin fetch / new branch. + assert.equal(createWorktree.mock.calls.length, 1); + assert.deepEqual(createWorktree.mock.calls[0]?.[0], { + cwd: "/tmp/project", + refName: "t3code/recreate", + path: missingWorktreePath, + deferDependencyInstall: true, + }); + assert.equal(runForThread.mock.calls.length, 1); + assert.deepEqual(refreshStatus.mock.calls[0]?.[0], missingWorktreePath); + const metaUpdate = dispatchedCommands[1]; + assertTrue(metaUpdate?.type === "thread.meta.update"); + if (metaUpdate?.type === "thread.meta.update") { + assert.equal(metaUpdate.branch, "t3code/recreate"); + assert.equal(metaUpdate.worktreePath, missingWorktreePath); + } + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("records setup-script failures without aborting bootstrap turn start", () => + Effect.gen(function* () { + const dispatchedCommands: Array = []; + const createWorktree = vi.fn( + (_: Parameters[0]) => + Effect.succeed({ + worktree: { + refName: "t3code/bootstrap-refName", + path: "/tmp/bootstrap-worktree", + }, + }), + ); + const runForThread = vi.fn( + ( + input: Parameters< + ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]["runForThread"] + >[0], + ) => + Effect.fail( + new ProjectSetupScriptRunner.ProjectSetupScriptOperationError({ + threadId: input.threadId, + worktreePath: input.worktreePath, + operation: "openTerminal", + cause: { message: "pty unavailable" }, + }), + ), + ); + + yield* buildAppUnderTest({ + layers: { + gitVcsDriver: { + createWorktree, + }, + orchestrationEngine: { + dispatch: (command) => + Effect.sync(() => { + dispatchedCommands.push(command); + return { sequence: dispatchedCommands.length }; + }), + readEvents: () => Stream.empty, + }, + projectionSnapshotQuery: { + getThreadShellById: (threadId) => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + worktreePath: "/tmp/bootstrap-worktree", + }), + ), + ), + }, + projectSetupScriptRunner: { + runForThread, + }, + }, + }); + + const createdAt = "2026-01-01T00:00:00.000Z"; + const wsUrl = yield* getWsServerUrl("/ws"); + const response = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-bootstrap-turn-start-setup-failure"), + threadId: ThreadId.make("thread-bootstrap-setup-failure"), + message: { + messageId: MessageId.make("msg-bootstrap-setup-failure"), + role: "user", + text: "hello", + attachments: [], + }, + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + bootstrap: { + createThread: { + projectId: defaultProjectId, + title: "Bootstrap Thread", + modelSelection: defaultModelSelection, + runtimeMode: "full-access", + interactionMode: "default", + branch: "main", + worktreePath: null, + createdAt, + }, + prepareWorktree: { + projectCwd: "/tmp/project", + baseBranch: "main", + branch: "t3code/bootstrap-refName", + }, + runSetupScript: true, + }, + createdAt, + }), + ), + ); + + assert.equal(response.sequence, 4); + assert.deepEqual( + dispatchedCommands.map((command) => command.type), + ["thread.create", "thread.meta.update", "thread.activity.append", "thread.turn.start"], + ); + const setupFailureActivity = dispatchedCommands.find( + (command): command is Extract => + command.type === "thread.activity.append", + ); + assert.equal(setupFailureActivity?.activity.kind, "setup-script.failed"); + assert.deepEqual(setupFailureActivity?.activity.payload, { + detail: "pty unavailable", + worktreePath: "/tmp/bootstrap-worktree", + }); + assertTrue(dispatchedCommands.every((command) => command.type !== "thread.delete")); }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); @@ -10941,6 +11916,17 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }, readEvents: () => Stream.empty, }, + projectionSnapshotQuery: { + getThreadShellById: (threadId) => + Effect.succeed( + Option.some( + makeDefaultOrchestrationThreadShell({ + id: threadId, + worktreePath: "/tmp/bootstrap-worktree", + }), + ), + ), + }, projectSetupScriptRunner: { runForThread, }, @@ -11007,7 +11993,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); - it.effect("cleans up created bootstrap threads when worktree creation defects", () => + it.effect("preserves created bootstrap threads when worktree creation defects", () => Effect.gen(function* () { const dispatchedCommands: Array = []; const fileSystem = yield* FileSystem.FileSystem; @@ -11455,7 +12441,12 @@ it.live( const baseUrl = yield* getHttpServerUrl(); const cookie = yield* getAuthenticatedSessionCookieHeader(); - const wsUrl = baseUrl.replace(/^http:/, "ws:") + "/ws"; + // This environment only accepts omegent-t3 clients, so the + // measurement socket must carry the product handshake like every + // other client does. + const wsUrl = appendOmegentT3ProductHandshake( + baseUrl.replace(/^http:/, "ws:") + "/ws", + ); return yield* Effect.scoped( Effect.gen(function* () { diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index e3b42a2637a1..89b3d16e6266 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -6,11 +6,9 @@ import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Schedule from "effect/Schedule"; import * as Stream from "effect/Stream"; -import { FetchHttpClient, HttpRouter, HttpServer } from "effect/unstable/http"; +import { FetchHttpClient, HttpRouter, HttpServer, HttpServerRequest } from "effect/unstable/http"; import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder"; -import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; -import * as HostPowerMonitor from "./background/HostPowerMonitor.ts"; import * as ServerConfig from "./config.ts"; import { otlpTracesProxyRouteLayer, @@ -45,6 +43,7 @@ import { ProviderRegistry } from "./provider/Services/ProviderRegistry.ts"; import { ProviderSessionReaperLive } from "./provider/Layers/ProviderSessionReaper.ts"; import { ProviderUsageLimitsIngestionLive } from "./provider/Layers/ProviderUsageLimitsIngestion.ts"; import * as OpenCodeRuntime from "./provider/opencodeRuntime.ts"; +import * as DirenvEnvironment from "./provider/DirenvEnvironment.ts"; import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts"; import * as CheckpointStore from "./checkpointing/CheckpointStore.ts"; import * as AzureDevOpsCli from "./sourceControl/AzureDevOpsCli.ts"; @@ -60,9 +59,12 @@ import * as PreviewAutomationBroker from "./mcp/PreviewAutomationBroker.ts"; import * as DeviceService from "./device/DeviceService.ts"; import { deviceHubProxyRouteLayer } from "./device/DeviceHubProxy.ts"; import * as PreviewManager from "./preview/Manager.ts"; +import * as PortExposure from "./preview/PortExposure.ts"; import * as PortScanner from "./preview/PortScanner.ts"; +import * as AiUsageMonitor from "./aiUsage/AiUsageMonitor.ts"; import * as ProcessRunner from "./processRunner.ts"; import * as GitManager from "./git/GitManager.ts"; +import * as PrLookupFreeze from "./git/PrLookupFreeze.ts"; import * as EnvironmentTheme from "./environmentTheme.ts"; import * as Keybindings from "./keybindings.ts"; import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts"; @@ -72,6 +74,7 @@ import { ProviderRuntimeIngestionLive } from "./orchestration/Layers/ProviderRun import { ProviderCommandReactorLive } from "./orchestration/Layers/ProviderCommandReactor.ts"; import { CheckpointReactorLive } from "./orchestration/Layers/CheckpointReactor.ts"; import { ThreadDeletionReactorLive } from "./orchestration/Layers/ThreadDeletionReactor.ts"; +import { WorktreeLifecycleLive } from "./orchestration/Layers/WorktreeLifecycle.ts"; import * as ThreadSettlementReactor from "./orchestration/ThreadSettlementReactor.ts"; import * as PullRequestSyncReactor from "./orchestration/PullRequestSyncReactor.ts"; import * as ThreadPullRequestReactor from "./orchestration/ThreadPullRequestReactor.ts"; @@ -81,6 +84,7 @@ import { ProviderRegistryLive } from "./provider/Layers/ProviderRegistry.ts"; import * as ServerSettings from "./serverSettings.ts"; import * as NativeAppIconResolver from "./assets/NativeAppIconResolver.ts"; import * as ProjectFaviconResolver from "./project/ProjectFaviconResolver.ts"; +import * as DevStackReaper from "./devStacks/DevStackReaper.ts"; import * as T3ProjectFileLoader from "./project/T3ProjectFileLoader.ts"; import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts"; import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts"; @@ -98,12 +102,14 @@ import * as SourceControlProviderRegistry from "./sourceControl/SourceControlPro import * as PullRequestReadCache from "./pullRequest/PullRequestReadCache.ts"; import * as SourceControlRateLimit from "./sourceControl/SourceControlRateLimit.ts"; import * as SourceControlRepositoryService from "./sourceControl/SourceControlRepositoryService.ts"; +import * as ProjectLifecycleScriptRunner from "./project/ProjectLifecycleScriptRunner.ts"; import * as ProjectSetupScriptRunner from "./project/ProjectSetupScriptRunner.ts"; import { ObservabilityLive } from "./observability/Layers/Observability.ts"; import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts"; import { authHttpApiLayer, environmentAuthenticatedAuthLayer } from "./auth/http.ts"; import * as ServerSecretStore from "./auth/ServerSecretStore.ts"; +import * as IdentityService from "./identity/IdentityService.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import { connectHttpApiLayer, @@ -120,14 +126,19 @@ import * as ServerSelfUpdate from "./cloud/selfUpdate.ts"; import * as DesktopAppUpdate from "./desktopUpdate/DesktopAppUpdate.ts"; import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts"; import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts"; +import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts"; +import * as HostPowerMonitor from "./background/HostPowerMonitor.ts"; +import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinary.ts"; import * as HostResources from "./resourceTelemetry/HostResources.ts"; -import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; -import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts"; import * as DesktopTelemetryReceiver from "./resourceTelemetry/DesktopTelemetryReceiver.ts"; import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClient.ts"; -import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts"; -import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinary.ts"; import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts"; +import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; +import * as HostResourceProbe from "./diagnostics/HostResourceProbe.ts"; +import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; +import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts"; +import { GrokTranscriptResyncLive } from "./externalSessions/GrokTranscriptResync.ts"; +import { OrphanSessionRecoveryLive } from "./orchestration/Layers/OrphanSessionRecovery.ts"; import * as UsageLimitSources from "./usage/UsageLimitSources.ts"; import * as UsageService from "./usage/UsageService.ts"; import { OrchestrationLayerLive } from "./orchestration/runtimeLayer.ts"; @@ -137,6 +148,18 @@ import { persistServerRuntimeState, } from "./serverRuntimeState.ts"; import { orchestrationHttpApiLayer } from "./orchestration/http.ts"; +import * as GitHubAppClient from "./github/GitHubAppClient.ts"; +import * as GitHubAppConfig from "./github/GitHubAppConfig.ts"; +import * as GitHubDeliveryStore from "./github/GitHubDeliveryStore.ts"; +import * as GitHubPrBridge from "./github/GitHubPrBridge.ts"; +import { githubWebhookRouteLayer } from "./github/http.ts"; +import * as JiraAppClient from "./jira/JiraAppClient.ts"; +import * as JiraAppConfig from "./jira/JiraAppConfig.ts"; +import * as JiraDeliveryStore from "./jira/JiraDeliveryStore.ts"; +import * as JiraIssueBridge from "./jira/JiraIssueBridge.ts"; +import { jiraWebhookRouteLayer } from "./jira/http.ts"; +import * as WebhookDebugLog from "./webhooks/WebhookDebugLog.ts"; +import * as ThreadWorkItemStore from "./workItems/ThreadWorkItemStore.ts"; import * as NetService from "@t3tools/shared/Net"; import * as RelayClient from "@t3tools/shared/relayClient"; import { disableTailscaleServe, ensureTailscaleServe } from "@t3tools/tailscale"; @@ -153,10 +176,6 @@ export const HTTP_ROUTER_CONFIG = { // already closes the websocket gracefully. Do not add an artificial drain before // those finalizers get a chance to run. const HTTP_PREEMPTIVE_SHUTDOWN_GRACE_MS = 0; -const ResourceAttributionLayerLive = ResourceAttribution.layer; -const ApplicationObservabilityLive = ObservabilityLive.pipe( - Layer.provideMerge(ResourceAttributionLayerLive), -); const PtyAdapterLive = Layer.unwrap( Effect.gen(function* () { @@ -170,6 +189,11 @@ const PtyAdapterLive = Layer.unwrap( }), ); +const ResourceAttributionLayerLive = ResourceAttribution.layer; +const ApplicationObservabilityLive = ObservabilityLive.pipe( + Layer.provideMerge(ResourceAttributionLayerLive), +); + const ServerSettingsLayerLive = ServerSettings.layer.pipe( Layer.provide(ServerSecretStore.layer), Layer.provideMerge(SqlitePersistenceLayerLive), @@ -178,6 +202,7 @@ const ServerSettingsLayerLive = ServerSettings.layer.pipe( const NativeTelemetryLayerLive = NativeTelemetryClient.layer.pipe( Layer.provide(ResourceMonitorBinary.layer), ); + const DesktopTelemetryReceiverLayerLive = DesktopTelemetryReceiver.layer.pipe( Layer.provideMerge(ServerSettingsLayerLive), ); @@ -297,7 +322,7 @@ const ProviderSessionDirectoryLayerLive = ProviderSessionDirectoryLive.pipe( // `ProviderAdapterRegistryLive` is now a facade that resolves kind → adapter // by looking up the default `ProviderInstance` per driver in the instance // registry. Adapter construction itself moved inside each driver's -// `create()`; `ProviderEventLoggers.layer` owns the shared native/canonical +// `create()`; `ProviderEventLoggersLive` owns the shared native/canonical // NDJSON writers and is provided at the outer runtime layer so both // `ProviderService` and the per-instance drivers read the same logger pair. const ProviderLayerLive = ProviderServiceLive.pipe( @@ -307,6 +332,11 @@ const ProviderLayerLive = ProviderServiceLive.pipe( const PersistenceLayerLive = Layer.empty.pipe(Layer.provideMerge(SqlitePersistenceLayerLive)); +/** Durable identity claims — residual-free once Persistence/SqlClient is in the graph. */ +const IdentityLayerLive = IdentityService.layerPersisted.pipe( + Layer.provideMerge(PersistenceLayerLive), +); + const VcsDriverRegistryLayerLive = VcsDriverRegistry.layer.pipe( Layer.provide(VcsProjectConfig.layer), ); @@ -319,6 +349,10 @@ const SourceControlProviderRegistryLayerLive = SourceControlProviderRegistry.lay Layer.provideMerge(VcsDriverRegistryLayerLive), ); +// Single process-wide freeze map: GitManager (skip PR API) and the +// projection pipeline (settle/unsettle) must share the same instance. +const PrLookupFreezeLive = PrLookupFreeze.layer; + const PullRequestServiceLive = PullRequestService.layer.pipe( Layer.provide(PullRequestProviderRegistry.layer), Layer.provide(PullRequestReadCache.layer), @@ -331,6 +365,11 @@ const GitManagerLayerLive = GitManager.layer.pipe( Layer.provideMerge(GitVcsDriver.layer), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(TextGeneration.layer), + Layer.provide(PrLookupFreezeLive), +); + +const ProjectLifecycleScriptRunnerLayerLive = ProjectLifecycleScriptRunner.layer.pipe( + Layer.provide(ProcessRunner.layer), ); const GitLayerLive = Layer.empty.pipe( @@ -341,6 +380,7 @@ const GitLayerLive = Layer.empty.pipe( const GitWorkflowLayerLive = GitWorkflowService.layer.pipe( Layer.provideMerge(VcsDriverRegistryLayerLive), Layer.provideMerge(GitLayerLive), + Layer.provideMerge(ProjectLifecycleScriptRunnerLayerLive), ); const SourceControlRepositoryServiceLayerLive = SourceControlRepositoryService.layer.pipe( @@ -353,6 +393,32 @@ const ReviewLayerLive = ReviewService.layer.pipe( Layer.provideMerge(VcsDriverRegistryLayerLive), ); +/** Shared once for GitHub + Jira bridges (Jira keys / PR URLs → threads). */ +const ThreadWorkItemStoreLive = ThreadWorkItemStore.layer; + +const GitHubAppDependenciesLive = Layer.mergeAll( + GitHubAppClient.layer, + GitHubDeliveryStore.layer, +).pipe(Layer.provideMerge(GitHubAppConfig.layer)); + +const GitHubPrBridgeLive = GitHubPrBridge.layer.pipe( + Layer.provideMerge(GitHubAppDependenciesLive), + Layer.provideMerge(ThreadWorkItemStoreLive), + Layer.provideMerge(IdentityLayerLive), +); + +const JiraAppDependenciesLive = Layer.mergeAll(JiraAppClient.layer, JiraDeliveryStore.layer).pipe( + Layer.provideMerge(JiraAppConfig.layer), +); + +const JiraIssueBridgeLive = JiraIssueBridge.layer.pipe( + Layer.provideMerge(JiraAppDependenciesLive), + // Prefer the instance already provided by GitHubPrBridgeLive when merged below. + Layer.provideMerge(ThreadWorkItemStoreLive), + // Closed-set map for trusted vs context-only Jira actors. + Layer.provideMerge(IdentityLayerLive), +); + const VcsLayerLive = Layer.empty.pipe( Layer.provideMerge(VcsProjectConfig.layer), Layer.provideMerge(VcsDriverRegistryLayerLive), @@ -383,8 +449,17 @@ const TerminalLayerLive = TerminalManager.layer.pipe( Layer.provide(NativeTelemetryLayerLive), ); +// Self-contained: the HTTP client is only used to prove a published port +// answers, and the Net service only to notice a dev server that has exited. +// Neither belongs in the requirements of everything that renders a preview. +const PortExposureLayerLive = PortExposure.layer.pipe( + Layer.provide(FetchHttpClient.layer), + Layer.provide(NetService.layer), +); + const PreviewLayerLive = Layer.empty.pipe( Layer.provideMerge(PreviewManager.layer), + Layer.provideMerge(PortExposureLayerLive), Layer.provideMerge(PortScannerLayerLive), ); @@ -412,6 +487,10 @@ const ProjectFaviconResolverLayerLive = ProjectFaviconResolver.layer.pipe( Layer.provide(T3ProjectFileLoader.layer), ); +// Self-contained: the sweep reads the dev-stack registry and /proc directly, and +// only needs t3.json to learn each repository's declared policy. +const DevStackReaperLayerLive = DevStackReaper.layer.pipe(Layer.provide(T3ProjectFileLoader.layer)); + const ServerEnvironmentLayerLive = ServerEnvironment.layer.pipe( Layer.provide(ServerSecretStore.layer), ); @@ -430,11 +509,24 @@ const CloudManagedEndpointRuntimeLive = Layer.mergeAll( ), ); +const OrphanSessionRecoveryLayerLive = OrphanSessionRecoveryLive.pipe( + Layer.provide(ProviderLayerLive), + Layer.provide(OrchestrationLayerLive), +); + const ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe( // Subscribes to `account.rate-limits.updated` so usage bars track live // telemetry instead of waiting for the next status probe. Layer.provideMerge(ProviderUsageLimitsIngestionLive), Layer.provideMerge(ProviderLayerLive), + Layer.provideMerge(OrphanSessionRecoveryLayerLive), + Layer.provideMerge( + GrokTranscriptResyncLive.pipe( + Layer.provide(ProviderSessionRuntime.layer), + Layer.provide(OrphanSessionRecoveryLayerLive), + Layer.provide(OrchestrationLayerLive), + ), + ), Layer.provideMerge(OrchestrationLayerLive), ); @@ -469,15 +561,23 @@ const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe( Layer.provideMerge(AntigravityInstallationRefreshLive), Layer.provideMerge(ProviderAuthServiceLive), // Core Services + Layer.provideMerge(Layer.mergeAll(WorktreeLifecycleLive, CheckpointingLayerLive)), Layer.provideMerge(ServerSettingsLayerLive), - Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge( Layer.mergeAll(SourceControlProviderRegistryLayerLive, PullRequestServiceLive), ), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), - Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive, DeviceLayerLive)), + Layer.provideMerge( + Layer.mergeAll( + TerminalLayerLive, + PreviewLayerLive, + DeviceLayerLive, + AiUsageMonitor.layer, + DevStackReaperLayerLive, + ), + ), Layer.provideMerge(PersistenceLayerLive), // Both read a user-owned file out of the state directory and stream changes // to clients; neither depends on the other. @@ -502,7 +602,12 @@ const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe( // from the repo's `model-manifest.json` on `main` and applied by the // Codex/Claude drivers. Layer.provideMerge( - Layer.mergeAll(ProviderEventLoggers.layer, ModelManifest.layer, CodexResetCredit.layer), + Layer.mergeAll( + ProviderEventLoggers.layer, + DirenvEnvironment.layerLive, + ModelManifest.layer, + CodexResetCredit.layer, + ), ), // `OpenCodeDriver.create()` yields `OpenCodeRuntime`; previously the old // `ProviderRegistryLive` pulled `OpenCodeRuntimeLive` in for itself, but @@ -527,10 +632,21 @@ const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe( ), ); -const RuntimeDependenciesLive = RuntimeCoreDependenciesLive.pipe( +const RuntimeCoreWithGitHubLive = GitHubPrBridgeLive.pipe( + Layer.provideMerge(RuntimeCoreDependenciesLive), +); + +const RuntimeCoreWithIntegrationsLive = JiraIssueBridgeLive.pipe( + Layer.provideMerge(RuntimeCoreWithGitHubLive), + // Shared 24h NDJSON debug logs for GitHub + Jira inbound webhooks. + Layer.provideMerge(WebhookDebugLog.layer), +); + +const RuntimeDependenciesLive = RuntimeCoreWithIntegrationsLive.pipe( // Misc. Layer.provideMerge(BackgroundLayerLive), Layer.provideMerge(ResourceDiagnosticsLayerLive), + Layer.provideMerge(HostResourceProbe.layer), Layer.provideMerge(UsageLayerLive), Layer.provideMerge(TraceDiagnostics.layer), Layer.provideMerge(AnalyticsService.layer), @@ -540,11 +656,32 @@ const RuntimeDependenciesLive = RuntimeCoreDependenciesLive.pipe( Layer.provide(NetService.layer), ); +/** + * Bootstrap / liveness surfaces that must not wait for provider recovery or the + * broader command-readiness gate. Discord bot token exchange and environment + * discovery hang the whole client fleet if they sit behind a stuck recovery turn. + */ +export function isCommandReadinessExemptPath(url: string): boolean { + const pathOnly = (url.split("?", 1)[0] ?? url).split("#", 1)[0] ?? url; + return ( + pathOnly === "/oauth/token" || + pathOnly === "/.well-known/t3/environment" || + pathOnly === "/api/t3-connect/health" || + pathOnly === "/api/connect/health" + ); +} + const commandReadinessLayer = HttpRouter.middleware( (httpEffect) => - Effect.flatMap(ServerRuntimeStartup.ServerRuntimeStartup, (startup) => - startup.awaitCommandReady.pipe(Effect.orDie, Effect.andThen(httpEffect)), - ), + Effect.gen(function* () { + const request = yield* HttpServerRequest.HttpServerRequest; + if (isCommandReadinessExemptPath(request.url)) { + return yield* httpEffect; + } + const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup; + yield* startup.awaitCommandReady.pipe(Effect.orDie); + return yield* httpEffect; + }), { global: true }, ); @@ -567,6 +704,8 @@ export const makeRoutesLayer = Layer.mergeAll( ), McpHttpServer.layer.pipe(Layer.provide(McpSessionRegistry.layer)), ).pipe( + // IdentityService is residual here — tests provide layerWithPeople / memory; + // makeServerLayer provides layerPersisted (SQLite claims) once SqlClient is live. // Both transports consume the same service instance, so caches single-flight across clients // and mutations observed on WebSocket invalidate patches subsequently read over HTTP. Layer.provide(PullRequestServiceLive), @@ -577,6 +716,12 @@ export const makeRoutesLayer = Layer.mergeAll( Layer.provide(httpCompressionLayer), ); +const productionRoutesLayer = Layer.mergeAll( + makeRoutesLayer, + githubWebhookRouteLayer, + jiraWebhookRouteLayer, +); + const makeServerLayer = Layer.unwrap( Effect.gen(function* () { const config = yield* ServerConfig.ServerConfig; @@ -764,7 +909,7 @@ const makeServerLayer = Layer.unwrap( ).pipe(Effect.asVoid), }).pipe(Layer.provideMerge(RuntimeDependenciesLive), Layer.provide(launcherLayer)); - const routesLayer = HttpRouter.serve(makeRoutesLayer.pipe(Layer.provide(launcherLayer)), { + const routesLayer = HttpRouter.serve(productionRoutesLayer.pipe(Layer.provide(launcherLayer)), { disableLogger: !config.logWebSocketEvents, routerConfig: HTTP_ROUTER_CONFIG, }).pipe(Layer.tap(() => Deferred.succeed(routesReady, undefined).pipe(Effect.orDie))); @@ -779,6 +924,8 @@ const makeServerLayer = Layer.unwrap( return serverApplicationLayer.pipe( Layer.provideMerge(runtimeServicesLive), Layer.provide(activationLayer), + // Durable claims for HTTP/WS routes (residual-free; SQL from Persistence). + Layer.provideMerge(IdentityLayerLive), Layer.provideMerge(serverRelayBrokerTracingLayer), Layer.provideMerge(HttpServerLive), Layer.provide(ApplicationObservabilityLive), diff --git a/apps/server/src/serverLifecycleEvents.ts b/apps/server/src/serverLifecycleEvents.ts index 855d03490efe..ab3037080bd2 100644 --- a/apps/server/src/serverLifecycleEvents.ts +++ b/apps/server/src/serverLifecycleEvents.ts @@ -8,7 +8,8 @@ import * as Stream from "effect/Stream"; type LifecycleEventInput = | Omit, "sequence"> - | Omit, "sequence">; + | Omit, "sequence"> + | Omit, "sequence">; interface SnapshotState { readonly sequence: number; @@ -39,10 +40,12 @@ const make = Effect.gen(function* () { ...event, sequence: nextSequence, } satisfies ServerLifecycleStreamEvent; - const nextEvents = - nextEvent.type === "welcome" - ? [nextEvent, ...current.events.filter((entry) => entry.type !== "welcome")] - : [nextEvent, ...current.events.filter((entry) => entry.type !== "ready")]; + // Keep only the latest event of each type in the replay snapshot, so a + // connecting client sees the current welcome, ready, and web version. + const nextEvents = [ + nextEvent, + ...current.events.filter((entry) => entry.type !== nextEvent.type), + ]; return [nextEvent, { sequence: nextSequence, events: nextEvents }] as const; }).pipe(Effect.tap((event) => PubSub.publish(pubsub, event))), snapshot: Ref.get(state), diff --git a/apps/server/src/serverRuntimeStartup.reconcile.test.ts b/apps/server/src/serverRuntimeStartup.reconcile.test.ts index 37fd210ee6da..f278d5ff6b98 100644 --- a/apps/server/src/serverRuntimeStartup.reconcile.test.ts +++ b/apps/server/src/serverRuntimeStartup.reconcile.test.ts @@ -60,6 +60,7 @@ const makeProviderService = (liveThreadIds: ReadonlyArray = []) => sendTurn: () => Effect.die("unused"), compactThread: () => Effect.die("unused"), interruptTurn: () => Effect.die("unused"), + compactSession: () => Effect.die("unused"), respondToRequest: () => Effect.die("unused"), respondToUserInput: () => Effect.die("unused"), stopSession: () => Effect.die("unused"), @@ -194,6 +195,7 @@ it.effect.each( ); const fallbackProviderInstanceId = ProviderInstanceId.make("claudeAgent"); const continuationSent = yield* Deferred.make(); + const continuationRunning = yield* Deferred.make(); const continuationCleared = yield* Deferred.make(); const sends: ProviderSendTurnInput[] = []; const dispatched: OrchestrationCommand[] = []; @@ -287,16 +289,20 @@ it.effect.each( }, dispatch: (command) => Effect.sync(() => dispatched.push(command)).pipe( + Effect.flatMap(() => { + const runningCount = dispatched.filter( + (entry) => + entry.type === "thread.session.set" && entry.session.status === "running", + ).length; + return runningCount === 2 + ? Deferred.succeed(continuationRunning, undefined) + : Effect.void; + }), Effect.as({ sequence: dispatched.length }), ), }); - assert.isTrue( - dispatched.every( - (command) => - command.type === "thread.session.set" && command.session.status === "starting", - ), - ); yield* Deferred.await(continuationSent); + yield* Deferred.await(continuationRunning); yield* Deferred.await(continuationCleared); assert.deepStrictEqual( @@ -312,28 +318,50 @@ it.effect.each( }, ], ); - assert.deepStrictEqual( - dispatched.map((command) => - command.type === "thread.session.set" - ? { + const sessionSets = dispatched.flatMap((command) => + command.type === "thread.session.set" + ? [ + { threadId: command.threadId, status: command.session.status, activeTurnId: command.session.activeTurnId, - } - : null, - ), + }, + ] + : [], + ); + const byThreadId = (left: { threadId: ThreadId }, right: { threadId: ThreadId }) => + String(left.threadId).localeCompare(String(right.threadId)); + assert.deepStrictEqual( + sessionSets + .filter((command) => command.status === "starting") + .slice() + .sort(byThreadId), + [ + { threadId: codex.id, status: "starting" as const, activeTurnId: null }, + { threadId: fallback.id, status: "starting" as const, activeTurnId: null }, + ] + .slice() + .sort(byThreadId), + ); + assert.deepStrictEqual( + sessionSets + .filter((command) => command.status === "running") + .slice() + .sort(byThreadId), [ { threadId: codex.id, - status: "starting", - activeTurnId: null, + status: "running" as const, + activeTurnId: TurnId.make(`continued-${String(codex.id)}`), }, { threadId: fallback.id, - status: "starting", - activeTurnId: null, + status: "running" as const, + activeTurnId: TurnId.make(`continued-${String(fallback.id)}`), }, - ], + ] + .slice() + .sort(byThreadId), ); for (const [thread, continuationTurnId] of [ [codex, codex.session.activeTurnId], @@ -908,6 +936,8 @@ for (const preparedStatus of [ assert.deepStrictEqual(sends, [ { threadId: thread.id, continuation: true, interactionMode: "default" }, ]); + assert.equal(thread.session.status, "running"); + assert.equal(thread.session.activeTurnId, TurnId.make("turn-recovered")); assert.deepStrictEqual(binding.runtimePayload, { activeTurnId: null, continueAfterServerUpdate: null, diff --git a/apps/server/src/serverRuntimeStartup.test.ts b/apps/server/src/serverRuntimeStartup.test.ts index 0426df44bcea..6ff989e1df6a 100644 --- a/apps/server/src/serverRuntimeStartup.test.ts +++ b/apps/server/src/serverRuntimeStartup.test.ts @@ -8,7 +8,9 @@ import * as Fiber from "effect/Fiber"; import * as Option from "effect/Option"; import * as PlatformError from "effect/PlatformError"; import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; +import * as ServerRuntime from "@t3tools/shared/serverRuntime"; import * as ServerConfig from "./config.ts"; import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts"; @@ -17,6 +19,83 @@ import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts"; import * as ServerSettings from "./serverSettings.ts"; import * as GitVcsDriver from "./vcs/GitVcsDriver.ts"; +it("marks a running session with an active turn as interrupted after a server restart", () => { + const updatedAt = "2026-07-10T12:00:00.000Z"; + assert.deepStrictEqual( + ServerRuntimeStartup.interruptSessionAfterServerRestart( + { + threadId: ThreadId.make("thread-running-at-restart"), + status: "running", + providerName: "Codex", + providerInstanceId: ProviderInstanceId.make("codex"), + runtimeMode: "full-access", + activeTurnId: "turn-running-at-restart" as never, + lastError: null, + updatedAt: "2026-07-10T11:59:00.000Z", + }, + updatedAt, + ), + { + threadId: ThreadId.make("thread-running-at-restart"), + status: "interrupted", + providerName: "Codex", + providerInstanceId: ProviderInstanceId.make("codex"), + runtimeMode: "full-access", + activeTurnId: null, + lastError: "Server restarted while the agent was working. Send a follow-up to resume it.", + updatedAt, + }, + ); +}); + +it("settles a zombie running session without an active turn to ready (no Wake Required)", () => { + const updatedAt = "2026-07-10T12:00:00.000Z"; + assert.deepStrictEqual( + ServerRuntimeStartup.interruptSessionAfterServerRestart( + { + threadId: ThreadId.make("thread-zombie-running"), + status: "running", + providerName: "Codex", + providerInstanceId: ProviderInstanceId.make("codex"), + runtimeMode: "full-access", + activeTurnId: null, + lastError: null, + updatedAt: "2026-07-10T11:59:00.000Z", + }, + updatedAt, + ), + { + threadId: ThreadId.make("thread-zombie-running"), + status: "ready", + providerName: "Codex", + providerInstanceId: ProviderInstanceId.make("codex"), + runtimeMode: "full-access", + activeTurnId: null, + lastError: null, + updatedAt, + }, + ); +}); + +it("does not mark an already idle session as interrupted after restart", () => { + assert.equal( + ServerRuntimeStartup.interruptSessionAfterServerRestart( + { + threadId: ThreadId.make("thread-idle-at-restart"), + status: "ready", + providerName: "Codex", + providerInstanceId: ProviderInstanceId.make("codex"), + runtimeMode: "full-access", + activeTurnId: null, + lastError: null, + updatedAt: "2026-07-10T11:59:00.000Z", + }, + "2026-07-10T12:00:00.000Z", + ), + null, + ); +}); + it.effect("automatic pull only updates enabled, behind, clean default-branch checkouts", () => Effect.gen(function* () { const pulled: string[] = []; @@ -170,12 +249,15 @@ it.effect("resolveAutoBootstrapWelcomeTargets returns existing project and threa getImportedAgentSessionSources: () => Effect.die("unused"), getThreadCheckpointContext: () => Effect.succeed(Option.none()), getFullThreadDiffContext: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.die("unused"), getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.die("unused"), getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), }), Effect.provideService(OrchestrationEngine.OrchestrationEngineService, { readEvents: () => Stream.empty, @@ -257,12 +339,15 @@ it.effect.each([ getImportedAgentSessionSources: () => Effect.die("unused"), getThreadCheckpointContext: () => Effect.succeed(Option.none()), getFullThreadDiffContext: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.die("unused"), getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.die("unused"), getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), }), Effect.provideService(OrchestrationEngine.OrchestrationEngineService, { readEvents: () => Stream.empty, @@ -326,12 +411,15 @@ it.effect( getImportedAgentSessionSources: () => Effect.die("unused"), getThreadCheckpointContext: () => Effect.succeed(Option.none()), getFullThreadDiffContext: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.die("unused"), getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.die("unused"), getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), }), Effect.provideService(OrchestrationEngine.OrchestrationEngineService, { readEvents: () => Stream.empty, @@ -388,12 +476,15 @@ it.effect("resolveAutoBootstrapWelcomeTargets preserves typed UUID generation fa getImportedAgentSessionSources: () => Effect.die("unused"), getThreadCheckpointContext: () => Effect.succeed(Option.none()), getFullThreadDiffContext: () => Effect.succeed(Option.none()), + getSessionStopContextById: () => Effect.die("unused"), getThreadRuntimeContext: () => Effect.die("unused"), getTurnStartMessage: () => Effect.die("unused"), getThreadShellById: () => Effect.die("unused"), getThreadDetailById: () => Effect.die("unused"), getThreadDetailSnapshot: () => Effect.die("unused"), searchThreads: () => Effect.succeed({ matches: [] }), + getThreadActivitiesPage: () => Effect.die("unused"), + getThreadLifecycleById: () => Effect.die("unused"), }), Effect.provideService(OrchestrationEngine.OrchestrationEngineService, { readEvents: () => Stream.empty, @@ -419,6 +510,32 @@ it.effect("resolveAutoBootstrapWelcomeTargets preserves typed UUID generation fa }).pipe(Effect.provide(NodeServices.layer)), ); +it.effect("writes a runtime descriptor the desktop client can decode", () => + Effect.gen(function* () { + const descriptor = { + version: 1 as const, + pid: 4242, + stateDir: "/state", + httpBaseUrl: "http://127.0.0.1:3773", + startedAt: "2026-08-04T10:00:00.000Z", + }; + + const contents = yield* ServerRuntimeStartup.encodeServerRuntimeDescriptorFile(descriptor); + + // The file is newline-terminated and holds a single JSON document. + assert.isTrue(contents.endsWith("\n")); + assert.equal(contents.trimEnd().split("\n").length, 1); + + // DesktopExistingBackend decodes the file with this same shared schema, so + // the round trip through it is the cross-process contract. + const decoded = Schema.decodeUnknownExit( + Schema.fromJsonString(ServerRuntime.ServerRuntimeDescriptor), + )(contents); + assert.equal(decoded._tag, "Success"); + assert.deepStrictEqual(decoded._tag === "Success" ? decoded.value : null, descriptor); + }), +); + it.effect("completeAutoBootstrapWelcome settles failures without bootstrap targets", () => Effect.gen(function* () { const completion = yield* ServerRuntimeStartup.completeAutoBootstrapWelcome( diff --git a/apps/server/src/serverRuntimeStartup.ts b/apps/server/src/serverRuntimeStartup.ts index 3d04abaa1914..9a8b9e5b20e0 100644 --- a/apps/server/src/serverRuntimeStartup.ts +++ b/apps/server/src/serverRuntimeStartup.ts @@ -5,10 +5,10 @@ import { DEFAULT_SERVER_SETTINGS, type ModelSelection, type OrchestrationProjectShell, + type OrchestrationSession, ProjectId, ProviderInstanceId, ThreadId, - TurnId, } from "@t3tools/contracts"; import { resolveProjectAutoPull } from "@t3tools/shared/serverSettings"; import * as Cause from "effect/Cause"; @@ -19,6 +19,7 @@ import * as DateTime from "effect/DateTime"; import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; +import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; @@ -26,6 +27,10 @@ import * as Queue from "effect/Queue"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import * as Scope from "effect/Scope"; +import { + SERVER_RUNTIME_DESCRIPTOR_FILE, + ServerRuntimeDescriptor, +} from "@t3tools/shared/serverRuntime"; import * as ServerConfig from "./config.ts"; import * as Keybindings from "./keybindings.ts"; @@ -34,13 +39,22 @@ import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngi import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts"; import * as OrchestrationReactor from "./orchestration/Services/OrchestrationReactor.ts"; import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts"; +import { runWebVersionWatcher } from "./webVersionWatcher.ts"; import * as ServerSettings from "./serverSettings.ts"; import * as AnalyticsService from "./telemetry/AnalyticsService.ts"; import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import * as ProviderService from "./provider/Services/ProviderService.ts"; import * as ProviderSessionDirectory from "./provider/Services/ProviderSessionDirectory.ts"; +import { + hasServerUpdateContinuationMarker, + readRuntimePayload, + readServerUpdateContinuationTurnId, + SERVER_UPDATE_CONTINUATION_KEY, + SERVER_UPDATE_CONTINUATION_PROMPT, +} from "./provider/providerSessionContinuation.ts"; import * as ProviderSessionReaper from "./provider/Services/ProviderSessionReaper.ts"; +import * as OrphanSessionRecovery from "./orchestration/Services/OrphanSessionRecovery.ts"; import { forkParked } from "./serverActivation.ts"; import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts"; import * as GitVcsDriver from "./vcs/GitVcsDriver.ts"; @@ -170,7 +184,7 @@ const recordStartupHeartbeat = Effect.gen(function* () { }); }); -const getAutoBootstrapThreadModelSelection = (): ModelSelection => ({ +export const getAutoBootstrapThreadModelSelection = (): ModelSelection => ({ instanceId: ProviderInstanceId.make("codex"), model: DEFAULT_MODEL, }); @@ -335,10 +349,39 @@ const runStartupPhase = (phase: string, effect: Effect.Effect) Effect.withSpan(`server.startup.${phase}`), ); +/** + * Pure helper for session rows that claimed to be live across a process restart. + * Only marks **Wake Required** (`interrupted`) when a turn was actually in flight. + * Zombie `running`/`starting` sessions with no active turn settle to `ready`. + */ +export function interruptSessionAfterServerRestart( + session: OrchestrationSession | null, + updatedAt: string, +): OrchestrationSession | null { + if (session?.status !== "starting" && session?.status !== "running") { + return null; + } + const hadActiveTurn = session.activeTurnId != null; + if (!hadActiveTurn) { + return { + ...session, + status: "ready", + activeTurnId: null, + lastError: null, + updatedAt, + }; + } + return { + ...session, + status: "interrupted", + activeTurnId: null, + lastError: "Server restarted while the agent was working. Send a follow-up to resume it.", + updatedAt, + }; +} + const ORPHANED_PROVIDER_SESSION_ERROR = "Provider session did not survive a server restart. Send a new message to continue."; -const SERVER_UPDATE_CONTINUATION_KEY = "continueAfterServerUpdate"; -const SERVER_UPDATE_CONTINUATION_PROMPT = "Continue where you left off."; class ProviderSessionContinuationError extends Schema.TaggedError()( "ProviderSessionContinuationError", @@ -362,35 +405,8 @@ export class ServerUpdateThreadContinuationError extends Schema.TaggedError { - return ( - runtimePayload !== null && - typeof runtimePayload === "object" && - !Array.isArray(runtimePayload) && - SERVER_UPDATE_CONTINUATION_KEY in runtimePayload - ); -} - -function readRuntimePayload(runtimePayload: unknown): Record { - return runtimePayload !== null && - typeof runtimePayload === "object" && - !Array.isArray(runtimePayload) - ? (runtimePayload as Record) - : {}; -} - const isServerUpdateThreadContinuationError = Schema.is(ServerUpdateThreadContinuationError); -function readServerUpdateContinuationTurnId(runtimePayload: unknown): TurnId | null { - if (!hasServerUpdateContinuationMarker(runtimePayload)) { - return null; - } - const value = runtimePayload[SERVER_UPDATE_CONTINUATION_KEY]; - return typeof value === "string" && value.length > 0 ? TurnId.make(value) : null; -} - const toServerUpdateThreadContinuationError = (cause: unknown) => isServerUpdateThreadContinuationError(cause) ? cause @@ -689,13 +705,30 @@ export const reconcileProviderSessions = Effect.gen(function* () { }); } const capabilities = yield* providerService.getCapabilities(providerInstanceId); - yield* providerService.sendTurn({ + const result = yield* providerService.sendTurn({ threadId: thread.id, ...(capabilities.promptlessTurnContinuation === true ? { continuation: true } : { input: SERVER_UPDATE_CONTINUATION_PROMPT }), interactionMode: thread.interactionMode, }); + // Resume/continuation often does not emit turn.started until the + // replacement turn finishes. Leave the session running with the + // admitted turn id so queue.steer is not blocked for the whole turn. + const continuedAt = DateTime.formatIso(yield* DateTime.now); + yield* orchestrationEngine.dispatch({ + type: "thread.session.set", + commandId: CommandId.make(yield* crypto.randomUUIDv4), + threadId: thread.id, + session: { + ...session, + status: "running", + activeTurnId: result.turnId, + lastError: null, + updatedAt: continuedAt, + }, + createdAt: continuedAt, + }); }); const continuationExit = yield* Effect.exit(continuation); if (Exit.isSuccess(continuationExit) || Cause.hasInterrupts(continuationExit.cause)) { @@ -740,6 +773,20 @@ interface StartupOptions { readonly abort?: (error: ServerRuntimeStartupError) => Effect.Effect; } +const ServerRuntimeDescriptorJson = Schema.fromJsonString(ServerRuntimeDescriptor); +const encodeServerRuntimeDescriptor = Schema.encodeEffect(ServerRuntimeDescriptorJson); +const decodeServerRuntimeDescriptor = Schema.decodeEffect(ServerRuntimeDescriptorJson); + +/** + * Exact contents written to the runtime descriptor file. The desktop client + * reads this file back and decodes it with the same schema + * (`DesktopExistingBackend`), so the on-disk shape is a cross-process contract. + */ +export const encodeServerRuntimeDescriptorFile = ( + descriptor: ServerRuntimeDescriptor, +): Effect.Effect => + encodeServerRuntimeDescriptor(descriptor).pipe(Effect.map((json) => `${json}\n`)); + export const autoPullProjects = Effect.fn("autoPullProjects")(function* ( projects: ReadonlyArray, settings: Pick< @@ -807,10 +854,16 @@ export const autoPullProjects = Effect.fn("autoPullProjects")(function* ( export const make = (options?: StartupOptions) => Effect.gen(function* () { const serverConfig = yield* ServerConfig.ServerConfig; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; const keybindings = yield* Keybindings.Keybindings; const orchestrationReactor = yield* OrchestrationReactor.OrchestrationReactor; const providerSessionReaper = yield* ProviderSessionReaper.ProviderSessionReaper; + const orphanSessionRecovery = yield* OrphanSessionRecovery.OrphanSessionRecovery; const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents; + // Broadcast when the served web bundle is hot-swapped on disk so clients can + // offer a reload without a server restart. + yield* Effect.forkScoped(runWebVersionWatcher(lifecycleEvents)); const serverSettings = yield* ServerSettings.ServerSettingsService; const serverEnvironment = yield* ServerEnvironment.ServerEnvironment; const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery; @@ -875,6 +928,22 @@ export const make = (options?: StartupOptions) => }), ); + yield* runStartupPhase( + "sessions.interrupt-stale", + Effect.gen(function* () { + // Full orphan audit: clear shell sessions *and* provider runtimes that + // claim to be live. No provider process can have survived the restart, + // so leaving them "running" deadlocks resync/reaper behind active turns. + const result = yield* orphanSessionRecovery.settleAllAfterServerRestart(); + if (result.settledSessions > 0 || result.settledRuntimes > 0) { + yield* Effect.logWarning("interrupted stale provider sessions after server restart", { + interruptedCount: result.settledSessions, + settledRuntimes: result.settledRuntimes, + }); + } + }), + ); + yield* runStartupPhase("provider-sessions.reconcile", reconcileProviderSessions); yield* Effect.logDebug("startup phase: syncing clean projects"); @@ -946,6 +1015,39 @@ export const make = (options?: StartupOptions) => yield* Effect.logDebug("startup phase: waiting for http listener"); yield* runStartupPhase("http.wait", Deferred.await(httpListening)); + + const runtimeDescriptorPath = path.join( + serverConfig.stateDir, + SERVER_RUNTIME_DESCRIPTOR_FILE, + ); + const descriptorHost = + serverConfig.host === undefined || isWildcardHost(serverConfig.host) + ? "127.0.0.1" + : serverConfig.host; + const runtimeStartedAt = DateTime.formatIso(yield* DateTime.now); + const runtimeDescriptorContents = yield* encodeServerRuntimeDescriptorFile({ + version: 1, + pid: process.pid, + stateDir: serverConfig.stateDir, + httpBaseUrl: `http://${formatHostForUrl(descriptorHost)}:${serverConfig.port}`, + startedAt: runtimeStartedAt, + }).pipe(Effect.orDie); + yield* fileSystem + .writeFileString(runtimeDescriptorPath, runtimeDescriptorContents, { mode: 0o600 }) + .pipe(Effect.orDie); + yield* Effect.addFinalizer(() => + // Best-effort cleanup: only this process's own descriptor is removed, + // and a missing, unreadable, or malformed file must not fail shutdown. + fileSystem.readFileString(runtimeDescriptorPath).pipe( + Effect.flatMap(decodeServerRuntimeDescriptor), + Effect.flatMap((current) => + current.pid === process.pid + ? fileSystem.remove(runtimeDescriptorPath, { force: true }) + : Effect.void, + ), + Effect.ignore, + ), + ); yield* runStartupPhase( "auxiliary-roots.parked", options?.awaitAuxiliaryParked ?? Effect.void, diff --git a/apps/server/src/sourceControl/BitbucketApi.test.ts b/apps/server/src/sourceControl/BitbucketApi.test.ts index 856d043a7fce..6dcb83bb4faa 100644 --- a/apps/server/src/sourceControl/BitbucketApi.test.ts +++ b/apps/server/src/sourceControl/BitbucketApi.test.ts @@ -136,6 +136,7 @@ function makeLayer(input: { kind: "git", rootPath: "/repo", metadataPath: null, + bare: false, freshness: { source: "live-local" as const, observedAt: DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"), @@ -675,6 +676,7 @@ it.effect("preserves Git checkout failures without deriving the domain message f operation: "fetchRemoteBranch", command: "git fetch origin feature/source-control", cwd: "/repo", + failureKind: "unknown", detail: "remote rejected the request", }); const { layer } = makeLayer({ diff --git a/apps/server/src/sourceControl/GitHubCli.test.ts b/apps/server/src/sourceControl/GitHubCli.test.ts index f72259b677eb..988fecde8c58 100644 --- a/apps/server/src/sourceControl/GitHubCli.test.ts +++ b/apps/server/src/sourceControl/GitHubCli.test.ts @@ -52,6 +52,29 @@ describe("GitHubCli.layer", () => { assert.notProperty(commandFailure, "operation"); }); + it("surfaces guest App-wrapper diagnostics instead of the generic command-failed line", () => { + const context = { command: "gh", cwd: "/repo" } as const; + const cause = new VcsProcessExitError({ + operation: "GitHubCli.execute", + command: "gh", + cwd: context.cwd, + exitCode: 1, + failureKind: "command-failed", + detail: "Process exited with a non-zero status.", + publicDiagnostic: + "t3-github-app-token: app is not installed on pingdotgg/t3code (or repo does not exist)", + }); + + const error = GitHubCli.fromVcsError(context, cause); + + assert.equal(error._tag, "GitHubCliCommandError"); + assert.equal( + error.detail, + "t3-github-app-token: app is not installed on pingdotgg/t3code (or repo does not exist)", + ); + assert.equal(error.message.includes("app is not installed"), true); + }); + it.effect("parses pull request view output", () => Effect.gen(function* () { mockRun.mockReturnValueOnce( @@ -165,6 +188,38 @@ describe("GitHubCli.layer", () => { }).pipe(Effect.provide(layer)), ); + it.effect("detects failing pull request checks from gh pr checks json", () => + Effect.gen(function* () { + mockRun.mockReturnValueOnce( + Effect.succeed( + processOutput( + // @effect-diagnostics-next-line preferSchemaOverJson:off + JSON.stringify([ + { bucket: "pass", state: "SUCCESS" }, + { bucket: "fail", state: "FAILURE" }, + ]), + ), + ), + ); + + const gh = yield* GitHubCli.GitHubCli; + const result = yield* gh.getPullRequestHasFailingChecks({ + cwd: "/repo", + reference: "#42", + }); + + assert.strictEqual(result, true); + expect(mockRun).toHaveBeenCalledWith({ + operation: "GitHubCli.getPullRequestHasFailingChecks", + command: "gh", + args: ["pr", "checks", "#42", "--json", "bucket,state"], + cwd: "/repo", + timeoutMs: 30_000, + allowNonZeroExit: true, + }); + }).pipe(Effect.provide(layer)), + ); + it.effect("skips invalid entries when parsing pr lists", () => Effect.gen(function* () { mockRun.mockReturnValueOnce( diff --git a/apps/server/src/sourceControl/GitHubCli.ts b/apps/server/src/sourceControl/GitHubCli.ts index cd8782c87d9e..0527d38fbb09 100644 --- a/apps/server/src/sourceControl/GitHubCli.ts +++ b/apps/server/src/sourceControl/GitHubCli.ts @@ -82,10 +82,13 @@ export class GitHubPullRequestNotFoundError extends Schema.TaggedError()( "GitHubCliCommandError", - gitHubCliFailureFields, + { + ...gitHubCliFailureFields, + publicDiagnostic: Schema.optional(Schema.String), + }, ) { get detail(): string { - return "GitHub CLI command failed."; + return this.publicDiagnostic ?? "GitHub CLI command failed."; } override get message(): string { @@ -193,6 +196,13 @@ export function fromVcsError( if (error.failureKind === "not-found") { return new GitHubPullRequestNotFoundError({ ...context, cause: error }); } + if (error.publicDiagnostic !== undefined) { + return new GitHubCliCommandError({ + ...context, + cause: error, + publicDiagnostic: error.publicDiagnostic, + }); + } } return new GitHubCliCommandError({ ...context, cause: error }); @@ -205,6 +215,7 @@ export interface GitHubPullRequestSummary { readonly baseRefName: string; readonly headRefName: string; readonly state?: "open" | "closed" | "merged"; + readonly hasFailingChecks?: boolean; readonly isDraft?: boolean; readonly closedAt?: string | null; readonly mergedAt?: string | null; @@ -250,6 +261,10 @@ export class GitHubCli extends Context.Service< readonly cwd: string; readonly reference: string; }) => Effect.Effect; + readonly getPullRequestHasFailingChecks: (input: { + readonly cwd: string; + readonly reference: string; + }) => Effect.Effect; readonly getRepositoryCloneUrls: (input: { readonly cwd: string; @@ -424,6 +439,38 @@ export const make = Effect.gen(function* () { ), ), ), + getPullRequestHasFailingChecks: (input) => + process + .run({ + operation: "GitHubCli.getPullRequestHasFailingChecks", + command: "gh", + args: ["pr", "checks", input.reference, "--json", "bucket,state"], + cwd: input.cwd, + timeoutMs: DEFAULT_TIMEOUT_MS, + allowNonZeroExit: true, + }) + .pipe( + Effect.mapError((error) => fromVcsError({ command: "gh", cwd: input.cwd }, error)), + Effect.map((result) => { + const raw = result.stdout.trim(); + if (raw.length === 0) return false; + try { + const parsed = JSON.parse(raw) as ReadonlyArray<{ + readonly bucket?: string | null; + readonly state?: string | null; + }>; + return parsed.some((check) => { + const bucket = check.bucket?.trim().toLowerCase(); + const state = check.state?.trim().toLowerCase(); + return ( + bucket === "fail" || state === "fail" || state === "failure" || state === "error" + ); + }); + } catch { + return false; + } + }), + ), getRepositoryCloneUrls: (input) => execute({ cwd: input.cwd, diff --git a/apps/server/src/sourceControl/GitHubSourceControlProvider.test.ts b/apps/server/src/sourceControl/GitHubSourceControlProvider.test.ts index a025ce5ec800..ff0184ed975c 100644 --- a/apps/server/src/sourceControl/GitHubSourceControlProvider.test.ts +++ b/apps/server/src/sourceControl/GitHubSourceControlProvider.test.ts @@ -45,6 +45,7 @@ it.effect("maps GitHub PR summaries into provider-neutral change requests", () = headRepositoryNameWithOwner: "fork/t3code", headRepositoryOwnerLogin: "fork", }), + getPullRequestHasFailingChecks: () => Effect.succeed(true), }); const changeRequest = yield* provider.getChangeRequest({ @@ -66,6 +67,7 @@ it.effect("maps GitHub PR summaries into provider-neutral change requests", () = isCrossRepository: true, headRepositoryNameWithOwner: "fork/t3code", headRepositoryOwnerLogin: "fork", + hasFailingChecks: true, }); }), ); diff --git a/apps/server/src/sourceControl/GitHubSourceControlProvider.ts b/apps/server/src/sourceControl/GitHubSourceControlProvider.ts index d82832564a24..0ae2daaacd0a 100644 --- a/apps/server/src/sourceControl/GitHubSourceControlProvider.ts +++ b/apps/server/src/sourceControl/GitHubSourceControlProvider.ts @@ -45,6 +45,9 @@ function toChangeRequest(summary: GitHubCli.GitHubPullRequestSummary): ChangeReq ...(summary.headRepositoryOwnerLogin !== undefined ? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin } : {}), + ...(summary.hasFailingChecks !== undefined + ? { hasFailingChecks: summary.hasFailingChecks } + : {}), }; } @@ -212,8 +215,15 @@ export const make = Effect.gen(function* () { kind: "github", listChangeRequests, getChangeRequest: (input) => - github.getPullRequest(input).pipe( - Effect.map(toChangeRequest), + Effect.all({ + summary: github.getPullRequest(input), + hasFailingChecks: github + .getPullRequestHasFailingChecks(input) + .pipe(Effect.orElseSucceed(() => false)), + }).pipe( + Effect.map(({ summary, hasFailingChecks }) => + toChangeRequest({ ...summary, ...(hasFailingChecks ? { hasFailingChecks } : {}) }), + ), Effect.mapError( (error) => new SourceControlProviderError({ diff --git a/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts b/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts index 54038502bfde..45a541967295 100644 --- a/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts +++ b/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts @@ -68,6 +68,7 @@ function makeRegistry(input: { kind: "git", rootPath: "/repo", metadataPath: null, + bare: false, freshness: { source: "live-local" as const, observedAt: TEST_EPOCH, diff --git a/apps/server/src/sourceControl/SourceControlRepositoryService.test.ts b/apps/server/src/sourceControl/SourceControlRepositoryService.test.ts index 461bff08668a..d41015722066 100644 --- a/apps/server/src/sourceControl/SourceControlRepositoryService.test.ts +++ b/apps/server/src/sourceControl/SourceControlRepositoryService.test.ts @@ -180,16 +180,43 @@ it.effect("clones a looked-up repository into the requested destination", () => cwd: parent, args: ["clone", CLONE_URLS.url, "t3code"], }, + { + cwd: destinationPath, + args: ["config", "core.hooksPath", ".githooks"], + }, + { + cwd: destinationPath, + args: ["checkout", "--force", "HEAD"], + }, ]); }).pipe( Effect.provide( makeLayer({ git: { execute: (input) => - Effect.sync(() => { + Effect.gen(function* () { cloneCalls.push({ cwd: input.cwd, args: input.args }); + if (input.args[0] === "clone") { + yield* fs.makeDirectory(`${destinationPath}/.githooks`, { recursive: true }); + yield* fs.writeFileString( + `${destinationPath}/.githooks/post-checkout`, + "#!/bin/sh\n", + ); + } return processOutput(); - }), + }).pipe( + Effect.mapError( + (cause) => + new GitCommandError({ + operation: input.operation, + command: `git ${input.args.join(" ")}`, + cwd: input.cwd, + failureKind: "unknown", + detail: "Could not create the clone fixture.", + cause, + }), + ), + ), }, }), ), @@ -366,6 +393,7 @@ it.effect("publish succeeds with status remote_added when the local repo has no operation: input.operation, command: "git rev-parse --verify HEAD", cwd: input.cwd, + failureKind: "unknown", detail: "fatal: Needed a single revision", }), ) diff --git a/apps/server/src/sourceControl/SourceControlRepositoryService.ts b/apps/server/src/sourceControl/SourceControlRepositoryService.ts index 0addeca9e785..1015ee1f03ea 100644 --- a/apps/server/src/sourceControl/SourceControlRepositoryService.ts +++ b/apps/server/src/sourceControl/SourceControlRepositoryService.ts @@ -202,6 +202,29 @@ export const make = Effect.gen(function* () { maxOutputBytes: 256 * 1024, }); + const nativePostCheckout = path.join( + preparedDestination.destinationPath, + ".githooks", + "post-checkout", + ); + if (yield* fileSystem.exists(nativePostCheckout)) { + yield* git.execute({ + operation: "SourceControlRepositoryService.configureNativeHooks", + cwd: preparedDestination.destinationPath, + args: ["config", "core.hooksPath", ".githooks"], + }); + // Clone's checkout happened before the repository-owned hooks were configured. + // Re-checking out the fresh HEAD invokes post-checkout synchronously, so setup + // (including pnpm install) finishes before the clone is handed to the user. + yield* git.execute({ + operation: "SourceControlRepositoryService.prepareClone", + cwd: preparedDestination.destinationPath, + args: ["checkout", "--force", "HEAD"], + timeoutMs: 120_000, + maxOutputBytes: 256 * 1024, + }); + } + return { cwd: preparedDestination.destinationPath, remoteUrl, diff --git a/apps/server/src/staticAssetDelivery.test.ts b/apps/server/src/staticAssetDelivery.test.ts new file mode 100644 index 000000000000..c9e78f2c36d8 --- /dev/null +++ b/apps/server/src/staticAssetDelivery.test.ts @@ -0,0 +1,241 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + contentCacheKey, + isCompressibleContentType, + isContentHashedAsset, + makeStaticCompressionCache, + negotiateStaticEncoding, + resolveStaticCacheControl, +} from "./staticAssetDelivery.ts"; + +describe("contentCacheKey", () => { + const encode = (value: string) => new TextEncoder().encode(value); + + it("keys identical content the same way", () => { + expect(contentCacheKey(encode("a"))).toBe( + contentCacheKey(encode("a")), + ); + }); + + it("separates content of the same length", () => { + // A rebuild can reuse a filename, a size, and even a timestamp, so the + // key has to come from the bytes themselves. + expect(contentCacheKey(encode("a"))).not.toBe( + contentCacheKey(encode("b")), + ); + }); +}); + +describe("isContentHashedAsset", () => { + it("recognizes vite content-hashed bundle assets", () => { + expect(isContentHashedAsset("assets/index-DxV9k2Qp.js")).toBe(true); + expect(isContentHashedAsset("/assets/style-a1b2c3d4.css")).toBe(true); + }); + + it("rejects stable-name files that a hot swap can change in place", () => { + // These keep their name across builds, so the compression cache must key + // them by content, not path/mtime/size -- otherwise an atomic asset swap + // that preserves metadata could serve stale bytes. + expect(isContentHashedAsset("index.html")).toBe(false); + expect(isContentHashedAsset("favicon.ico")).toBe(false); + expect(isContentHashedAsset("manifest.webmanifest")).toBe(false); + expect(isContentHashedAsset("assets/logo.svg")).toBe(false); + }); +}); + +describe("resolveStaticCacheControl", () => { + it("marks content-hashed bundle assets immutable", () => { + expect(resolveStaticCacheControl("assets/index-DxV9k2Qp.js")).toBe( + "public, max-age=31536000, immutable", + ); + expect(resolveStaticCacheControl("assets/style-a1b2c3d4.css")).toBe( + "public, max-age=31536000, immutable", + ); + }); + + it("revalidates entry documents and unhashed files", () => { + expect(resolveStaticCacheControl("index.html")).toBe("no-cache"); + expect(resolveStaticCacheControl("/index.html")).toBe("no-cache"); + // No hash means a rebuild reuses the name, so it must not be pinned. + expect(resolveStaticCacheControl("assets/logo.svg")).toBe("no-cache"); + expect(resolveStaticCacheControl("favicon.ico")).toBe("no-cache"); + }); +}); + +describe("negotiateStaticEncoding", () => { + it("prefers brotli when the client accepts both", () => { + expect(negotiateStaticEncoding("gzip, deflate, br")).toBe("br"); + }); + + it("falls back to gzip when brotli is absent", () => { + expect(negotiateStaticEncoding("gzip, deflate")).toBe("gzip"); + }); + + it("returns null when nothing usable is offered", () => { + expect(negotiateStaticEncoding(undefined)).toBeNull(); + expect(negotiateStaticEncoding("")).toBeNull(); + expect(negotiateStaticEncoding("deflate")).toBeNull(); + }); + + it("honors explicit refusals expressed as q=0", () => { + expect(negotiateStaticEncoding("br;q=0, gzip")).toBe("gzip"); + expect(negotiateStaticEncoding("gzip;q=0, br;q=0")).toBeNull(); + }); + + it("accepts a wildcard offer", () => { + expect(negotiateStaticEncoding("*")).toBe("br"); + }); +}); + +describe("isCompressibleContentType", () => { + it("compresses text and structured payloads", () => { + expect(isCompressibleContentType("text/html; charset=utf-8")).toBe(true); + expect(isCompressibleContentType("application/javascript")).toBe(true); + expect(isCompressibleContentType("image/svg+xml")).toBe(true); + }); + + it("leaves already-compressed binaries alone", () => { + expect(isCompressibleContentType("image/png")).toBe(false); + expect(isCompressibleContentType("font/woff2")).toBe(false); + expect(isCompressibleContentType("application/octet-stream")).toBe(false); + }); +}); + +describe("makeStaticCompressionCache", () => { + const bundle = new TextEncoder().encode("export const value = 1;\n".repeat(500)); + + it("compresses a payload once and reuses the result", async () => { + let compressCalls = 0; + const cache = makeStaticCompressionCache(async (data) => { + compressCalls += 1; + return data.subarray(0, 64); + }); + + const first = await cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "gzip" }); + const second = await cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "gzip" }); + + expect(first).not.toBeNull(); + expect(second).toBe(first); + expect(compressCalls).toBe(1); + }); + + it("compresses once for a burst of concurrent requests", async () => { + let compressCalls = 0; + let release = () => {}; + const started = new Promise((resolve) => { + release = resolve; + }); + const cache = makeStaticCompressionCache(async (data) => { + compressCalls += 1; + await started; + return data.subarray(0, 64); + }); + + const requests = [ + cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "br" }), + cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "br" }), + cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "br" }), + ]; + release(); + const results = await Promise.all(requests); + + expect(compressCalls).toBe(1); + expect(results[1]).toBe(results[0]); + expect(results[2]).toBe(results[0]); + }); + + it("retries after a failed compression instead of caching the failure", async () => { + let compressCalls = 0; + const cache = makeStaticCompressionCache(async (data) => { + compressCalls += 1; + if (compressCalls === 1) throw new Error("zlib buffer error"); + return data.subarray(0, 64); + }); + + await expect( + cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "gzip" }), + ).rejects.toThrow("zlib buffer error"); + + const retried = await cache.get({ + cacheKey: "bundle.js 1 100", + data: bundle, + encoding: "gzip", + }); + + expect(compressCalls).toBe(2); + expect(retried).not.toBeNull(); + }); + + it("recompresses when the file changes underneath the same path", async () => { + let compressCalls = 0; + const cache = makeStaticCompressionCache(async (data) => { + compressCalls += 1; + return data.subarray(0, 64); + }); + + await cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "gzip" }); + await cache.get({ cacheKey: "bundle.js 2 140", data: bundle, encoding: "gzip" }); + + expect(compressCalls).toBe(2); + }); + + it("keeps brotli and gzip results apart", async () => { + const cache = makeStaticCompressionCache(async (data, encoding) => + new TextEncoder().encode(`${encoding}:${data.byteLength}`), + ); + + const brotli = await cache.get({ cacheKey: "bundle.js 1 100", data: bundle, encoding: "br" }); + const gzipped = await cache.get({ + cacheKey: "bundle.js 1 100", + data: bundle, + encoding: "gzip", + }); + + expect(new TextDecoder().decode(brotli ?? new Uint8Array())).toContain("br:"); + expect(new TextDecoder().decode(gzipped ?? new Uint8Array())).toContain("gzip:"); + }); + + it("skips payloads too small to be worth compressing", async () => { + let compressCalls = 0; + const cache = makeStaticCompressionCache(async (data) => { + compressCalls += 1; + return data; + }); + + const result = await cache.get({ + cacheKey: "tiny.js 1 8", + data: new TextEncoder().encode("const a=1;"), + encoding: "gzip", + }); + + expect(result).toBeNull(); + expect(compressCalls).toBe(0); + }); + + it("declines a result that did not get smaller", async () => { + const cache = makeStaticCompressionCache(async (data) => new Uint8Array(data.byteLength + 32)); + + const result = await cache.get({ + cacheKey: "incompressible.bin 1 100", + data: bundle, + encoding: "gzip", + }); + + expect(result).toBeNull(); + expect(cache.retainedByteLength).toBe(0); + }); + + it("really shrinks a realistic bundle with the default compressor", async () => { + const cache = makeStaticCompressionCache(); + + const compressed = await cache.get({ + cacheKey: "real.js 1 100", + data: bundle, + encoding: "br", + }); + + expect(compressed).not.toBeNull(); + expect((compressed as Uint8Array).byteLength).toBeLessThan(bundle.byteLength / 2); + }); +}); diff --git a/apps/server/src/staticAssetDelivery.ts b/apps/server/src/staticAssetDelivery.ts new file mode 100644 index 000000000000..5eb1136e3f81 --- /dev/null +++ b/apps/server/src/staticAssetDelivery.ts @@ -0,0 +1,195 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeCrypto from "node:crypto"; +import * as NodeZlib from "node:zlib"; +import * as NodeUtil from "node:util"; + +/** + * Delivery policy for the packaged web bundle. Vite emits content-hashed + * files under `assets/`, so those are immutable and safe to cache forever, + * while `index.html` and the SPA fallback must revalidate or a new build is + * never picked up. + */ +const IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable"; +const REVALIDATE_CACHE_CONTROL = "no-cache"; + +/** Vite content hashes are at least 8 url-safe characters before the extension. */ +const HASHED_ASSET_PATTERN = /-[A-Za-z0-9_-]{8,}\.[A-Za-z0-9]+$/; + +/** + * Compressing tiny payloads costs more than it saves, and the header + * overhead can make the response larger than the original. + */ +const MIN_COMPRESSIBLE_BYTES = 1024; + +/** Total size of compressed payloads retained across all static files. */ +const COMPRESSED_CACHE_MAX_BYTES = 64 * 1024 * 1024; + +const COMPRESSIBLE_CONTENT_TYPES = [ + "text/", + "application/javascript", + "application/json", + "application/manifest+json", + "application/wasm", + "image/svg+xml", +]; + +const gzip = NodeUtil.promisify(NodeZlib.gzip); +const brotliCompress = NodeUtil.promisify(NodeZlib.brotliCompress); + +export type StaticContentEncoding = "br" | "gzip"; + +/** + * Whether a static file's name already encodes its content (a Vite hashed + * asset under `assets/`). Such files are safe to cache forever and safe to key + * by path/metadata, because the name changes whenever the bytes do. Every other + * served file keeps a stable name across builds, so a hot asset swap that + * preserves mtime and size could otherwise let the compression cache serve + * stale bytes -- those must be keyed by content instead. + */ +export function isContentHashedAsset(relativePath: string): boolean { + const normalized = relativePath.replaceAll("\\", "/").replace(/^\/+/, ""); + return normalized.startsWith("assets/") && HASHED_ASSET_PATTERN.test(normalized); +} + +export function resolveStaticCacheControl(relativePath: string): string { + return isContentHashedAsset(relativePath) ? IMMUTABLE_CACHE_CONTROL : REVALIDATE_CACHE_CONTROL; +} + +/** + * Cache key derived from the bytes being served rather than from file + * metadata. Used where the served content and the metadata could otherwise + * disagree, which would let one request's compression be reused for + * different content. Only worth it for small payloads, since it hashes the + * whole buffer on every request. + */ +export function contentCacheKey(data: Uint8Array): string { + return NodeCrypto.createHash("sha1").update(data).digest("hex"); +} + +export function isCompressibleContentType(contentType: string): boolean { + const normalized = contentType.toLowerCase(); + return COMPRESSIBLE_CONTENT_TYPES.some((prefix) => normalized.startsWith(prefix)); +} + +/** + * Pick an encoding from `Accept-Encoding`, preferring Brotli. Entries with an + * explicit `q=0` are refusals, and `identity;q=0` plus an unsupported codec + * list leaves nothing usable, so the caller falls back to the raw bytes. + */ +export function negotiateStaticEncoding( + acceptEncoding: string | undefined, +): StaticContentEncoding | null { + if (!acceptEncoding) return null; + + const acceptedQualityByCodec = new Map(); + for (const entry of acceptEncoding.split(",")) { + const [rawCodec = "", ...parameters] = entry.trim().split(";"); + const codec = rawCodec.trim().toLowerCase(); + if (!codec) continue; + const quality = parameters + .map((parameter) => /^\s*q=([0-9.]+)\s*$/i.exec(parameter)) + .find((match) => match !== null)?.[1]; + acceptedQualityByCodec.set(codec, quality === undefined ? 1 : Number.parseFloat(quality)); + } + + const accepts = (codec: StaticContentEncoding) => { + const quality = acceptedQualityByCodec.get(codec) ?? acceptedQualityByCodec.get("*"); + return quality !== undefined && quality > 0; + }; + + if (accepts("br")) return "br"; + if (accepts("gzip")) return "gzip"; + return null; +} + +async function compressBytes( + data: Uint8Array, + encoding: StaticContentEncoding, +): Promise { + if (encoding === "gzip") { + return new Uint8Array(await gzip(data)); + } + return new Uint8Array( + await brotliCompress(data, { + params: { + // Default quality 11 costs seconds on a multi-megabyte bundle. 5 is + // the usual static-asset sweet spot, and every result is cached. + [NodeZlib.constants.BROTLI_PARAM_QUALITY]: 5, + [NodeZlib.constants.BROTLI_PARAM_SIZE_HINT]: data.byteLength, + }, + }), + ); +} + +/** + * Compress once per (file, encoding) and reuse the result. Packaged assets + * never change while the server runs, so recompressing a multi-megabyte + * bundle for every remote request is pure waste. Entries are keyed by mtime + * and size so a dev-server rebuild is not served stale. + */ +export function makeStaticCompressionCache(compress = compressBytes) { + const compressedByKey = new Map(); + /** + * Compressions already running. A cold start requests the bundle, its CSS, + * and its chunks at once, and browsers retry, so without this the same + * multi-megabyte payload is compressed once per concurrent request. + */ + const inFlightByKey = new Map>(); + let retainedBytes = 0; + + const evictOldest = (incomingBytes: number) => { + while (retainedBytes + incomingBytes > COMPRESSED_CACHE_MAX_BYTES) { + const oldestKey = compressedByKey.keys().next().value; + if (oldestKey === undefined) return; + retainedBytes -= compressedByKey.get(oldestKey)?.byteLength ?? 0; + compressedByKey.delete(oldestKey); + } + }; + + const compressAndRetain = async ( + key: string, + data: Uint8Array, + encoding: StaticContentEncoding, + ): Promise => { + const compressed = await compress(data, encoding); + // A payload that grew under compression is not worth serving encoded. + if (compressed.byteLength >= data.byteLength) return null; + + if (compressed.byteLength <= COMPRESSED_CACHE_MAX_BYTES) { + evictOldest(compressed.byteLength); + compressedByKey.set(key, compressed); + retainedBytes += compressed.byteLength; + } + return compressed; + }; + + return { + get(input: { + readonly cacheKey: string; + readonly data: Uint8Array; + readonly encoding: StaticContentEncoding; + }): Promise { + if (input.data.byteLength < MIN_COMPRESSIBLE_BYTES) return Promise.resolve(null); + + const key = `${input.encoding} ${input.cacheKey}`; + const cached = compressedByKey.get(key); + if (cached) return Promise.resolve(cached); + + const pending = inFlightByKey.get(key); + if (pending) return pending; + + // Clear the in-flight entry however this settles, so a failed + // compression is retried rather than remembered as permanently pending. + const compression = compressAndRetain(key, input.data, input.encoding).finally(() => { + inFlightByKey.delete(key); + }); + inFlightByKey.set(key, compression); + return compression; + }, + get retainedByteLength(): number { + return retainedBytes; + }, + }; +} + +export type StaticCompressionCache = ReturnType; diff --git a/apps/server/src/terminal/Manager.test.ts b/apps/server/src/terminal/Manager.test.ts index f631992e7ae3..f0ee3560bcb9 100644 --- a/apps/server/src/terminal/Manager.test.ts +++ b/apps/server/src/terminal/Manager.test.ts @@ -2345,6 +2345,25 @@ it.layer( }), ); + it.effect("points the terminal's own $SHELL at the shell that starts", () => + Effect.gen(function* () { + if ((yield* HostProcessPlatform) === "win32") return; + const { manager, ptyAdapter } = yield* createManager(5, { + shellResolver: () => "/bin/zsh", + env: { SHELL: "/bin/bash" }, + }); + yield* manager.open(openInput()); + const spawnInput = ptyAdapter.spawnInputs[0]; + expect(spawnInput).toBeDefined(); + if (!spawnInput) return; + + // The configured shell wins for the launched process and its own $SHELL, + // even though the host login shell ($SHELL) was bash. + expect(spawnInput.shell).toBe("/bin/zsh"); + expect(spawnInput.env.SHELL).toBe("/bin/zsh"); + }), + ); + it.effect("bridges PTY callbacks back into Effect-managed event streaming", () => Effect.gen(function* () { const { manager, ptyAdapter, getEvents } = yield* createManager(5, { diff --git a/apps/server/src/terminal/Manager.ts b/apps/server/src/terminal/Manager.ts index 174ed4206afc..6e4382e10726 100644 --- a/apps/server/src/terminal/Manager.ts +++ b/apps/server/src/terminal/Manager.ts @@ -56,6 +56,7 @@ import * as Schema from "effect/Schema"; import * as Scope from "effect/Scope"; import * as Semaphore from "effect/Semaphore"; import * as SynchronizedRef from "effect/SynchronizedRef"; +import * as Stream from "effect/Stream"; import * as ServerConfig from "../config.ts"; import { mergeProviderInstanceEnvironment } from "../provider/ProviderInstanceEnvironment.ts"; @@ -1390,8 +1391,29 @@ export const make = Effect.fn("TerminalManager.make")(function* () { const { terminalLogsDir } = yield* ServerConfig.ServerConfig; const ptyAdapter = yield* PtyAdapter.PtyAdapter; const portDiscovery = yield* PortScanner.PortDiscovery; + const platform = yield* HostProcessPlatform; const nativeTelemetry = yield* NativeTelemetryClient.NativeTelemetryClient; const serverSettings = yield* ServerSettings.ServerSettingsService; + + // Preferred terminal shell, sourced live from `settings.terminalShell`. + // Held in a plain closure variable so the synchronous `shellResolver` + // (invoked per spawn) can read it without an Effect. This value is consumed + // only by the terminal PTY path; agent providers spawn on a separate path + // with their own environment and never see it, so a configured terminal + // shell cannot leak into providers. + let terminalShellOverride = yield* serverSettings.getSettings.pipe( + Effect.map((settings) => settings.terminalShell.trim()), + Effect.orElseSucceed(() => ""), + ); + yield* serverSettings.streamChanges.pipe( + Stream.runForEach((next) => + Effect.sync(() => { + terminalShellOverride = next.terminalShell.trim(); + }), + ), + Effect.forkScoped, + ); + const path = yield* Path.Path; const resolveProviderInstanceEnvironment = Effect.fn( "terminal.resolveProviderInstanceEnvironment", @@ -1406,6 +1428,10 @@ export const make = Effect.fn("TerminalManager.make")(function* () { return yield* makeWithOptions({ logsDir: terminalLogsDir, ptyAdapter, + shellResolver: () => + terminalShellOverride.length > 0 + ? terminalShellOverride + : defaultShellResolver(platform, process.env), processTable: nativeTelemetry.processTable.pipe( Effect.mapError( (cause) => new TerminalSubprocessCheckError({ cause, command: "resource-monitor" }), @@ -2164,7 +2190,11 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func cwd: session.cwd, cols: session.cols, rows: session.rows, - env: spawnEnv, + // Point the terminal's own $SHELL at the shell that actually starts + // (including any configured override) so tools launched inside the + // terminal agree with it. Scoped to this PTY's env only — never the + // shared process env, so agent providers are unaffected. + env: platform === "win32" ? spawnEnv : { ...spawnEnv, SHELL: candidate.shell }, }), ); diff --git a/apps/server/src/textGeneration/CodexTextGeneration.test.ts b/apps/server/src/textGeneration/CodexTextGeneration.test.ts index 0129136d5e8d..c2157cd43cd5 100644 --- a/apps/server/src/textGeneration/CodexTextGeneration.test.ts +++ b/apps/server/src/textGeneration/CodexTextGeneration.test.ts @@ -233,7 +233,10 @@ it.layer(CodexTextGenerationTestLayer)("CodexTextGeneration", (it) => { body: "", }), launchArgs: "--enable settings-feature", - environment: { T3CODE_CODEX_LAUNCH_ARGS: " --strict-config --listen off " }, + // Merged onto the real environment, not replacing it: this env is what + // the fake `codex` shell script is spawned with, and dropping PATH + // leaves it unable to resolve `cat` on systems without /bin/cat. + environment: { ...process.env, T3CODE_CODEX_LAUNCH_ARGS: " --strict-config --listen off " }, requireArg: "--strict-config", forbidArg: "settings-feature", }, diff --git a/apps/server/src/textGeneration/CursorTextGeneration.ts b/apps/server/src/textGeneration/CursorTextGeneration.ts index 5ae057b54f63..615f72451173 100644 --- a/apps/server/src/textGeneration/CursorTextGeneration.ts +++ b/apps/server/src/textGeneration/CursorTextGeneration.ts @@ -5,7 +5,11 @@ import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import { ChildProcessSpawner } from "effect/unstable/process"; -import { type CursorSettings, type ModelSelection } from "@t3tools/contracts"; +import { + type CursorSettings, + type ModelSelection, + type ProviderOptionSelection, +} from "@t3tools/contracts"; import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git"; import { extractJsonObject } from "@t3tools/shared/schemaJson"; @@ -25,7 +29,10 @@ import { import { applyCursorAcpModelSelection, makeCursorAcpRuntime, + type CursorAcpRuntimeInput, } from "../provider/acp/CursorAcpSupport.ts"; +import type * as AcpSessionRuntime from "../provider/acp/AcpSessionRuntime.ts"; +import type * as EffectAcpErrors from "effect-acp/errors"; const CURSOR_TIMEOUT_MS = 180_000; @@ -35,15 +42,44 @@ const isTextGenerationError = Schema.is(TextGenerationError); * Build a Cursor text-generation closure bound to a specific `CursorSettings` * payload. See `makeCodexAdapter` for the overall per-instance rationale. */ -export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(function* ( - cursorSettings: CursorSettings, +interface AcpTextGenerationSettings { + readonly binaryPath: string; +} + +export interface AcpTextGenerationDefinition { + readonly providerName: string; + readonly makeRuntime: ( + settings: Settings, + input: Omit, + ) => Effect.Effect< + AcpSessionRuntime.AcpSessionRuntime["Service"], + EffectAcpErrors.AcpError, + Crypto.Crypto | import("effect/Scope").Scope + >; + readonly applyModelSelection: (input: { + readonly runtime: AcpSessionRuntime.AcpSessionRuntime["Service"]; + readonly model: string | null | undefined; + readonly selections: ReadonlyArray | null | undefined; + readonly mapError: (context: { + readonly cause: EffectAcpErrors.AcpError; + readonly step: "set-config-option" | "set-model"; + readonly configId?: string; + }) => E; + }) => Effect.Effect; +} + +export const makeAcpTextGeneration = Effect.fn("makeAcpTextGeneration")(function* < + Settings extends AcpTextGenerationSettings, +>( + settings: Settings, + definition: AcpTextGenerationDefinition, environment?: NodeJS.ProcessEnv, ) { const crypto = yield* Crypto.Crypto; const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; const resolvedEnvironment = environment ?? process.env; - const runCursorJson = ({ + const runAcpJson = ({ operation, cwd, prompt, @@ -62,13 +98,14 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu }): Effect.Effect => Effect.gen(function* () { const outputRef = yield* Ref.make(""); - const runtime = yield* makeCursorAcpRuntime({ - cursorSettings, - environment: resolvedEnvironment, - childProcessSpawner: commandSpawner, - cwd, - clientInfo: { name: "t3-code-git-text", version: "0.0.0" }, - }).pipe(Effect.provideService(Crypto.Crypto, crypto)); + const runtime = yield* definition + .makeRuntime(settings, { + environment: resolvedEnvironment, + childProcessSpawner: commandSpawner, + cwd, + clientInfo: { name: "t3-code-git-text", version: "0.0.0" }, + }) + .pipe(Effect.provideService(Crypto.Crypto, crypto)); yield* runtime.handleSessionUpdate((notification) => { const update = notification.update; @@ -85,7 +122,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu const promptResult = yield* Effect.gen(function* () { yield* runtime.start(); yield* Effect.ignore(runtime.setMode("ask")); - yield* applyCursorAcpModelSelection({ + yield* definition.applyModelSelection({ runtime, model: modelSelection.model, selections: modelSelection.options, @@ -94,8 +131,8 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu operation, detail: step === "set-config-option" - ? `Failed to set Cursor ACP config option "${configId}" for text generation.` - : "Failed to set Cursor ACP base model for text generation.", + ? `Failed to set ${definition.providerName} ACP config option "${configId}" for text generation.` + : `Failed to set ${definition.providerName} ACP base model for text generation.`, cause, }), }); @@ -111,7 +148,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu Effect.fail( new TextGenerationError({ operation, - detail: "Cursor Agent request timed out.", + detail: `${definition.providerName} request timed out.`, }), ), onSome: (value) => Effect.succeed(value), @@ -122,7 +159,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu ? cause : new TextGenerationError({ operation, - detail: "Cursor ACP request failed.", + detail: `${definition.providerName} ACP request failed.`, cause, }), ), @@ -134,8 +171,8 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu operation, detail: promptResult.stopReason === "cancelled" - ? "Cursor ACP request was cancelled." - : "Cursor Agent returned empty output.", + ? `${definition.providerName} ACP request was cancelled.` + : `${definition.providerName} returned empty output.`, }); } @@ -146,7 +183,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu Effect.fail( new TextGenerationError({ operation, - detail: "Cursor Agent returned invalid structured output.", + detail: `${definition.providerName} returned invalid structured output.`, cause, }), ), @@ -158,7 +195,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu ? cause : new TextGenerationError({ operation, - detail: "Cursor ACP text generation failed.", + detail: `${definition.providerName} ACP text generation failed.`, cause, }), ), @@ -175,7 +212,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu policy: input.policy, }); - const generated = yield* runCursorJson({ + const generated = yield* runAcpJson({ operation: "generateCommitMessage", cwd: input.cwd, prompt, @@ -204,7 +241,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu changeRequestTemplate: input.changeRequestTemplate, }); - const generated = yield* runCursorJson({ + const generated = yield* runAcpJson({ operation: "generatePrContent", cwd: input.cwd, prompt, @@ -225,7 +262,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu attachments: input.attachments, }); - const generated = yield* runCursorJson({ + const generated = yield* runAcpJson({ operation: "generateBranchName", cwd: input.cwd, prompt, @@ -246,7 +283,7 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu attachments: input.attachments, }); - const generated = yield* runCursorJson({ + const generated = yield* runAcpJson({ operation: "generateThreadTitle", cwd: input.cwd, prompt, @@ -266,3 +303,18 @@ export const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(fu generateThreadTitle, } satisfies TextGeneration.TextGeneration["Service"]; }); + +export const makeCursorTextGeneration = ( + cursorSettings: CursorSettings, + environment?: NodeJS.ProcessEnv, +) => + makeAcpTextGeneration( + cursorSettings, + { + providerName: "Cursor", + makeRuntime: (settings, input) => + makeCursorAcpRuntime({ ...input, cursorSettings: settings }), + applyModelSelection: applyCursorAcpModelSelection, + }, + environment, + ); diff --git a/apps/server/src/textGeneration/TextGeneration.ts b/apps/server/src/textGeneration/TextGeneration.ts index 84730d639ac6..8be10d293ea5 100644 --- a/apps/server/src/textGeneration/TextGeneration.ts +++ b/apps/server/src/textGeneration/TextGeneration.ts @@ -8,7 +8,13 @@ import * as ProviderInstanceRegistry from "../provider/Services/ProviderInstance import type { ProviderInstance } from "../provider/ProviderDriver.ts"; import type { TextGenerationPolicy } from "./TextGenerationPolicy.ts"; -export type TextGenerationProvider = "codex" | "claudeAgent" | "cursor" | "grok" | "opencode"; +export type TextGenerationProvider = + | "codex" + | "claudeAgent" + | "cursor" + | "grok" + | "kimi" + | "opencode"; export interface CommitMessageGenerationInput { cwd: string; diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts index 0e6b0c1eecd6..f75c5184cbcd 100644 --- a/apps/server/src/usage/UsageService.ts +++ b/apps/server/src/usage/UsageService.ts @@ -43,6 +43,7 @@ import { ServerConfig } from "../config.ts"; import { expandHomePath } from "../pathExpansion.ts"; import * as ServerSettings from "../serverSettings.ts"; import { resolveClaudeHomePath } from "../provider/Drivers/ClaudeHome.ts"; +import { resolveKimiHomePath } from "../provider/Drivers/GrokKimiHome.ts"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; import { UsageAggregator } from "./usageAggregation.ts"; import { createOverrideRateTable, parseRateTable, type RateTable } from "./usagePricing.ts"; @@ -259,6 +260,7 @@ export const make = Effect.gen(function* () { grokHomeEnv.length > 0 ? path.resolve(expandHomePath(grokHomeEnv)) : path.join(NodeOS.homedir(), ".grok"); + const kimiHome = yield* resolveKimiHomePath(); return [ { provider: "claude" as const, dir: claudeDir }, @@ -268,6 +270,7 @@ export const make = Effect.gen(function* () { dir: path.join(grokHome, "sessions"), fileName: "updates.jsonl", }, + { provider: "kimi" as const, dir: path.join(kimiHome, "sessions") }, ]; }); diff --git a/apps/server/src/usage/usagePricing.ts b/apps/server/src/usage/usagePricing.ts index 6c94be424827..96d24958436f 100644 --- a/apps/server/src/usage/usagePricing.ts +++ b/apps/server/src/usage/usagePricing.ts @@ -156,6 +156,12 @@ const UNPRICEABLE_MODELS = new Set([ "sonnet", "haiku", "fable", + // Kimi's wire log names no model, and a rotated Grok log can separate a + // session's model announcement from its turns, so those arrive under bare + // provider-name sentinels rather than a guess. Reporting them unpriced keeps + // the cost honest. Neither bare name is itself a priced model. + "kimi", + "grok", ]); export function lookupRate(table: RateTable, model: string): ModelRate | null { diff --git a/apps/server/src/usage/usageScanCache.ts b/apps/server/src/usage/usageScanCache.ts index 224f109147e4..2d33de950a4e 100644 --- a/apps/server/src/usage/usageScanCache.ts +++ b/apps/server/src/usage/usageScanCache.ts @@ -219,7 +219,9 @@ export function decodeScanCache(document: unknown): ScanCache { if (typeof raw !== "object" || raw === null) continue; const entry = raw as Partial; if (typeof entry.s !== "number" || typeof entry.m !== "number") continue; - if (entry.p !== "claude" && entry.p !== "codex" && entry.p !== "grok") continue; + if (entry.p !== "claude" && entry.p !== "codex" && entry.p !== "grok" && entry.p !== "kimi") { + continue; + } if (!isRecordArray(entry.r) || !isRecordArray(entry.t)) continue; // Position fields feed byte offsets and a Buffer allocation in the reader, // so anything outside their real ranges must reject the entry: a bogus diff --git a/apps/server/src/usage/usageTranscriptReader.ts b/apps/server/src/usage/usageTranscriptReader.ts index 9e5ab6e0c9e0..032b2f07b577 100644 --- a/apps/server/src/usage/usageTranscriptReader.ts +++ b/apps/server/src/usage/usageTranscriptReader.ts @@ -22,10 +22,12 @@ import type { UsageProviderKind } from "@t3tools/contracts"; import { initialCodexScanState, + initialKimiScanState, mightCarryUsage, parseClaudeLine, parseCodexLine, parseGrokLine, + parseKimiLine, type CodexScanState, type UsageRecord, } from "./usageTranscripts.ts"; @@ -217,6 +219,9 @@ export async function readTranscriptRecords( resumed = true; } + // Kimi names no session on any record; the wire log's own directory is the + // session, which is what `distinctSessions` counts. + const kimiState = initialKimiScanState(NodePath.basename(NodePath.dirname(filePath))); const parseLine = (line: string, state: CodexScanState, out: UsageRecord[]): void => { if (provider === "codex") { if ( @@ -235,6 +240,11 @@ export async function readTranscriptRecords( for (const grokRecord of parseGrokLine(line)) out.push(grokRecord); return; } + if (provider === "kimi") { + const record = parseKimiLine(line, kimiState); + if (record !== null) out.push(record); + return; + } const record = parseClaudeLine(line); if (record !== null) out.push(record); }; diff --git a/apps/server/src/usage/usageTranscripts.test.ts b/apps/server/src/usage/usageTranscripts.test.ts index b09db613ed85..ae265464f3b1 100644 --- a/apps/server/src/usage/usageTranscripts.test.ts +++ b/apps/server/src/usage/usageTranscripts.test.ts @@ -3,9 +3,12 @@ import { describe, expect, it } from "@effect/vitest"; import { GROK_COST_USD_TICKS_PER_DOLLAR, initialCodexScanState, + initialKimiScanState, + KIMI_UNKNOWN_MODEL, parseClaudeLine, parseCodexLine, parseGrokLine, + parseKimiLine, totalTokens, } from "./usageTranscripts.ts"; @@ -238,6 +241,122 @@ describe("parseCodexLine", () => { }); }); +describe("parseKimiLine", () => { + // Shape copied from a real ~/.kimi/sessions///wire.jsonl. + const statusUpdate = ( + usage: Record, + messageId = "chatcmpl-0PaxSO2787FGCr5nPVWAxidi", + timestamp = 1785096129.2452343, + ) => + JSON.stringify({ + timestamp, + message: { + type: "StatusUpdate", + payload: { + context_usage: 0.0167, + context_tokens: 17600, + max_context_tokens: 1048576, + token_usage: usage, + message_id: messageId, + plan_mode: false, + mcp_status: null, + }, + }, + }); + + it("reads a served response's counts and takes the session from the caller", () => { + const state = initialKimiScanState("15f9b4f3-af5d-4939-9a82-c4ca191b5d58"); + const record = parseKimiLine( + statusUpdate({ + input_other: 15296, + output: 129, + input_cache_read: 2304, + input_cache_creation: 0, + }), + state, + ); + + expect(record).not.toBeNull(); + expect(record?.provider).toBe("kimi"); + expect(record?.sessionId).toBe("15f9b4f3-af5d-4939-9a82-c4ca191b5d58"); + expect(record?.totals.uncachedInputTokens).toBe(15296); + expect(record?.totals.cachedInputTokens).toBe(2304); + expect(record?.totals.cacheCreationTokens).toBe(0); + expect(record?.totals.outputTokens).toBe(129); + // Epoch seconds, not milliseconds. + expect(record?.timestampMs).toBe(1785096129245); + }); + + it("records no model so the turn prices as unpriced rather than a guess", () => { + const state = initialKimiScanState("session"); + const record = parseKimiLine(statusUpdate({ input_other: 10, output: 5 }), state); + expect(record?.model).toBe(KIMI_UNKNOWN_MODEL); + expect(record?.reportedCostUsd).toBeNull(); + }); + + it("carries message_id so a refreshed status is not counted twice", () => { + const state = initialKimiScanState("session"); + const record = parseKimiLine(statusUpdate({ input_other: 10, output: 5 }, "msg-1"), state); + expect(record?.dedupeKey).toBe("msg-1"); + }); + + it("sums across turns, because each response re-bills its whole context", () => { + // A second turn re-sends the grown context, so its input side legitimately + // repeats the first turn's tokens — that is what was billed. Treating the + // counts as a running session total and taking only the last would + // undercount every turn before it. + const state = initialKimiScanState("session"); + const first = parseKimiLine( + statusUpdate({ input_other: 15296, output: 129, input_cache_read: 2304 }, "msg-1"), + state, + ); + const second = parseKimiLine( + statusUpdate({ input_other: 15400, output: 240, input_cache_read: 2304 }, "msg-2"), + state, + ); + + expect(first?.dedupeKey).toBe("msg-1"); + expect(second?.dedupeKey).toBe("msg-2"); + // Distinct responses, so nothing collapses them. + expect(second?.totals.outputTokens).toBe(240); + }); + + it("gives a refreshed status the same dedupe key so it collapses", () => { + // Kimi re-emits a status without a new round trip; both copies carry the + // same message_id, which is what the caller de-duplicates on. + const state = initialKimiScanState("session"); + const a = parseKimiLine(statusUpdate({ input_other: 100, output: 10 }, "msg-1"), state); + const b = parseKimiLine(statusUpdate({ input_other: 100, output: 10 }, "msg-1"), state); + + expect(a?.dedupeKey).toBe("msg-1"); + expect(b?.dedupeKey).toBe(a?.dedupeKey); + }); + + it("ignores the wire log's other frames", () => { + const state = initialKimiScanState("session"); + expect( + parseKimiLine(JSON.stringify({ type: "metadata", protocol_version: "1.10" }), state), + ).toBeNull(); + expect( + parseKimiLine( + JSON.stringify({ + timestamp: 1785096129.2, + message: { type: "TurnBegin", payload: { user_input: "hi" } }, + }), + state, + ), + ).toBeNull(); + expect(parseKimiLine("not json", state)).toBeNull(); + }); + + it("drops a status update that carries no tokens", () => { + const state = initialKimiScanState("session"); + expect( + parseKimiLine(statusUpdate({ input_other: 0, output: 0, input_cache_read: 0 }), state), + ).toBeNull(); + }); +}); + describe("totalTokens", () => { it("does not add reasoning on top of output", () => { expect( diff --git a/apps/server/src/usage/usageTranscripts.ts b/apps/server/src/usage/usageTranscripts.ts index 5d909379eb10..663c22567c8f 100644 --- a/apps/server/src/usage/usageTranscripts.ts +++ b/apps/server/src/usage/usageTranscripts.ts @@ -70,6 +70,7 @@ export function totalTokens(totals: UsageTokenTotals): number { export function mightCarryUsage(line: string, provider: UsageProviderKind): boolean { if (provider === "claude") return line.includes('"usage"'); if (provider === "grok") return line.includes('"turn_completed"'); + if (provider === "kimi") return line.includes('"token_usage"'); return line.includes('"token_count"'); } @@ -485,4 +486,91 @@ export function parseGrokLine(line: string): readonly UsageRecord[] { return results; } +/* Kimi */ +/* -------------------------------------------------------------------------- */ + +/** + * The model recorded for Kimi turns. + * + * Kimi's wire log names no model on any record, and the CLI's configured model + * at scan time says nothing about what served a turn weeks ago. Rather than + * attribute — and therefore price — turns against a guess, they are recorded + * under a sentinel that `usagePricing` treats as unpriceable, so Kimi shows + * real token counts and an honest "unpriced" share instead of a fabricated + * cost. + */ +export const KIMI_UNKNOWN_MODEL = "kimi"; + +/** Rolling state for a single Kimi `wire.jsonl`. */ +export interface KimiScanState { + sessionId: string; +} + +export function initialKimiScanState(sessionId: string): KimiScanState { + return { sessionId }; +} + +/** + * Feeds one line of a Kimi wire log into `state`, returning a record when the + * line was a status update carrying token usage. + * + * Each `StatusUpdate` reports the counts for one served response — the input + * side re-states the whole context because that is what the request billed — + * so these sum across turns. `message_id` de-duplicates the repeats Kimi emits + * when a status is refreshed without a new round trip. + */ +export function parseKimiLine(line: string, state: KimiScanState): UsageRecord | null { + let parsed: unknown; + try { + parsed = JSON.parse(line); + } catch { + return null; + } + if (typeof parsed !== "object" || parsed === null) return null; + + const record = parsed as Record; + const message = record["message"]; + if (typeof message !== "object" || message === null) return null; + const messageRecord = message as Record; + if (messageRecord["type"] !== "StatusUpdate") return null; + + const payload = messageRecord["payload"]; + if (typeof payload !== "object" || payload === null) return null; + const payloadRecord = payload as Record; + const usage = payloadRecord["token_usage"]; + if (typeof usage !== "object" || usage === null) return null; + const usageRecord = usage as Record; + + // Kimi timestamps are epoch seconds with a fractional part. + const timestamp = record["timestamp"]; + if (typeof timestamp !== "number" || !Number.isFinite(timestamp) || timestamp <= 0) return null; + const timestampMs = Math.trunc(timestamp * 1000); + + const outputTokens = int(usageRecord["output"]); + const totals: UsageTokenTotals = { + // `input_other` already excludes the cached and cache-creation portions. + uncachedInputTokens: int(usageRecord["input_other"]), + cachedInputTokens: int(usageRecord["input_cache_read"]), + cacheCreationTokens: int(usageRecord["input_cache_creation"]), + outputTokens, + // Kimi does not break reasoning out of the output count. + reasoningTokens: 0, + }; + + if (totalTokens(totals) === 0) return null; + + const messageId = payloadRecord["message_id"]; + + return { + provider: "kimi", + timestampMs, + model: KIMI_UNKNOWN_MODEL, + sessionId: state.sessionId, + totals, + // Kimi does not report cost in the wire log. + reportedCostUsd: null, + dedupeKey: typeof messageId === "string" && messageId.length > 0 ? messageId : null, + }; +} + export { EMPTY_TOTALS }; diff --git a/apps/server/src/vcs/GitVcsDriver.test.ts b/apps/server/src/vcs/GitVcsDriver.test.ts index 031055a3b6cb..164e3513a3ba 100644 --- a/apps/server/src/vcs/GitVcsDriver.test.ts +++ b/apps/server/src/vcs/GitVcsDriver.test.ts @@ -5,11 +5,12 @@ import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; import * as PlatformError from "effect/PlatformError"; import { ChildProcessSpawner } from "effect/unstable/process"; -import { assert, it } from "@effect/vitest"; +import { assert, describe, it } from "@effect/vitest"; import { GitCommandError } from "@t3tools/contracts"; import * as ServerConfig from "../config.ts"; import * as GitVcsDriver from "./GitVcsDriver.ts"; +import * as VcsDriver from "./VcsDriver.ts"; import * as VcsProcess from "./VcsProcess.ts"; import { runVcsDriverContractSuite } from "./testing/VcsDriverContractHarness.ts"; @@ -65,6 +66,96 @@ runVcsDriverContractSuite({ }, }); +const withTempDir = (use: (cwd: string) => Effect.Effect) => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-git-bare-" }); + return yield* use(cwd); + }).pipe(Effect.scoped, Effect.provide(GitContractLayer)); + +describe("GitVcsDriver bare repositories", () => { + it.effect("detects a bare repository instead of reporting no repository", () => + withTempDir((cwd) => + Effect.gen(function* () { + const path = yield* Path.Path; + const driver = yield* VcsDriver.VcsDriver; + yield* runGit(cwd, ["init", "--bare"]); + + const identity = yield* driver.detectRepository(cwd); + + assert.equal(identity?.kind, "git"); + assert.equal(identity?.bare, true); + // A bare repository has no toplevel, so the metadata directory is the root. + assert.equal(identity?.rootPath, path.normalize(cwd)); + assert.isFalse(yield* driver.isInsideWorkTree(cwd)); + }), + ), + ); + + it.effect("detects a repository whose config marks an existing checkout bare", () => + withTempDir((cwd) => + Effect.gen(function* () { + const driver = yield* VcsDriver.VcsDriver; + yield* runGit(cwd, ["init"]); + // The shape a repository lands in when `core.bare` is flipped under a + // populated checkout: every Git route used to fail detection outright. + yield* runGit(cwd, ["config", "core.bare", "true"]); + + const identity = yield* driver.detectRepository(cwd); + + assert.equal(identity?.kind, "git"); + assert.equal(identity?.bare, true); + }), + ), + ); + + it.effect("still reports no repository outside one", () => + withTempDir((cwd) => + Effect.gen(function* () { + const driver = yield* VcsDriver.VcsDriver; + assert.equal(yield* driver.detectRepository(cwd), null); + }), + ), + ); + + it.effect("creates a usable worktree from a bare repository", () => + withTempDir((root) => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const driver = yield* VcsDriver.VcsDriver; + const gitDriver = yield* GitVcsDriver.GitVcsDriver; + + const source = path.join(root, "source"); + const bare = path.join(root, "bare.git"); + const worktree = path.join(root, "worktree"); + yield* fileSystem.makeDirectory(source, { recursive: true }); + yield* runGit(source, ["init"]); + yield* runGit(source, ["config", "user.email", "test@test.com"]); + yield* runGit(source, ["config", "user.name", "Test"]); + yield* runGit(source, ["commit", "--allow-empty", "-m", "init"]); + // Explicit branch name: `git init` defaults vary by host config. + yield* runGit(source, ["branch", "t3-base"]); + yield* runGit(root, ["clone", "--bare", source, bare]); + + const result = yield* gitDriver.createWorktree({ + cwd: bare, + refName: "t3-base", + newRefName: "feature", + path: worktree, + }); + + assert.equal(result.worktree.path, worktree); + assert.equal(result.worktree.refName, "feature"); + // The thread's checkout is a real working tree even though its source has none. + assert.isTrue(yield* driver.isInsideWorkTree(worktree)); + const worktreeIdentity = yield* driver.detectRepository(worktree); + assert.equal(worktreeIdentity?.bare, false); + }), + ), + ); +}); + it.effect("GitVcsDriver forwards execute env to the VCS process", () => { let observedEnv: NodeJS.ProcessEnv | undefined; let observedAppendTruncationMarker: boolean | undefined; diff --git a/apps/server/src/vcs/GitVcsDriver.ts b/apps/server/src/vcs/GitVcsDriver.ts index f1e48a24d6fe..9c379a59dd96 100644 --- a/apps/server/src/vcs/GitVcsDriver.ts +++ b/apps/server/src/vcs/GitVcsDriver.ts @@ -30,6 +30,7 @@ import { type VcsStatusInput, type VcsStatusResult, } from "@t3tools/contracts"; +import * as DirenvEnvironment from "../provider/DirenvEnvironment.ts"; import { makeGitVcsDriverCore, PATCH_RENDER_PREFIX_ARGS, @@ -118,6 +119,7 @@ export interface GitCommitProgress { export interface GitCommitOptions { readonly timeoutMs?: number; readonly progress?: GitCommitProgress; + readonly disableSigning?: boolean; } export interface GitPushResult { @@ -467,18 +469,41 @@ export const makeVcsDriverShape = Effect.fn("makeGitVcsDriverShape")(function* ( ignoreClassifier: "native" as const, }; - const isInsideWorkTree: VcsDriver.VcsDriver["Service"]["isInsideWorkTree"] = (cwd) => + /** + * A single `rev-parse` separates the three states we care about: outside any + * repository (non-zero exit), a bare repository (no working tree of its own), + * and an ordinary checkout. Keep it one call — repeated rev-parse probes on + * every status poll were a major VCS load contributor. + */ + const probeRepository = (cwd: string) => gitCommand( vcsProcess, - "GitVcsDriver.isInsideWorkTree", + "GitVcsDriver.probeRepository", cwd, - ["rev-parse", "--is-inside-work-tree"], + ["rev-parse", "--is-bare-repository", "--is-inside-work-tree"], { allowNonZeroExit: true, timeoutMs: 5_000, maxOutputBytes: 4_096, }, - ).pipe(Effect.map((result) => result.exitCode === 0 && result.stdout.trim() === "true")); + ).pipe( + Effect.map((result) => { + if (result.exitCode !== 0) { + return null; + } + const [bare, insideWorkTree] = result.stdout + .trim() + .split("\n") + .map((line) => line.trim()); + return { + bare: bare === "true", + insideWorkTree: insideWorkTree === "true", + }; + }), + ); + + const isInsideWorkTree: VcsDriver.VcsDriver["Service"]["isInsideWorkTree"] = (cwd) => + probeRepository(cwd).pipe(Effect.map((probe) => probe?.insideWorkTree === true)); const execute: VcsDriver.VcsDriver["Service"]["execute"] = (input) => gitCommand(vcsProcess, input.operation, input.cwd, input.args, { @@ -496,25 +521,51 @@ export const makeVcsDriverShape = Effect.fn("makeGitVcsDriverShape")(function* ( const detectRepository: VcsDriver.VcsDriver["Service"]["detectRepository"] = Effect.fn( "detectRepository", )(function* (cwd) { - if (!(yield* isInsideWorkTree(cwd))) { + const probe = yield* probeRepository(cwd); + if (!probe) { + return null; + } + if (!probe.insideWorkTree && !probe.bare) { + // Inside the metadata directory of a non-bare repository (e.g. `.git/`), + // which is not a workspace any driver operation can act on. return null; } - const root = yield* gitCommand(vcsProcess, "GitVcsDriver.detectRepository.root", cwd, [ - "rev-parse", - "--show-toplevel", - ]); const gitCommonDir = yield* gitCommand( vcsProcess, "GitVcsDriver.detectRepository.commonDir", cwd, ["rev-parse", "--git-common-dir"], ).pipe(Effect.orElseSucceed(() => null)); + const metadataPath = gitCommonDir?.stdout.trim() || null; + + // A bare repository has no toplevel to report, but it is still a complete + // repository: `fetch`, ref plumbing, and `worktree add` all work against + // it, so it is a valid source for thread worktrees. Report its metadata + // directory as the root rather than rejecting it as "not a repository". + if (!probe.insideWorkTree) { + const commonDir = metadataPath ?? "."; + return { + kind: "git" as const, + rootPath: path.normalize( + path.isAbsolute(commonDir) ? commonDir : path.resolve(cwd, commonDir), + ), + metadataPath, + bare: true, + freshness: yield* nowFreshness(), + }; + } + + const root = yield* gitCommand(vcsProcess, "GitVcsDriver.detectRepository.root", cwd, [ + "rev-parse", + "--show-toplevel", + ]); return { kind: "git" as const, rootPath: root.stdout.trim(), - metadataPath: gitCommonDir?.stdout.trim() || null, + metadataPath, + bare: false, freshness: yield* nowFreshness(), }; }); @@ -940,5 +991,9 @@ export const make = Effect.gen(function* () { return GitVcsDriver.of(git); }); -export const vcsLayer = Layer.effect(VcsDriver.VcsDriver, makeVcsDriver); -export const layer = Layer.effect(GitVcsDriver, make); +export const vcsLayer = Layer.effect(VcsDriver.VcsDriver, makeVcsDriver).pipe( + Layer.provide(DirenvEnvironment.layerLive), +); +export const layer = Layer.effect(GitVcsDriver, make).pipe( + Layer.provide(DirenvEnvironment.layerLive), +); diff --git a/apps/server/src/vcs/GitVcsDriverCore.test.ts b/apps/server/src/vcs/GitVcsDriverCore.test.ts index fb741b28ee7c..ba216d34c621 100644 --- a/apps/server/src/vcs/GitVcsDriverCore.test.ts +++ b/apps/server/src/vcs/GitVcsDriverCore.test.ts @@ -217,51 +217,6 @@ it.effect("uses stable diagnostics for every parsed non-repository command", () }).pipe(Effect.provide(layer)); }); -it.effect("invalidates origin remote cache when a driver mutation adds origin", () => - Effect.gen(function* () { - const driver = yield* GitVcsDriver.GitVcsDriver; - const cwd = yield* makeTmpDir(); - const remote = yield* makeTmpDir("git-vcs-driver-remote-"); - yield* initRepoWithCommit(cwd); - yield* git(remote, ["init", "--bare"]); - - const before = yield* driver.statusDetailsLocal(cwd); - assert.equal(before.hasOriginRemote, false); - - yield* driver.ensureRemote({ cwd, preferredName: "origin", url: remote }); - - const after = yield* driver.statusDetailsLocal(cwd); - assert.equal(after.hasOriginRemote, true); - }).pipe(Effect.provide(TestLayer)), -); - -it.effect("re-reads origin remote status after cache TTL expiry and bypassed invalidation", () => - Effect.gen(function* () { - const driver = yield* GitVcsDriver.GitVcsDriver; - const cwd = yield* makeTmpDir(); - const remote = yield* makeTmpDir("git-vcs-driver-remote-"); - yield* initRepoWithCommit(cwd); - yield* git(remote, ["init", "--bare"]); - - // First call caches hasOriginRemote = false (5-min TTL) - assert.equal((yield* driver.statusDetailsLocal(cwd)).hasOriginRemote, false); - - // Add origin via raw git (bypasses invalidation hook) - yield* git(cwd, ["remote", "add", "origin", remote]); - - // Cache still has the stale false (TTL not yet expired) - const stillCached = yield* driver.statusDetailsLocal(cwd); - assert.equal(stillCached.hasOriginRemote, false); - - // Advance past the 5-minute TTL so the cache entry expires - yield* TestClock.adjust("6 minutes"); - - // After expiry, the next call re-executes and picks up the remote - const afterExpiry = yield* driver.statusDetailsLocal(cwd); - assert.equal(afterExpiry.hasOriginRemote, true); - }).pipe(Effect.provide(TestLayer)), -); - it.effect("coalesces concurrent ref pages into one repository snapshot", () => Effect.scoped( Effect.gen(function* () { @@ -1562,6 +1517,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => { assert.equal(created.worktree.path, worktreePath); assert.equal(created.worktree.refName, "feature/worktree"); + assert.deepEqual(created.preparation, { _tag: "ready", attempts: 0 }); assert.equal(yield* git(worktreePath, ["branch", "--show-current"]), "feature/worktree"); yield* driver.removeWorktree({ cwd, path: worktreePath }); @@ -1570,6 +1526,200 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => { }), ); + it.effect("awaits the target worktree hook when the source checkout has no hooks", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + yield* initRepoWithCommit(cwd); + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const worktreePath = pathService.join( + yield* makeTmpDir("git-worktrees-"), + "prepared-worktree", + ); + + yield* fileSystem.makeDirectory(pathService.join(cwd, ".githooks")); + const hookPath = pathService.join(cwd, ".githooks", "post-checkout"); + yield* fileSystem.writeFileString( + hookPath, + '#!/bin/sh\nprintf prepared >"$(git rev-parse --show-toplevel)/.prepared"\n', + ); + yield* fileSystem.chmod(hookPath, 0o755); + yield* git(cwd, ["add", ".githooks/post-checkout"]); + yield* git(cwd, ["commit", "-m", "add native checkout hook"]); + const targetRef = yield* git(cwd, ["rev-parse", "HEAD"]); + + // Reproduce T3VM: the common source checkout predates `.githooks`, but + // the target ref used for the new worktree contains it. + yield* git(cwd, ["checkout", `${targetRef}^`]); + yield* git(cwd, ["config", "core.hooksPath", ".githooks"]); + + const driver = yield* GitVcsDriver.GitVcsDriver; + const created = yield* driver.createWorktree({ + cwd, + path: worktreePath, + refName: targetRef, + newRefName: "feature/prepared-worktree", + }); + + assert.equal( + yield* fileSystem.readFileString(pathService.join(worktreePath, ".prepared")), + "prepared", + ); + assert.deepEqual(created.preparation, { _tag: "ready", attempts: 1 }); + assert.equal( + yield* git(worktreePath, ["branch", "--show-current"]), + "feature/prepared-worktree", + ); + }), + ); + + it.effect("passes deferred dependency installation through native and explicit hooks", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + const { initialBranch } = yield* initRepoWithCommit(cwd); + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const worktreePath = pathService.join( + yield* makeTmpDir("git-worktrees-"), + "deferred-worktree", + ); + + yield* fileSystem.makeDirectory(pathService.join(cwd, ".githooks")); + const hookPath = pathService.join(cwd, ".githooks", "post-checkout"); + yield* fileSystem.writeFileString( + hookPath, + [ + "#!/bin/sh", + 'mode="${T3CODE_DEFER_DEPENDENCY_INSTALL:-blocking}"', + 'printf "%s\\n" "$mode" >>"$(git rev-parse --show-toplevel)/.preparation-mode"', + "", + ].join("\n"), + ); + yield* fileSystem.chmod(hookPath, 0o755); + yield* git(cwd, ["add", ".githooks/post-checkout"]); + yield* git(cwd, ["commit", "-m", "add checkout hook"]); + yield* git(cwd, ["config", "core.hooksPath", ".githooks"]); + + const driver = yield* GitVcsDriver.GitVcsDriver; + const created = yield* driver.createWorktree({ + cwd, + path: worktreePath, + refName: initialBranch, + newRefName: "feature/deferred-worktree", + deferDependencyInstall: true, + }); + + assert.deepEqual(created.preparation, { _tag: "ready", attempts: 1 }); + assert.deepEqual( + (yield* fileSystem.readFileString(pathService.join(worktreePath, ".preparation-mode"))) + .trim() + .split("\n"), + ["1", "1"], + ); + }), + ); + + it.effect("keeps a worktree when deterministic target preparation fails", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + yield* initRepoWithCommit(cwd); + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const worktreePath = pathService.join( + yield* makeTmpDir("git-worktrees-"), + "degraded-worktree", + ); + + yield* fileSystem.makeDirectory(pathService.join(cwd, ".githooks")); + const hookPath = pathService.join(cwd, ".githooks", "post-checkout"); + yield* fileSystem.writeFileString( + hookPath, + [ + "#!/bin/sh", + '[ "${T3CODE_WORKTREE_PREPARATION_STRICT:-0}" = "1" ] || exit 99', + 'echo "ERR_PNPM_LOCKFILE_CONFIG_MISMATCH: catalogs differ" >&2', + "exit 17", + "", + ].join("\n"), + ); + yield* fileSystem.chmod(hookPath, 0o755); + yield* git(cwd, ["add", ".githooks/post-checkout"]); + yield* git(cwd, ["commit", "-m", "add failing checkout hook"]); + const targetRef = yield* git(cwd, ["rev-parse", "HEAD"]); + yield* git(cwd, ["checkout", `${targetRef}^`]); + yield* git(cwd, ["config", "core.hooksPath", ".githooks"]); + + const driver = yield* GitVcsDriver.GitVcsDriver; + const created = yield* driver.createWorktree({ + cwd, + path: worktreePath, + refName: targetRef, + newRefName: "feature/degraded-worktree", + }); + + assert.equal(created.worktree.path, worktreePath); + assert.deepEqual(created.preparation, { + _tag: "degraded", + attempts: 1, + command: "git hook run post-checkout", + detail: "ERR_PNPM_LOCKFILE_CONFIG_MISMATCH: catalogs differ", + exitCode: 17, + }); + assert.equal( + yield* git(worktreePath, ["branch", "--show-current"]), + "feature/degraded-worktree", + ); + }), + ); + + it.effect("retries transient target preparation failures once", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + yield* initRepoWithCommit(cwd); + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const worktreePath = pathService.join( + yield* makeTmpDir("git-worktrees-"), + "recovered-worktree", + ); + const attemptFile = `${worktreePath}.preparation-attempted`; + const preparedFile = `${worktreePath}.prepared`; + + yield* fileSystem.makeDirectory(pathService.join(cwd, ".githooks")); + const hookPath = pathService.join(cwd, ".githooks", "post-checkout"); + yield* fileSystem.writeFileString( + hookPath, + [ + "#!/bin/sh", + `if [ ! -f "${attemptFile}" ]; then`, + ` touch "${attemptFile}"`, + ' echo "temporary package registry failure" >&2', + " exit 1", + "fi", + `printf prepared >"${preparedFile}"`, + "", + ].join("\n"), + ); + yield* fileSystem.chmod(hookPath, 0o755); + yield* git(cwd, ["add", ".githooks/post-checkout"]); + yield* git(cwd, ["commit", "-m", "add recovering checkout hook"]); + const targetRef = yield* git(cwd, ["rev-parse", "HEAD"]); + yield* git(cwd, ["checkout", `${targetRef}^`]); + yield* git(cwd, ["config", "core.hooksPath", ".githooks"]); + + const driver = yield* GitVcsDriver.GitVcsDriver; + const created = yield* driver.createWorktree({ + cwd, + path: worktreePath, + refName: targetRef, + newRefName: "feature/recovered-worktree", + }); + + assert.deepEqual(created.preparation, { _tag: "ready", attempts: 2 }); + assert.equal(yield* fileSystem.readFileString(preparedFile), "prepared"); + }), + ); + it.effect("allows worktree removal to run longer than the default command timeout", () => Effect.gen(function* () { const delegate = yield* ChildProcessSpawner.ChildProcessSpawner; diff --git a/apps/server/src/vcs/GitVcsDriverCore.ts b/apps/server/src/vcs/GitVcsDriverCore.ts index 3c7e018ddea7..9d2283a0ab64 100644 --- a/apps/server/src/vcs/GitVcsDriverCore.ts +++ b/apps/server/src/vcs/GitVcsDriverCore.ts @@ -25,6 +25,7 @@ import { type ReviewDiffPreviewInput, type ReviewDiffPreviewSource, type VcsRef, + type VcsWorktreePreparation, } from "@t3tools/contracts"; import { dedupeRemoteBranchesWithLocalMatches, normalizeGitRemoteUrl } from "@t3tools/shared/git"; import { compactTraceAttributes } from "@t3tools/shared/observability"; @@ -58,8 +59,39 @@ const REVIEW_DIFF_FILE_MAX_OUTPUT_BYTES = 1024 * 1024; // otherwise leak into the patch and leave every parsed file unnamed. export const PATCH_RENDER_PREFIX_ARGS = ["--src-prefix=a/", "--dst-prefix=b/"] as const; const WORKSPACE_FILES_MAX_OUTPUT_BYTES = 120_000; -const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15); +const WORKTREE_PREPARATION_DETAIL_MAX_CHARS = 8_000; +const DETERMINISTIC_WORKTREE_PREPARATION_FAILURES = [ + "ERR_PNPM_LOCKFILE_CONFIG_MISMATCH", + "ERR_PNPM_OUTDATED_LOCKFILE", + "ERR_PNPM_FROZEN_LOCKFILE_WITH_OUTDATED_LOCKFILE", +] as const; +/** + * Align with remote status cache TTL so automatic pollers do not re-fetch upstream + * more often than we recompute remote status. + */ +const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(90); const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5); +/** + * Cap concurrent `git` spawns across all worktrees. Unbounded fan-out during + * reconnect/VCS storms was thrashing host memory and delaying RPC pongs. + */ +const GIT_PROCESS_CONCURRENCY = 8; + +function worktreePreparationDetail(input: { + readonly stderr: string; + readonly stdout: string; + readonly fallback: string; +}): string { + const output = [input.stderr.trim(), input.stdout.trim()].filter(Boolean).join("\n"); + const detail = output.length > 0 ? output : input.fallback; + return detail.length <= WORKTREE_PREPARATION_DETAIL_MAX_CHARS + ? detail + : detail.slice(-WORKTREE_PREPARATION_DETAIL_MAX_CHARS); +} + +function isDeterministicWorktreePreparationFailure(detail: string): boolean { + return DETERMINISTIC_WORKTREE_PREPARATION_FAILURES.some((marker) => detail.includes(marker)); +} const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30); const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15); @@ -72,8 +104,6 @@ const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64; const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2); const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5); const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30); -const STATUS_DEFAULT_BRANCH_CACHE_TTL = Duration.minutes(5); -const STATUS_ORIGIN_EXISTS_CACHE_TTL = Duration.minutes(5); const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({ GCM_INTERACTIVE: "never", GIT_ASKPASS: "", @@ -83,6 +113,54 @@ const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({ } satisfies NodeJS.ProcessEnv); const DEFAULT_BASE_BRANCH_CANDIDATES = ["main", "master"] as const; const GIT_LIST_BRANCHES_DEFAULT_LIMIT = 100; + +const COMMIT_SIGNING_FAILURE_PATTERNS = [ + /gpg(?:2)?(?:\.exe)?: .*failed to sign/i, + /gpg failed to sign the data/i, + /signing failed:/i, + /failed to sign the data/i, + /pinentry.*(?:failed|error|not found|no such file|cancell?ed)/i, + /(?:failed|error|no such file|cancell?ed).*pinentry/i, + /inappropriate ioctl for device/i, + /cannot open \/dev\/tty/i, + /no secret key/i, + /secret key not available/i, + /ssh-keygen(?:\.exe)?:?.*(?:failed|error|couldn['’]t).*sign/i, + /couldn['’]t sign (?:message|data)/i, + /couldn['’]t load public key/i, + /no private key found for public key/i, + /load key .*: (?:invalid format|no such file or directory|permission denied)/i, + /agent refused operation/i, +] as const; + +export function isCommitSigningFailureStderr(stderr: string): boolean { + return COMMIT_SIGNING_FAILURE_PATTERNS.some((pattern) => pattern.test(stderr)); +} + +/** Longer than any real git error line, short enough to keep logs readable. */ +const GIT_STDERR_LOG_LIMIT = 2000; + +/** + * Strip credentials from git output so it can be logged. + * + * git echoes the remote URL it used, and those URLs routinely carry secrets + * (`https://x-access-token:TOKEN@github.com/...`), so raw stderr must never + * reach a log. Redacts the userinfo component of any URL plus bare tokens that + * commonly appear on their own. + */ +export function redactGitOutput(stderr: string): string { + return ( + stderr + .slice(0, GIT_STDERR_LOG_LIMIT) + .replace(/([a-zA-Z][\w+.-]*:\/\/)[^/@\s]*@/g, "$1@") + .replace(/\b(gh[pousr]_|github_pat_|glpat-)[A-Za-z0-9_-]+/g, "$1") + // Take the whole value, not just the scheme word: `Authorization: Bearer X` + // must not redact `Bearer` and leave `X` behind. + .replace(/\b(Authorization)\s*[:=]\s*.*/gi, "$1: ") + .replace(/\b(Bearer|token)\s*[:=]?\s+\S+/gi, "$1 ") + ); +} + const NON_REPOSITORY_STATUS_DETAILS = Object.freeze({ isRepo: false, hasOriginRemote: false, @@ -393,6 +471,7 @@ function gitCommandContext( command: "git", cwd: input.cwd, argumentCount: input.args.length, + failureKind: "unknown" as const, } as const; } @@ -524,16 +603,43 @@ const createTrace2Monitor = Effect.fn("createTrace2Monitor")(function* ( return; } - if (traceRecord.success.child_class !== "hook") { - return; - } - const event = traceRecord.success.event; const childKey = trace2ChildKey(traceRecord.success); if (childKey === null) { return; } const started = hookStartByChildKey.get(childKey); + + // Git 2.55+ TRACE2 child_exit records omit child_class:"hook". Still finish + // hooks we previously saw start via the child_id map. + if (event === "child_exit") { + if (!started) { + return; + } + hookStartByChildKey.delete(childKey); + const rawCode = traceRecord.success.code ?? traceRecord.success.exitCode; + const exitCode = typeof rawCode === "number" && Number.isInteger(rawCode) ? rawCode : null; + const now = yield* DateTime.now; + const durationMs = Math.max(0, DateTime.toEpochMillis(now) - started.startedAtMs); + yield* addCurrentSpanEvent("git.hook.finished", { + hookName: started.hookName, + exitCode, + durationMs, + }); + if (progress.onHookFinished) { + yield* progress.onHookFinished({ + hookName: started.hookName, + exitCode, + durationMs, + }); + } + return; + } + + if (traceRecord.success.child_class !== "hook") { + return; + } + const hookNameFromEvent = typeof traceRecord.success.hook_name === "string" ? traceRecord.success.hook_name.trim() : ""; const hookName = hookNameFromEvent.length > 0 ? hookNameFromEvent : (started?.hookName ?? ""); @@ -550,29 +656,6 @@ const createTrace2Monitor = Effect.fn("createTrace2Monitor")(function* ( if (progress.onHookStarted) { yield* progress.onHookStarted(hookName); } - return; - } - - if (event === "child_exit") { - hookStartByChildKey.delete(childKey); - const code = traceRecord.success.exitCode; - const exitCode = typeof code === "number" && Number.isInteger(code) ? code : null; - const now = yield* DateTime.now; - const durationMs = started - ? Math.max(0, DateTime.toEpochMillis(now) - started.startedAtMs) - : null; - yield* addCurrentSpanEvent("git.hook.finished", { - hookName: started?.hookName ?? hookName, - exitCode, - durationMs, - }); - if (progress.onHookFinished) { - yield* progress.onHookFinished({ - hookName: started?.hookName ?? hookName, - exitCode, - durationMs, - }); - } } }); @@ -727,6 +810,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; const { worktreesDir } = yield* ServerConfig; const crypto = yield* Crypto.Crypto; + const gitProcessSemaphore = yield* Semaphore.make(GIT_PROCESS_CONCURRENCY); const executeRaw: GitVcsDriver.GitVcsDriver["Service"]["execute"] = Effect.fnUntraced( function* (input) { @@ -837,22 +921,24 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* const execution = runGitCommand().pipe(Effect.scoped); if (timeoutMs === null) { - return yield* execution; + return yield* gitProcessSemaphore.withPermits(1)(execution); } - return yield* execution.pipe( - Effect.timeoutOption(timeoutMs), - Effect.flatMap((result) => - Option.match(result, { - onNone: () => - Effect.fail( - new GitCommandError({ - ...gitCommandContext(commandInput), - detail: "Git command timed out.", - }), - ), - onSome: Effect.succeed, - }), + return yield* gitProcessSemaphore.withPermits(1)( + execution.pipe( + Effect.timeoutOption(timeoutMs), + Effect.flatMap((result) => + Option.match(result, { + onNone: () => + Effect.fail( + new GitCommandError({ + ...gitCommandContext(commandInput), + detail: "Git command timed out.", + }), + ), + onSome: Effect.succeed, + }), + ), ), ); }, @@ -1150,63 +1236,6 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* return Cache.get(refresh ? repositoryPathsRefreshCache : repositoryPathsCache, cacheKey); }; - const defaultBranchCache = yield* Cache.makeWith( - (gitCommonDir: string) => - Effect.gen(function* () { - const path = yield* Path.Path; - const fetchCwd = - path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir; - return yield* executeGit( - "GitVcsDriver.statusDetails.defaultBranch", - fetchCwd, - ["--git-dir", gitCommonDir, "symbolic-ref", "refs/remotes/origin/HEAD"], - { allowNonZeroExit: true }, - ).pipe( - Effect.map((result) => { - if (result.exitCode !== 0) return null; - return parseDefaultBranchFromRemoteHeadRef(result.stdout, "origin"); - }), - ); - }), - { - capacity: 2_048, - timeToLive: Exit.match({ - onSuccess: () => STATUS_DEFAULT_BRANCH_CACHE_TTL, - onFailure: () => Duration.zero, - }), - }, - ); - const originExistsCache = yield* Cache.makeWith( - (gitCommonDir: string) => - Effect.gen(function* () { - const path = yield* Path.Path; - const fetchCwd = - path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir; - return yield* executeGit( - "GitVcsDriver.statusDetails.originExists", - fetchCwd, - ["--git-dir", gitCommonDir, "remote", "get-url", "origin"], - { allowNonZeroExit: true }, - ).pipe(Effect.map((result) => result.exitCode === 0)); - }), - { - capacity: 2_048, - timeToLive: Exit.match({ - onSuccess: () => STATUS_ORIGIN_EXISTS_CACHE_TTL, - onFailure: () => Duration.zero, - }), - }, - ); - const invalidateStatusStaticCaches = (cwd: string) => - Effect.gen(function* () { - const repositoryPaths = yield* resolveRepositoryPaths(cwd).pipe( - Effect.catchTags({ GitCommandError: () => Effect.succeed(null) }), - ); - const cacheKey = repositoryPaths?.gitCommonDir ?? normalizeRepositoryPathsCacheKey(cwd); - yield* Cache.invalidate(defaultBranchCache, cacheKey); - yield* Cache.invalidate(originExistsCache, cacheKey); - }); - const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd: string) { const repositoryPaths = yield* resolveRepositoryPaths(cwd); if (repositoryPaths !== null) { @@ -1603,6 +1632,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* command: "git", cwd, detail: "Git index is locked. Status will resume when the index lock is removed.", + failureKind: "unknown", }); // Status can succeed while locked, repeatedly running LFS clean filters without caching. if ( @@ -1655,11 +1685,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* }); } - const repositoryPaths = yield* resolveRepositoryPaths(cwd).pipe( - Effect.catchTags({ GitCommandError: () => Effect.succeed(null) }), - ); - const statusCacheKey = repositoryPaths?.gitCommonDir; - const [numstatStdout, defaultBranch, hasPrimaryRemote] = yield* Effect.all( + const [numstatStdout, defaultRefResult, hasPrimaryRemote] = yield* Effect.all( [ executeGitWithStableDiagnostics( "GitVcsDriver.statusDetails.numstat", @@ -1716,16 +1742,21 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* ); }), ), - statusCacheKey - ? Cache.get(defaultBranchCache, statusCacheKey).pipe(Effect.orElseSucceed(() => null)) - : resolveDefaultBranchName(cwd, "origin").pipe(Effect.orElseSucceed(() => null)), - statusCacheKey - ? Cache.get(originExistsCache, statusCacheKey).pipe(Effect.orElseSucceed(() => false)) - : originRemoteExists(cwd).pipe(Effect.orElseSucceed(() => false)), + executeGit( + "GitVcsDriver.statusDetails.defaultRef", + cwd, + ["symbolic-ref", "refs/remotes/origin/HEAD"], + { allowNonZeroExit: true }, + ), + originRemoteExists(cwd).pipe(Effect.orElseSucceed(() => false)), ], { concurrency: "unbounded" }, ); const statusStdout = statusResult.stdout; + const defaultBranch = + defaultRefResult.exitCode === 0 + ? defaultRefResult.stdout.trim().replace(/^refs\/remotes\/origin\//, "") + : null; let refName: string | null = null; let upstreamRef: string | null = null; @@ -1922,25 +1953,52 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* body, options?: GitVcsDriver.GitCommitOptions, ) { - const args = ["commit", "-m", subject]; + const args = ["commit"]; + if (options?.disableSigning) { + args.push("--no-gpg-sign"); + } + args.push("-m", subject); const trimmedBody = body.trim(); if (trimmedBody.length > 0) { args.push("-m", trimmedBody); } - const progress = - options?.progress?.onOutputLine === undefined - ? options?.progress - : { - ...options.progress, + let hookFailed = false; + const progress: GitVcsDriver.ExecuteGitProgress = { + ...(options?.progress?.onOutputLine + ? { onStdoutLine: (line: string) => options.progress?.onOutputLine?.({ stream: "stdout", text: line }) ?? Effect.void, onStderrLine: (line: string) => options.progress?.onOutputLine?.({ stream: "stderr", text: line }) ?? Effect.void, - }; - yield* executeGit("GitVcsDriver.commit.commit", cwd, args, { + } + : {}), + ...(options?.progress?.onHookStarted + ? { onHookStarted: options.progress.onHookStarted } + : {}), + onHookFinished: (input) => { + if (input.exitCode !== null && input.exitCode !== 0) { + hookFailed = true; + } + return options?.progress?.onHookFinished?.(input) ?? Effect.void; + }, + }; + const result = yield* executeGitWithStableDiagnostics("GitVcsDriver.commit.commit", cwd, args, { + allowNonZeroExit: true, ...(options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}), - ...(progress ? { progress } : {}), - }).pipe(Effect.asVoid); + progress, + }); + if (result.exitCode !== 0) { + return yield* new GitCommandError({ + ...gitCommandContext({ operation: "GitVcsDriver.commit.commit", cwd, args }), + detail: "Git command exited with a non-zero status.", + ...(result.exitCode === null ? {} : { exitCode: result.exitCode }), + stdoutLength: result.stdout.length, + stderrLength: result.stderr.length, + ...(!options?.disableSigning && !hookFailed && isCommitSigningFailureStderr(result.stderr) + ? { failureKind: "commit_signing_failed" as const } + : {}), + }); + } const commitSha = yield* runGitStdout("GitVcsDriver.commit.revParseHead", cwd, [ "rev-parse", "HEAD", @@ -2364,6 +2422,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* operation: "GitVcsDriver.getReviewDiffPreview.hash", command: "crypto.digest SHA-256", cwd: input.cwd, + failureKind: "unknown", detail: "Failed to hash review diff.", cause, }), @@ -2414,6 +2473,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* command: "git", cwd: input.cwd, detail, + failureKind: "unknown", ...(cause === undefined ? {} : { cause }), }); @@ -2452,6 +2512,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* command: stage, cwd: input.cwd, detail, + failureKind: "unknown", ...(cause === undefined ? {} : { cause }), }); const requestedPath = path.resolve(repositoryRoot, input.newPath); @@ -2878,11 +2939,94 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* ? ["worktree", "add", "-b", input.newRefName, worktreePath, input.refName] : ["worktree", "add", worktreePath, input.refName]; + const preparationEnv = input.deferDependencyInstall + ? { T3CODE_DEFER_DEPENDENCY_INSTALL: "1" } + : undefined; yield* executeGit("GitVcsDriver.createWorktree", input.cwd, args, { fallbackErrorDetail: "git worktree add failed", timeoutMs: WORKTREE_ADD_TIMEOUT_MS, + ...(preparationEnv === undefined ? {} : { env: preparationEnv }), }); + // A relative core.hooksPath is resolved from the worktree where `git + // worktree add` was launched. That checkout may be stale and not contain + // the hook which exists in the newly-created worktree. Explicitly run the + // target worktree's native post-checkout hook and await it before returning. + const postCheckoutHook = path.join(worktreePath, ".githooks", "post-checkout"); + const hasPostCheckoutHook = yield* fileSystem.exists(postCheckoutHook).pipe( + Effect.mapError( + (cause) => + new GitCommandError({ + operation: "GitVcsDriver.createWorktree.prepare", + command: "inspect .githooks/post-checkout", + cwd: worktreePath, + failureKind: "unknown", + detail: "Failed to inspect the target worktree preparation hook.", + cause, + }), + ), + ); + let preparation: VcsWorktreePreparation = { _tag: "ready", attempts: 0 }; + if (hasPostCheckoutHook) { + const checkedOutRef = (yield* runGitStdout( + "GitVcsDriver.createWorktree.resolveHead", + worktreePath, + ["rev-parse", "HEAD"], + )).trim(); + const hookArgs = [ + "-c", + "core.hooksPath=.githooks", + "hook", + "run", + "post-checkout", + "--", + checkedOutRef, + checkedOutRef, + "1", + ]; + const runPreparation = (attempts: number) => + executeGit("GitVcsDriver.createWorktree.prepare", worktreePath, hookArgs, { + allowNonZeroExit: true, + env: { + ...preparationEnv, + T3CODE_WORKTREE_PREPARATION_STRICT: "1", + }, + }).pipe( + Effect.map((result) => + result.exitCode === 0 + ? { _tag: "ready" as const, attempts } + : { + _tag: "degraded" as const, + attempts, + command: "git hook run post-checkout", + detail: worktreePreparationDetail({ + stderr: result.stderr, + stdout: result.stdout, + fallback: "The post-checkout preparation hook exited unsuccessfully.", + }), + ...(result.exitCode === null ? {} : { exitCode: result.exitCode }), + }, + ), + Effect.catch((error) => + Effect.succeed({ + _tag: "degraded" as const, + attempts, + command: "git hook run post-checkout", + detail: error.message, + ...(error.exitCode === undefined ? {} : { exitCode: error.exitCode }), + }), + ), + ); + + preparation = yield* runPreparation(1); + if ( + preparation._tag === "degraded" && + !isDeterministicWorktreePreparationFailure(preparation.detail) + ) { + preparation = yield* runPreparation(2); + } + } + // `git worktree add` leaves submodules empty, so a repo that keeps agent // skills, tooling or source in one gets a worktree that is quietly missing // them. Best-effort: the objects are usually already in the parent's @@ -2926,6 +3070,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* path: worktreePath, refName: targetBranch, }, + preparation, }; }); @@ -3316,14 +3461,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* cwd: string, effect: Effect.Effect, ): Effect.Effect => - effect.pipe( - Effect.ensuring( - Effect.all([ - invalidateListRefsSnapshot(cwd).pipe(Effect.ignore), - invalidateStatusStaticCaches(cwd).pipe(Effect.ignore), - ]), - ), - ); + effect.pipe(Effect.ensuring(invalidateListRefsSnapshot(cwd).pipe(Effect.ignore))); const initRepoWithListRefsInvalidation: GitVcsDriver.GitVcsDriver["Service"]["initRepo"] = ( input, ) => diff --git a/apps/server/src/vcs/VcsDriverRegistry.test.ts b/apps/server/src/vcs/VcsDriverRegistry.test.ts index 0ad2450eb192..785ad30cc13e 100644 --- a/apps/server/src/vcs/VcsDriverRegistry.test.ts +++ b/apps/server/src/vcs/VcsDriverRegistry.test.ts @@ -2,6 +2,7 @@ import { assert, it, describe } from "@effect/vitest"; import * as NodeServices from "@effect/platform-node/NodeServices"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; +import * as TestClock from "effect/testing/TestClock"; import { ChildProcessSpawner } from "effect/unstable/process"; import * as VcsProcess from "./VcsProcess.ts"; @@ -60,8 +61,8 @@ describe("VcsDriverRegistry", () => { const normalizedArgs = input.args[0] === "-C" && input.args.length >= 2 ? input.args.slice(2) : input.args; const command = normalizedArgs.join(" "); - if (command === "rev-parse --is-inside-work-tree") { - return processOutput("true\n"); + if (command === "rev-parse --is-bare-repository --is-inside-work-tree") { + return processOutput("false\ntrue\n"); } if (command === "rev-parse --show-toplevel") { return processOutput("/repo\n"); @@ -85,16 +86,16 @@ describe("VcsDriverRegistry", () => { assert.deepStrictEqual( calls.map((call) => normalizeGitArgs(call.args).join(" ")), [ - "rev-parse --is-inside-work-tree", - "rev-parse --show-toplevel", + "rev-parse --is-bare-repository --is-inside-work-tree", "rev-parse --git-common-dir", + "rev-parse --show-toplevel", ], ); }).pipe(Effect.provide(layer)); }); it.effect("detects a repository created after a negative lookup", () => { - let insideWorkTreeChecks = 0; + let probeChecks = 0; const layer = Layer.effect(VcsDriverRegistry.VcsDriverRegistry, VcsDriverRegistry.make).pipe( Layer.provide(NodeServices.layer), Layer.provide( @@ -107,15 +108,15 @@ describe("VcsDriverRegistry", () => { run: (input) => Effect.sync(() => { const command = normalizeGitArgs(input.args).join(" "); - if (command === "rev-parse --is-inside-work-tree") { - insideWorkTreeChecks += 1; - return insideWorkTreeChecks === 1 + if (command === "rev-parse --is-bare-repository --is-inside-work-tree") { + probeChecks += 1; + return probeChecks === 1 ? { ...processOutput(""), exitCode: ChildProcessSpawner.ExitCode(128), stderr: "fatal: not a git repository", } - : processOutput("true\n"); + : processOutput("false\ntrue\n"); } if (command === "rev-parse --show-toplevel") { return processOutput("/repo\n"); @@ -133,8 +134,60 @@ describe("VcsDriverRegistry", () => { const registry = yield* VcsDriverRegistry.VcsDriverRegistry; assert.equal(yield* registry.detect({ cwd: "/repo" }), null); + // Negative detects are TTL-cached (15s); advance so a later repo creation is noticed. + yield* TestClock.adjust("16 seconds"); assert.equal((yield* registry.detect({ cwd: "/repo" }))?.repository.rootPath, "/repo"); - assert.equal(insideWorkTreeChecks, 2); - }).pipe(Effect.provide(layer)); + assert.equal(probeChecks, 2); + }).pipe(Effect.provide(Layer.mergeAll(layer, TestClock.layer()))); + }); + + it.effect("fresh detect sees a repository created during a negative cache TTL", () => { + let probeChecks = 0; + const layer = Layer.effect(VcsDriverRegistry.VcsDriverRegistry, VcsDriverRegistry.make).pipe( + Layer.provide(NodeServices.layer), + Layer.provide( + Layer.mock(VcsProjectConfig.VcsProjectConfig)({ + resolveKind: (input) => Effect.succeed(input.requestedKind ?? "auto"), + }), + ), + Layer.provide( + Layer.mock(VcsProcess.VcsProcess)({ + run: (input) => + Effect.sync(() => { + const command = normalizeGitArgs(input.args).join(" "); + if (command === "rev-parse --is-bare-repository --is-inside-work-tree") { + probeChecks += 1; + return probeChecks === 1 + ? { + ...processOutput(""), + exitCode: ChildProcessSpawner.ExitCode(128), + stderr: "fatal: not a git repository", + } + : processOutput("false\ntrue\n"); + } + if (command === "rev-parse --show-toplevel") { + return processOutput("/repo\n"); + } + if (command === "rev-parse --git-common-dir") { + return processOutput("/repo/.git\n"); + } + return processOutput(""); + }), + }), + ), + ); + + return Effect.gen(function* () { + const registry = yield* VcsDriverRegistry.VcsDriverRegistry; + + assert.equal(yield* registry.detect({ cwd: "/repo" }), null); + assert.equal( + (yield* registry.detect({ cwd: "/repo", fresh: true }))?.repository.rootPath, + "/repo", + ); + // One probe per detect: the combined rev-parse keeps negative detection + // to a single git call. + assert.equal(probeChecks, 2); + }).pipe(Effect.provide(Layer.mergeAll(layer, TestClock.layer()))); }); }); diff --git a/apps/server/src/vcs/VcsDriverRegistry.ts b/apps/server/src/vcs/VcsDriverRegistry.ts index f40e1dadea3e..2563e8409fe7 100644 --- a/apps/server/src/vcs/VcsDriverRegistry.ts +++ b/apps/server/src/vcs/VcsDriverRegistry.ts @@ -12,11 +12,20 @@ import * as VcsProjectConfig from "./VcsProjectConfig.ts"; import * as VcsDriver from "./VcsDriver.ts"; const DETECTION_CACHE_CAPACITY = 2_048; -const DETECTION_CACHE_TTL = Duration.seconds(2); +/** + * Positive detects are stable for a worktree's lifetime; re-running 3× git + * rev-parse on every status/poll was a major VCS storm contributor under load. + * Keep negative detects short so creating a repo in a previously non-git path + * is still noticed quickly. + */ +const DETECTION_POSITIVE_CACHE_TTL = Duration.minutes(5); +const DETECTION_NEGATIVE_CACHE_TTL = Duration.seconds(15); export interface VcsDriverResolveInput { readonly cwd: string; readonly requestedKind?: VcsDriverKind | "auto"; + /** Skip a cached miss so a just-created repo is visible on this call. */ + readonly fresh?: boolean; } export interface VcsDriverHandle { @@ -115,17 +124,23 @@ export const make = Effect.gen(function* () { (key) => detectResolvedKind(parseDetectionCacheKey(key)), { capacity: DETECTION_CACHE_CAPACITY, - timeToLive: Exit.match({ - onSuccess: (detected) => (detected === null ? Duration.zero : DETECTION_CACHE_TTL), - onFailure: () => Duration.zero, - }), + timeToLive: (exit) => { + if (!Exit.isSuccess(exit)) { + return Duration.zero; + } + return exit.value === null ? DETECTION_NEGATIVE_CACHE_TTL : DETECTION_POSITIVE_CACHE_TTL; + }, }, ); const detect: VcsDriverRegistry["Service"]["detect"] = Effect.fn("VcsDriverRegistry.detect")( function* (input) { const requestedKind = yield* projectConfig.resolveKind(input); - return yield* Cache.get(detectionCache, detectionCacheKey({ cwd: input.cwd, requestedKind })); + const key = detectionCacheKey({ cwd: input.cwd, requestedKind }); + if (input.fresh) { + yield* Cache.invalidate(detectionCache, key); + } + return yield* Cache.get(detectionCache, key); }, ); diff --git a/apps/server/src/vcs/VcsProcess.test.ts b/apps/server/src/vcs/VcsProcess.test.ts index ac0ee4428046..dddf08547e84 100644 --- a/apps/server/src/vcs/VcsProcess.test.ts +++ b/apps/server/src/vcs/VcsProcess.test.ts @@ -177,6 +177,28 @@ describe("VcsProcess.run", () => { }).pipe(provideLive), ); + it.effect("keeps guest App-wrapper diagnostics off the process error message", () => + Effect.gen(function* () { + const wrapperLine = + "t3-github-app-token: app is not installed on pingdotgg/t3code (or repo does not exist)"; + const error = yield* run({ + operation: "test.wrapper-diagnostic", + command: "node", + args: ["-e", "process.stderr.write(process.argv[1]); process.exit(1)", wrapperLine], + cwd: process.cwd(), + }).pipe(Effect.flip); + + expect(error).toBeInstanceOf(VcsProcessExitError); + expect(error).toMatchObject({ + failureKind: "command-failed", + publicDiagnostic: wrapperLine, + }); + // Operators see this on GitHubCli.detail; the VCS message stays canned. + expect(error.message).not.toContain("pingdotgg"); + expect(error.message).toContain("Process exited with a non-zero status."); + }).pipe(provideLive), + ); + it.effect("classifies authentication failures without retaining stderr", () => Effect.gen(function* () { const secretStderr = "authentication failed for token super-secret-token"; @@ -395,3 +417,25 @@ describe("VcsProcess.run", () => { }).pipe(provideLive), ); }); + +describe("publicDiagnosticFromStderr", () => { + it("keeps only guest wrapper lines, and drops GraphQL bodies", () => { + expect( + VcsProcess.publicDiagnosticFromStderr( + "GraphQL: Could not resolve to a PullRequest with the number of 6613. (repository.pullRequest)", + ), + ).toBeUndefined(); + expect( + VcsProcess.publicDiagnosticFromStderr( + "t3-github-app-token: app is not installed on pingdotgg/t3code (or repo does not exist)", + ), + ).toBe( + "t3-github-app-token: app is not installed on pingdotgg/t3code (or repo does not exist)", + ); + expect( + VcsProcess.publicDiagnosticFromStderr( + "gh-app-wrapper: auth failed (exit 4); reminting and retrying once after 3s", + ), + ).toMatch(/^gh-app-wrapper:/); + }); +}); diff --git a/apps/server/src/vcs/VcsProcess.ts b/apps/server/src/vcs/VcsProcess.ts index 74608e116eed..88670ae69bfd 100644 --- a/apps/server/src/vcs/VcsProcess.ts +++ b/apps/server/src/vcs/VcsProcess.ts @@ -103,6 +103,21 @@ const classifyNonZeroExit = (command: string, stderr: string): VcsProcessExitFai return "command-failed"; }; +/** Guest App-wrapper lines are written for operators; they do not carry tokens. */ +const WRAPPER_DIAGNOSTIC = /^(?:t3-github-app-token|gh-app-wrapper):.+/i; +const PUBLIC_DIAGNOSTIC_MAX = 240; + +export function publicDiagnosticFromStderr(stderr: string): string | undefined { + for (const line of stderr.split(/\r?\n/)) { + const trimmed = line.trim(); + if (!WRAPPER_DIAGNOSTIC.test(trimmed)) continue; + return trimmed.length > PUBLIC_DIAGNOSTIC_MAX + ? `${trimmed.slice(0, PUBLIC_DIAGNOSTIC_MAX - 1)}…` + : trimmed; + } + return undefined; +} + export const make = Effect.gen(function* () { const processRunner = yield* ProcessRunner.ProcessRunner; const vcsProcesses = yield* Semaphore.make(VCS_PROCESS_CONCURRENCY); @@ -116,7 +131,7 @@ export const make = Effect.gen(function* () { argumentCount: input.args.length, }; - const result = yield* processRunner + const runProcess = processRunner .run({ command: input.command, args: input.args, @@ -160,6 +175,8 @@ export const make = Effect.gen(function* () { ), ); + const result = yield* runProcess; + if (result.code === null) { return yield* new VcsProcessMissingExitCodeError(baseError); } @@ -173,6 +190,7 @@ export const make = Effect.gen(function* () { stderrTruncated: result.stderrTruncated, }, classifyNonZeroExit(input.command, result.stderr), + publicDiagnosticFromStderr(result.stderr), ); } diff --git a/apps/server/src/vcs/VcsStatusBroadcaster.test.ts b/apps/server/src/vcs/VcsStatusBroadcaster.test.ts index ac21a61ddf78..a73cb48d7cc1 100644 --- a/apps/server/src/vcs/VcsStatusBroadcaster.test.ts +++ b/apps/server/src/vcs/VcsStatusBroadcaster.test.ts @@ -23,11 +23,19 @@ import type { VcsStatusStreamEvent, } from "@t3tools/contracts"; import { GitManagerError } from "@t3tools/contracts"; +import { symlinksSupported } from "@t3tools/shared/testing/symlinks"; import * as VcsStatusBroadcaster from "./VcsStatusBroadcaster.ts"; import * as BackgroundPolicy from "../background/BackgroundPolicy.ts"; import * as GitWorkflowService from "../git/GitWorkflowService.ts"; -import { symlinksSupported } from "@t3tools/shared/testing/symlinks"; +import * as ProjectLifecycleScriptRunner from "../project/ProjectLifecycleScriptRunner.ts"; + +const lifecycleScriptRunnerMock = Layer.mock( + ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner, +)({ + runWorktreeRemove: () => Effect.succeed({ status: "no-script" as const }), + runPrMerged: () => Effect.succeed({ status: "no-script" as const }), +}); const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"); @@ -82,6 +90,7 @@ function makeTestLayer(state: { return VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => state.backgroundWorkEnabled !== false)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => @@ -159,6 +168,7 @@ describe("VcsStatusBroadcaster", () => { const testLayer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.succeed(VcsStatusBroadcaster.VcsAutoPullPolicy, { isEnabled: (cwd) => Effect.succeed(cwd === configuredWorkspaceRoot), @@ -275,6 +285,7 @@ describe("VcsStatusBroadcaster", () => { const layer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => Effect.succeed(baseLocalStatus), @@ -321,6 +332,7 @@ describe("VcsStatusBroadcaster", () => { Layer.provide(FileSystem.layerNoop({ realPath: (path) => Effect.succeed(path) })), Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => Effect.succeed(baseLocalStatus), @@ -428,6 +440,7 @@ describe("VcsStatusBroadcaster", () => { const testLayer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => @@ -538,6 +551,7 @@ describe("VcsStatusBroadcaster", () => { const testLayer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: (input) => @@ -588,7 +602,7 @@ describe("VcsStatusBroadcaster", () => { }, ); - it.effect("streams a local snapshot first and remote updates later", () => { + it.effect("streams local status first and remote updates later", () => { const state = { currentLocalStatus: baseLocalStatus, currentRemoteStatus: baseRemoteStatus, @@ -600,11 +614,12 @@ describe("VcsStatusBroadcaster", () => { return Effect.gen(function* () { const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster; - const snapshotDeferred = yield* Deferred.make(); + const localDeferred = yield* Deferred.make(); const remoteUpdatedDeferred = yield* Deferred.make(); yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) => { - if (event._tag === "snapshot") { - return Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore); + // Cold start: localUpdated only (never a snapshot with fabricated remote/pr:null). + if (event._tag === "localUpdated") { + return Deferred.succeed(localDeferred, event).pipe(Effect.ignore); } if (event._tag === "remoteUpdated") { return Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore); @@ -612,14 +627,13 @@ describe("VcsStatusBroadcaster", () => { return Effect.void; }).pipe(Effect.forkScoped); - const snapshot = yield* Deferred.await(snapshotDeferred); + const localEvent = yield* Deferred.await(localDeferred); yield* broadcaster.refreshStatus("/repo"); const remoteUpdated = yield* Deferred.await(remoteUpdatedDeferred); - assert.deepStrictEqual(snapshot, { - _tag: "snapshot", + assert.deepStrictEqual(localEvent, { + _tag: "localUpdated", local: baseLocalStatus, - remote: null, } satisfies VcsStatusStreamEvent); assert.deepStrictEqual(remoteUpdated, { _tag: "remoteUpdated", @@ -642,7 +656,7 @@ describe("VcsStatusBroadcaster", () => { return Effect.gen(function* () { const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster; const scope = yield* Scope.make(); - const snapshotDeferred = yield* Deferred.make(); + const localDeferred = yield* Deferred.make(); const remoteUpdatedDeferred = yield* Deferred.make(); yield* Stream.runForEach( broadcaster.streamStatus( @@ -650,8 +664,8 @@ describe("VcsStatusBroadcaster", () => { { automaticRemoteRefreshInterval: Effect.succeed(Duration.zero) }, ), (event) => { - if (event._tag === "snapshot") { - return Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore); + if (event._tag === "localUpdated") { + return Deferred.succeed(localDeferred, event).pipe(Effect.ignore); } if (event._tag === "remoteUpdated") { return Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore); @@ -660,13 +674,12 @@ describe("VcsStatusBroadcaster", () => { }, ).pipe(Effect.forkIn(scope)); - const snapshot = yield* Deferred.await(snapshotDeferred); + const localEvent = yield* Deferred.await(localDeferred); const remoteUpdated = yield* Deferred.await(remoteUpdatedDeferred); - assert.deepStrictEqual(snapshot, { - _tag: "snapshot", + assert.deepStrictEqual(localEvent, { + _tag: "localUpdated", local: baseLocalStatus, - remote: null, } satisfies VcsStatusStreamEvent); assert.deepStrictEqual(remoteUpdated, { _tag: "remoteUpdated", @@ -703,6 +716,7 @@ describe("VcsStatusBroadcaster", () => { const testLayer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => @@ -805,6 +819,65 @@ describe("VcsStatusBroadcaster", () => { ); }); + it.effect("list mode uses a shared budgeted refresher, not a per-cwd poller", () => { + const state = { + currentLocalStatus: baseLocalStatus, + currentRemoteStatus: remoteStatusWithPr, + localStatusCalls: 0, + remoteStatusCalls: 0, + localInvalidationCalls: 0, + remoteInvalidationCalls: 0, + remoteStatusRefreshUpstreamValues: [] as Array, + }; + + return Effect.gen(function* () { + const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster; + const scope = yield* Scope.make(); + const repoAReady = yield* Deferred.make(); + const repoBReady = yield* Deferred.make(); + + const trackReady = (cwd: string, ready: Deferred.Deferred) => + Stream.runForEach( + broadcaster.streamStatus( + { cwd, mode: "list" }, + { automaticRemoteRefreshInterval: Effect.succeed(Duration.seconds(30)) }, + ), + (event) => + event._tag === "snapshot" || event._tag === "remoteUpdated" + ? Deferred.succeed(ready, undefined).pipe(Effect.ignore) + : Effect.void, + ).pipe(Effect.forkIn(scope, { startImmediately: true })); + + // Two list worktrees — shared exclusive refresher, not two independent pollers. + yield* trackReady("/repo-a", repoAReady); + yield* trackReady("/repo-b", repoBReady); + // Shared loop + optional cold kick eventually publishes remotes for both. + yield* Deferred.await(repoAReady); + yield* Deferred.await(repoBReady); + + assert.isAtLeast(state.remoteStatusCalls, 1); + assert.equal(state.remoteInvalidationCalls, 0); + for (const flag of state.remoteStatusRefreshUpstreamValues) { + assert.equal(flag, false); + } + const afterInitial = state.remoteStatusCalls; + + // Interval starts only after a sweep finishes; advance past list wait (45s) + // and allow another exclusive batch (batch size 4 covers both cwds). + yield* TestClock.adjust(VcsStatusBroadcaster.LIST_MODE_REMOTE_REFRESH_INTERVAL); + yield* Effect.yieldNow; + yield* Effect.yieldNow; + const delta = state.remoteStatusCalls - afterInitial; + // At least one exclusive post-wait batch; allow a couple of ticks while + // TestClock drains (still far below independent per-cwd 30s pollers). + assert.isAtLeast(delta, 1); + assert.isAtMost(delta, 8); + assert.equal(state.remoteInvalidationCalls, 0); + + yield* Scope.close(scope, Exit.void); + }).pipe(Effect.provide(Layer.merge(makeTestLayer(state), TestClock.layer()))); + }); + it.effect("delays automatic refresh when a cached remote snapshot is available", () => { const state = { currentLocalStatus: baseLocalStatus, @@ -840,13 +913,128 @@ describe("VcsStatusBroadcaster", () => { yield* TestClock.adjust(Duration.seconds(1)); yield* Effect.yieldNow; + // Poller re-reads remote via TTL; it does not force-invalidate every tick. assert.equal(state.remoteStatusCalls, 2); - assert.equal(state.remoteInvalidationCalls, 1); + assert.equal(state.remoteInvalidationCalls, 0); yield* Scope.close(scope, Exit.void); }).pipe(Effect.provide(Layer.merge(makeTestLayer(state), TestClock.layer()))); }); + it("detects open→merged PR transitions only", () => { + const open = remoteStatusWithPr; + const merged = { + ...remoteStatusWithPr, + pr: { ...remoteStatusWithPr.pr!, state: "merged" as const }, + }; + assert.isTrue(VcsStatusBroadcaster.didChangeRequestBecomeMerged(open, merged)); + assert.isFalse(VcsStatusBroadcaster.didChangeRequestBecomeMerged(null, merged)); + assert.isFalse(VcsStatusBroadcaster.didChangeRequestBecomeMerged(merged, merged)); + assert.isFalse(VcsStatusBroadcaster.didChangeRequestBecomeMerged(open, open)); + assert.isFalse( + VcsStatusBroadcaster.didChangeRequestBecomeMerged(open, { + ...merged, + pr: { ...merged.pr!, number: 9999 }, + }), + ); + }); + + it.effect("runs pr-merged lifecycle once when remote status transitions open→merged", () => { + const state = { + currentLocalStatus: baseLocalStatus, + currentRemoteStatus: remoteStatusWithPr as VcsStatusRemoteResult | null, + localStatusCalls: 0, + remoteStatusCalls: 0, + localInvalidationCalls: 0, + remoteInvalidationCalls: 0, + }; + const prMergedCalls: Array<{ + cwd: string; + prNumber?: number; + prUrl?: string; + prTitle?: string; + }> = []; + + return Effect.gen(function* () { + const prMergedRan = yield* Deferred.make(); + const testLayer = VcsStatusBroadcaster.layer.pipe( + Layer.provideMerge(NodeServices.layer), + Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide( + Layer.mock(ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner)({ + runWorktreeRemove: () => Effect.succeed({ status: "no-script" as const }), + runPrMerged: (input) => + Effect.gen(function* () { + prMergedCalls.push({ + cwd: input.worktreePath, + ...(input.pr + ? { + prNumber: input.pr.number, + prUrl: input.pr.url, + ...(input.pr.title ? { prTitle: input.pr.title } : {}), + } + : {}), + }); + yield* Deferred.succeed(prMergedRan, undefined).pipe(Effect.ignore); + return { status: "no-script" as const }; + }), + }), + ), + Layer.provide( + Layer.mock(GitWorkflowService.GitWorkflowService)({ + localStatus: () => + Effect.sync(() => { + state.localStatusCalls += 1; + return state.currentLocalStatus; + }), + remoteStatus: () => + Effect.sync(() => { + state.remoteStatusCalls += 1; + return state.currentRemoteStatus; + }), + invalidateLocalStatus: () => + Effect.sync(() => { + state.localInvalidationCalls += 1; + }), + invalidateRemoteStatus: () => + Effect.sync(() => { + state.remoteInvalidationCalls += 1; + }), + invalidateStatus: () => + Effect.sync(() => { + state.localInvalidationCalls += 1; + state.remoteInvalidationCalls += 1; + }), + }), + ), + ); + + yield* Effect.gen(function* () { + const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster; + yield* broadcaster.refreshStatus("/repo"); + assert.equal(prMergedCalls.length, 0); + + state.currentRemoteStatus = { + ...remoteStatusWithPr, + pr: { ...remoteStatusWithPr.pr!, state: "merged" }, + }; + yield* broadcaster.refreshStatus("/repo"); + yield* Deferred.await(prMergedRan); + assert.equal(prMergedCalls.length, 1); + assert.deepStrictEqual(prMergedCalls[0], { + cwd: "/repo", + prNumber: 2978, + prUrl: "https://github.com/pingdotgg/t3code/pull/2978", + prTitle: "[codex] Rewrite client connection architecture", + }); + + // Stay merged — do not re-fire. + yield* broadcaster.refreshStatus("/repo"); + assert.equal(prMergedCalls.length, 1); + }).pipe(Effect.provide(testLayer)); + }); + }); + it("backs off remote refresh failures exponentially and honors larger configured intervals", () => { assert.equal( Duration.toMillis(VcsStatusBroadcaster.remoteRefreshFailureDelay(1, Duration.seconds(1))), @@ -903,6 +1091,7 @@ describe("VcsStatusBroadcaster", () => { const testLayer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => false)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => @@ -956,6 +1145,7 @@ describe("VcsStatusBroadcaster", () => { const testLayer = VcsStatusBroadcaster.layer.pipe( Layer.provideMerge(NodeServices.layer), Layer.provide(makeBackgroundPolicyLayer(() => true)), + Layer.provide(lifecycleScriptRunnerMock), Layer.provide( Layer.mock(GitWorkflowService.GitWorkflowService)({ localStatus: () => @@ -998,26 +1188,28 @@ describe("VcsStatusBroadcaster", () => { remoteStartedDeferred = remoteStarted; const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster; - const firstSnapshot = yield* Deferred.make(); - const secondSnapshot = yield* Deferred.make(); + const firstLocal = yield* Deferred.make(); + const secondLocal = yield* Deferred.make(); const firstScope = yield* Scope.make(); const secondScope = yield* Scope.make(); + // Cold stream emits localUpdated first (remote still loading). yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) => - event._tag === "snapshot" - ? Deferred.succeed(firstSnapshot, event).pipe(Effect.ignore) + event._tag === "localUpdated" + ? Deferred.succeed(firstLocal, event).pipe(Effect.ignore) : Effect.void, - ).pipe(Effect.forkIn(firstScope)); + ).pipe(Effect.forkIn(firstScope, { startImmediately: true })); yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) => - event._tag === "snapshot" - ? Deferred.succeed(secondSnapshot, event).pipe(Effect.ignore) + event._tag === "localUpdated" + ? Deferred.succeed(secondLocal, event).pipe(Effect.ignore) : Effect.void, - ).pipe(Effect.forkIn(secondScope)); + ).pipe(Effect.forkIn(secondScope, { startImmediately: true })); - yield* Deferred.await(firstSnapshot); - yield* Deferred.await(secondSnapshot); + yield* Deferred.await(firstLocal); + yield* Deferred.await(secondLocal); yield* Deferred.await(remoteStarted); assert.equal(state.remoteStatusCalls, 1); + assert.equal(state.localStatusCalls, 1); yield* Scope.close(firstScope, Exit.void); assert.isTrue(Option.isNone(yield* Deferred.poll(remoteInterrupted))); @@ -1025,6 +1217,20 @@ describe("VcsStatusBroadcaster", () => { yield* Scope.close(secondScope, Exit.void).pipe(Effect.forkScoped); yield* Deferred.await(remoteInterrupted); assert.isTrue(Option.isSome(yield* Deferred.poll(remoteInterrupted))); + + const nextSnapshot = yield* Deferred.make(); + const nextScope = yield* Scope.make(); + yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) => + event._tag === "localUpdated" + ? Deferred.succeed(nextSnapshot, event).pipe(Effect.ignore) + : Effect.void, + ).pipe(Effect.forkIn(nextScope, { startImmediately: true })); + yield* Deferred.await(nextSnapshot); + + // Snapshot is retained after the last subscriber so reconnect does not + // immediately re-run multi-process local status for every worktree. + assert.equal(state.localStatusCalls, 1); + yield* Scope.close(nextScope, Exit.void); }).pipe(Effect.provide(testLayer)); }); }); diff --git a/apps/server/src/vcs/VcsStatusBroadcaster.ts b/apps/server/src/vcs/VcsStatusBroadcaster.ts index b9fc9e7ee3ab..13eb972164e2 100644 --- a/apps/server/src/vcs/VcsStatusBroadcaster.ts +++ b/apps/server/src/vcs/VcsStatusBroadcaster.ts @@ -8,7 +8,6 @@ import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as PubSub from "effect/PubSub"; import * as Ref from "effect/Ref"; -import * as Schedule from "effect/Schedule"; import * as Scope from "effect/Scope"; import * as Semaphore from "effect/Semaphore"; import * as Stream from "effect/Stream"; @@ -27,14 +26,27 @@ import { resolveProjectAutoPull } from "@t3tools/shared/serverSettings"; import * as BackgroundPolicy from "../background/BackgroundPolicy.ts"; import * as GitWorkflowService from "../git/GitWorkflowService.ts"; import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import * as ProjectLifecycleScriptRunner from "../project/ProjectLifecycleScriptRunner.ts"; import * as ServerSettings from "../serverSettings.ts"; const DEFAULT_VCS_STATUS_REFRESH_INTERVAL = Duration.seconds(30); +/** + * Shared list-mode remote refresh: one loop for all list-interested worktrees, + * not one fiber per cwd. Interval starts only after a sweep fully finishes so + * slow gh/git work never overlaps the next wait (and never stampedes reconnect). + */ +const LIST_REMOTE_REFRESH_INTERVAL = Duration.seconds(45); +/** Cap work per tick so a large sidebar cannot monopolize the process for minutes. */ +const LIST_REMOTE_REFRESH_BATCH_SIZE = 4; +const LIST_REMOTE_REFRESH_CONCURRENCY = 1; const VCS_STATUS_REFRESH_FAILURE_BASE_DELAY = Duration.seconds(30); const VCS_STATUS_REFRESH_FAILURE_MAX_DELAY = Duration.minutes(15); const MAX_FAILURE_DIAGNOSTIC_VALUES = 8; const MAX_FAILURE_DIAGNOSTIC_VALUE_LENGTH = 128; +/** Exported for tests — list subscriptions share this cadence. */ +export const LIST_MODE_REMOTE_REFRESH_INTERVAL = LIST_REMOTE_REFRESH_INTERVAL; + function boundedDiagnosticValue(value: string): string { return value.slice(0, MAX_FAILURE_DIAGNOSTIC_VALUE_LENGTH); } @@ -182,6 +194,27 @@ export function remoteRefreshFailureDelay( return Duration.max(configuredInterval, cappedBackoff); } +/** + * True only when we observed an open PR on this cwd and it later became merged. + * Skips first-seen already-merged PRs so server restarts / initial polls do not re-fire. + */ +export function didChangeRequestBecomeMerged( + previous: VcsStatusRemoteResult | null | undefined, + next: VcsStatusRemoteResult | null, +): boolean { + if (next?.pr?.state !== "merged") { + return false; + } + if (previous?.pr?.state !== "open") { + return false; + } + return previous.pr.number === next.pr.number; +} + +function prMergedLifecycleKey(cwd: string, prNumber: number): string { + return `${cwd}::${prNumber}`; +} + export class VcsStatusBroadcaster extends Context.Service< VcsStatusBroadcaster, { @@ -221,6 +254,7 @@ const normalizeCwd = (cwd: string) => export const make = Effect.gen(function* () { const autoPullPolicy = yield* VcsAutoPullPolicy; const workflow = yield* GitWorkflowService.GitWorkflowService; + const lifecycleScriptRunner = yield* ProjectLifecycleScriptRunner.ProjectLifecycleScriptRunner; const backgroundPolicy = yield* BackgroundPolicy.BackgroundPolicy; const fs = yield* FileSystem.FileSystem; const changesPubSub = yield* Effect.acquireRelease( @@ -244,6 +278,18 @@ export const make = Effect.gen(function* () { return lock.withPermits(1)(effect); }; const pollersRef = yield* SynchronizedRef.make(new Map()); + /** cwd → list-mode subscriber count (high-cardinality sidebar/board rows). */ + const listInterestRef = yield* SynchronizedRef.make(new Map()); + const listRefreshFiberRef = yield* SynchronizedRef.make | null>(null); + /** Round-robin cursor across list-interested cwds. */ + const listRefreshCursorRef = yield* Ref.make(0); + /** + * Exclusive list sweep lock: subscribe-time kicks and the periodic loop share + * this so remotes never pile up on top of an in-flight sweep. + */ + const listSweepMutex = yield* Semaphore.make(1); + // One fire per cwd+PR number for this server process. + const prMergedLifecycleFiredRef = yield* Ref.make(new Set()); const getCachedStatus = Effect.fn("VcsStatusBroadcaster.getCachedStatus")(function* ( cwd: string, @@ -251,6 +297,65 @@ export const make = Effect.gen(function* () { return yield* Ref.get(cacheRef).pipe(Effect.map((cache) => cache.get(cwd) ?? null)); }); + const maybeRunPrMergedLifecycle = Effect.fn("VcsStatusBroadcaster.maybeRunPrMergedLifecycle")( + function* ( + cwd: string, + previousRemote: VcsStatusRemoteResult | null | undefined, + nextRemote: VcsStatusRemoteResult | null, + ) { + if (!didChangeRequestBecomeMerged(previousRemote, nextRemote) || !nextRemote?.pr) { + return; + } + const pr = nextRemote.pr; + const fireKey = prMergedLifecycleKey(cwd, pr.number); + const shouldFire = yield* Ref.modify(prMergedLifecycleFiredRef, (fired) => { + if (fired.has(fireKey)) { + return [false, fired] as const; + } + const next = new Set(fired); + next.add(fireKey); + return [true, next] as const; + }); + if (!shouldFire) { + return; + } + + yield* lifecycleScriptRunner + .runPrMerged({ + projectCwd: cwd, + worktreePath: cwd, + pr: { + number: pr.number, + url: pr.url, + title: pr.title, + baseRef: pr.baseRef, + headRef: pr.headRef, + state: pr.state, + }, + }) + .pipe( + Effect.tap((result) => + result.status === "completed" + ? Effect.logInfo("VcsStatusBroadcaster pr-merged lifecycle completed", { + cwd, + prNumber: pr.number, + scriptId: result.scriptId, + scriptName: result.scriptName, + }) + : Effect.void, + ), + Effect.catch((error) => + Effect.logWarning("VcsStatusBroadcaster pr-merged lifecycle failed", { + cwd, + prNumber: pr.number, + cause: error, + }), + ), + Effect.forkIn(broadcasterScope), + ); + }, + ); + const updateCachedLocalStatus = Effect.fn("VcsStatusBroadcaster.updateCachedLocalStatus")( function* (cwd: string, local: VcsStatusLocalResult, options?: { publish?: boolean }) { const nextLocal = { @@ -287,16 +392,24 @@ export const make = Effect.gen(function* () { fingerprint: fingerprintStatusPart(remote), value: remote, } satisfies CachedValue; - const shouldPublish = yield* Ref.modify(cacheRef, (cache) => { + const { previousRemote, shouldPublish } = yield* Ref.modify(cacheRef, (cache) => { const previous = cache.get(cwd) ?? { local: null, remote: null }; const nextCache = new Map(cache); nextCache.set(cwd, { ...previous, remote: nextRemote, }); - return [previous.remote?.fingerprint !== nextRemote.fingerprint, nextCache] as const; + return [ + { + previousRemote: previous.remote?.value, + shouldPublish: previous.remote?.fingerprint !== nextRemote.fingerprint, + }, + nextCache, + ] as const; }); + yield* maybeRunPrMergedLifecycle(cwd, previousRemote, remote); + if (options?.publish && shouldPublish) { yield* PubSub.publish(changesPubSub, { cwd, @@ -325,7 +438,7 @@ export const make = Effect.gen(function* () { fingerprint: fingerprintStatusPart(remote), value: remote, } satisfies CachedValue; - const shouldPublish = yield* Ref.modify(cacheRef, (cache) => { + const { previousRemote, shouldPublish } = yield* Ref.modify(cacheRef, (cache) => { const previous = cache.get(cwd) ?? { local: null, remote: null }; const nextCache = new Map(cache); nextCache.set(cwd, { @@ -333,12 +446,18 @@ export const make = Effect.gen(function* () { remote: nextRemote, }); return [ - previous.local?.fingerprint !== nextLocal.fingerprint || - previous.remote?.fingerprint !== nextRemote.fingerprint, + { + previousRemote: previous.remote?.value, + shouldPublish: + previous.local?.fingerprint !== nextLocal.fingerprint || + previous.remote?.fingerprint !== nextRemote.fingerprint, + }, nextCache, ] as const; }); + yield* maybeRunPrMergedLifecycle(cwd, previousRemote, remote); + if (options?.publish && shouldPublish) { yield* PubSub.publish(changesPubSub, { cwd, @@ -453,13 +572,17 @@ export const make = Effect.gen(function* () { cwd: string, options?: { readonly refreshUpstream?: boolean; + readonly forceInvalidate?: boolean; readonly policyCwds?: ReadonlyArray; }, ) { + // Automatic poller ticks rely on GitManager's remote status TTL rather than + // wiping the cache every interval (which re-spawns gh for every worktree). + // Manual refreshStatus still force-invalidates. return yield* withRemoteWriteLock( cwd, Effect.gen(function* () { - if (options?.refreshUpstream !== false) { + if (options?.forceInvalidate) { yield* workflow.invalidateRemoteStatus(cwd); } const remote = yield* workflow.remoteStatus({ cwd }, options); @@ -528,6 +651,8 @@ export const make = Effect.gen(function* () { return Effect.gen(function* () { const consecutiveFailuresRef = yield* Ref.make(0); const needsInitialRefreshRef = yield* Ref.make(refreshImmediately); + /** When false, sleep once before the first refresh (warm cache path). */ + const mayRefreshImmediatelyRef = yield* Ref.make(refreshImmediately); const refreshRemoteStatusIfEnabled = Effect.gen(function* () { const configuredInterval = yield* automaticRemoteRefreshInterval; const activeInterval = Duration.isZero(configuredInterval) @@ -583,22 +708,22 @@ export const make = Effect.gen(function* () { return nextDelay; }); - if (!refreshImmediately) { - const configuredInterval = yield* automaticRemoteRefreshInterval; - yield* Effect.sleep( - Duration.isZero(configuredInterval) - ? DEFAULT_VCS_STATUS_REFRESH_INTERVAL - : configuredInterval, - ); - } - - return yield* refreshRemoteStatusIfEnabled.pipe( - Effect.repeat( - Schedule.identity().pipe( - Schedule.addDelay(({ output: delay }) => Effect.succeed(delay)), - ), - ), - Effect.asVoid, + // Work → wait → work. Delay starts only after refresh fully completes. + return yield* Effect.forever( + Effect.gen(function* () { + const mayRefreshImmediately = yield* Ref.get(mayRefreshImmediatelyRef); + if (!mayRefreshImmediately) { + const configuredInterval = yield* automaticRemoteRefreshInterval; + yield* Effect.sleep( + Duration.isZero(configuredInterval) + ? DEFAULT_VCS_STATUS_REFRESH_INTERVAL + : configuredInterval, + ); + yield* Ref.set(mayRefreshImmediatelyRef, true); + } + const delay = yield* refreshRemoteStatusIfEnabled; + yield* Effect.sleep(delay); + }), ); }); }; @@ -683,10 +808,13 @@ export const make = Effect.gen(function* () { ); } - return Effect.succeed([ - existing.fiber, - new Map([...activePollers].filter(([activeCwd]) => activeCwd !== cwd)), - ] as const); + const nextPollers = new Map(activePollers); + nextPollers.delete(cwd); + // Keep the broadcaster snapshot after the last subscriber leaves so a + // reconnect (or sidebar re-subscribe) can rehydrate without immediately + // re-running multi-process local status for every worktree. Capacity is + // bounded by unique cwds; explicit invalidate/refresh still force reload. + return Effect.succeed([existing.fiber, nextPollers] as const); }); if (pollerToInterrupt) { @@ -694,30 +822,165 @@ export const make = Effect.gen(function* () { } }); + /** + * Budgeted remote refresh for list-interested cwds without a full-mode poller. + * Exclusive (mutex): never overlaps another list sweep. Round-robins a small + * batch so dozens of worktrees cannot run multi-minute all-at-once storms that + * starve SessionStore.verify / websocket-ticket (SQLite is single-permit). + */ + const runListRemoteRefreshSweep = Effect.fn("VcsStatusBroadcaster.runListRemoteRefreshSweep")( + function* () { + yield* listSweepMutex.withPermits(1)( + Effect.gen(function* () { + const interests = yield* SynchronizedRef.get(listInterestRef); + const fullPollers = yield* SynchronizedRef.get(pollersRef); + const cwds = [...interests.keys()].filter((cwd) => !fullPollers.has(cwd)); + if (cwds.length === 0) { + return; + } + + const cursor = yield* Ref.get(listRefreshCursorRef); + const start = cwds.length === 0 ? 0 : cursor % cwds.length; + const batch: string[] = []; + for (let i = 0; i < Math.min(LIST_REMOTE_REFRESH_BATCH_SIZE, cwds.length); i += 1) { + const cwd = cwds[(start + i) % cwds.length]; + if (cwd !== undefined) { + batch.push(cwd); + } + } + yield* Ref.set( + listRefreshCursorRef, + cwds.length === 0 ? 0 : (start + batch.length) % cwds.length, + ); + + yield* Effect.forEach( + batch, + (cwd) => refreshRemoteStatus(cwd, { refreshUpstream: false }).pipe(Effect.ignore), + { concurrency: LIST_REMOTE_REFRESH_CONCURRENCY }, + ); + }), + ); + }, + ); + + const makeListRemoteRefreshLoop = () => + // Always: complete a sweep → then wait → repeat. Never schedule the next + // wait until the previous batch has fully finished. + Effect.forever( + Effect.gen(function* () { + yield* runListRemoteRefreshSweep(); + yield* Effect.sleep(LIST_REMOTE_REFRESH_INTERVAL); + }), + ); + + const retainListInterest = Effect.fn("VcsStatusBroadcaster.retainListInterest")(function* ( + cwd: string, + ) { + yield* SynchronizedRef.modifyEffect(listInterestRef, (interests) => { + const next = new Map(interests); + next.set(cwd, (next.get(cwd) ?? 0) + 1); + return Effect.succeed([undefined, next] as const); + }); + + yield* SynchronizedRef.modifyEffect(listRefreshFiberRef, (existing) => { + if (existing) { + return Effect.succeed([undefined, existing] as const); + } + return makeListRemoteRefreshLoop().pipe( + Effect.forkIn(broadcasterScope), + Effect.map((fiber) => [undefined, fiber] as const), + ); + }); + }); + + const releaseListInterest = Effect.fn("VcsStatusBroadcaster.releaseListInterest")(function* ( + cwd: string, + ) { + const shouldStopLoop = yield* SynchronizedRef.modifyEffect(listInterestRef, (interests) => { + const current = interests.get(cwd) ?? 0; + if (current <= 0) { + return Effect.succeed([false, interests] as const); + } + const next = new Map(interests); + if (current === 1) { + next.delete(cwd); + } else { + next.set(cwd, current - 1); + } + return Effect.succeed([next.size === 0, next] as const); + }); + + if (!shouldStopLoop) { + return; + } + + const fiber = yield* SynchronizedRef.modifyEffect(listRefreshFiberRef, (existing) => + Effect.succeed([existing, null] as const), + ); + if (fiber) { + yield* Fiber.interrupt(fiber).pipe(Effect.ignore); + } + }); + const streamStatus: VcsStatusBroadcaster["Service"]["streamStatus"] = (input, options) => Stream.unwrap( Effect.gen(function* () { const cwd = yield* withFileSystem(normalizeCwd(input.cwd)); + const mode = input.mode ?? "full"; const subscription = yield* PubSub.subscribe(changesPubSub); const initialLocal = yield* getOrLoadLocalStatus(cwd); - const cachedStatus = yield* getCachedStatus(cwd); + let cachedStatus = yield* getCachedStatus(cwd); + + // List mode: shared budgeted refresher keeps remote/PR state fresh for all + // list-interested cwds without one 30s poller fiber per worktree (storm root). + // Full mode: dedicated poller (may include git fetch) for active git chrome. + let release: Effect.Effect = Effect.void; + if (mode === "list") { + // Registers cwd with the shared budgeted refresher (keeps PR/remote fresh). + // No per-cwd poller and no per-subscribe remote stampede (reconnect storms + // used to fire N concurrent remoteStatus calls and block auth SQL). + yield* retainListInterest(cwd); + cachedStatus = yield* getCachedStatus(cwd); + // If cold, kick the exclusive shared sweep without awaiting it so the + // stream can open immediately; the sweep publishes remoteUpdated. + if (cachedStatus?.remote === null || cachedStatus?.remote === undefined) { + yield* runListRemoteRefreshSweep().pipe( + Effect.forkIn(broadcasterScope), + Effect.asVoid, + Effect.ignore, + ); + } + release = releaseListInterest(cwd).pipe(Effect.ignore, Effect.asVoid); + } else { + yield* retainRemotePoller( + cwd, + input.cwd, + options?.automaticRemoteRefreshInterval ?? + Effect.succeed(DEFAULT_VCS_STATUS_REFRESH_INTERVAL), + cachedStatus?.remote === null || cachedStatus?.remote === undefined, + ); + release = releaseRemotePoller(cwd, input.cwd).pipe(Effect.ignore, Effect.asVoid); + } + const initialRemote = cachedStatus?.remote?.value ?? null; - yield* retainRemotePoller( - cwd, - input.cwd, - options?.automaticRemoteRefreshInterval ?? - Effect.succeed(DEFAULT_VCS_STATUS_REFRESH_INTERVAL), - cachedStatus?.remote === null || cachedStatus?.remote === undefined, - ); - const release = releaseRemotePoller(cwd, input.cwd).pipe(Effect.ignore, Effect.asVoid); + // When remote is not cached yet, emit localUpdated only — never a snapshot that + // fabricates remote defaults (pr:null). Downstream clients treat that fake null + // PR as "no PR" and thrash badges (Discord ▫️⇄❌🔀 on every rehydrate). + const initialEvent = + initialRemote !== null + ? ({ + _tag: "snapshot" as const, + local: initialLocal, + remote: initialRemote, + } as const) + : ({ + _tag: "localUpdated" as const, + local: initialLocal, + } as const); return Stream.concat( - Stream.make({ - _tag: "snapshot" as const, - local: initialLocal, - remote: initialRemote, - }), + Stream.make(initialEvent), Stream.fromSubscription(subscription).pipe( Stream.filter((event) => event.cwd === cwd), Stream.map((event) => event.event), diff --git a/apps/server/src/vcs/testing/VcsDriverContractHarness.ts b/apps/server/src/vcs/testing/VcsDriverContractHarness.ts index fd474283590d..695fedd2ff57 100644 --- a/apps/server/src/vcs/testing/VcsDriverContractHarness.ts +++ b/apps/server/src/vcs/testing/VcsDriverContractHarness.ts @@ -76,6 +76,7 @@ export function runVcsDriverContractSuite(input: VcsDriverContractSuiteInp normalizePathForComparison(cwd), ), ); + assert.equal(identity?.bare, false); assert.equal(identity?.freshness.source, "live-local"); assert.isTrue(DateTime.isDateTime(identity?.freshness.observedAt)); assert.isTrue(Option.isNone(identity?.freshness.expiresAt ?? Option.none())); diff --git a/apps/server/src/webVersionWatcher.ts b/apps/server/src/webVersionWatcher.ts new file mode 100644 index 000000000000..ff29e248e135 --- /dev/null +++ b/apps/server/src/webVersionWatcher.ts @@ -0,0 +1,67 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeCrypto from "node:crypto"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import * as Ref from "effect/Ref"; + +import { resolveStaticDir } from "./config.ts"; +import type { ServerLifecycleEvents } from "./serverLifecycleEvents.ts"; + +/** How often to re-read the served index.html to detect an on-disk asset swap. */ +const POLL_INTERVAL = Duration.seconds(10); + +/** + * Identity of the currently served web bundle: a hash of index.html. Returns + * null when no static bundle is present (e.g. the dev server proxies Vite + * instead of serving files), in which case there is nothing to watch. + */ +const readWebVersion = (staticDir: string) => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const data = yield* fs + .readFile(path.join(staticDir, "index.html")) + .pipe(Effect.orElseSucceed(() => null)); + return data === null ? null : NodeCrypto.createHash("sha1").update(data).digest("hex"); + }); + +/** + * Broadcasts a `webVersionChanged` lifecycle event whenever the served + * index.html changes on disk, so connected clients learn that the web bundle + * was hot-swapped underneath them and can offer a reload. The current version + * is published once at startup to seed the lifecycle snapshot, so a client + * that connects later learns the version it is actually running. No-op when + * there is no packaged bundle to serve. + * + * Intended to be run with `Effect.forkScoped`; the poll loop never returns. + */ +export const runWebVersionWatcher = (lifecycleEvents: ServerLifecycleEvents["Service"]) => + Effect.gen(function* () { + const staticDir = yield* resolveStaticDir(); + if (staticDir === undefined) { + return; + } + const initial = yield* readWebVersion(staticDir); + const lastRef = yield* Ref.make(initial); + if (initial !== null) { + yield* lifecycleEvents.publish({ + version: 1, + type: "webVersionChanged", + payload: { webVersion: initial }, + }); + } + return yield* Effect.gen(function* () { + const current = yield* readWebVersion(staticDir); + const last = yield* Ref.get(lastRef); + if (current !== null && current !== last) { + yield* Ref.set(lastRef, current); + yield* lifecycleEvents.publish({ + version: 1, + type: "webVersionChanged", + payload: { webVersion: current }, + }); + } + }).pipe(Effect.delay(POLL_INTERVAL), Effect.forever); + }); diff --git a/apps/server/src/webhooks/WebhookDebugLog.ts b/apps/server/src/webhooks/WebhookDebugLog.ts new file mode 100644 index 000000000000..f1f9ce9df95b --- /dev/null +++ b/apps/server/src/webhooks/WebhookDebugLog.ts @@ -0,0 +1,263 @@ +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; +import * as Ref from "effect/Ref"; +import * as Semaphore from "effect/Semaphore"; + +import { writeFileStringAtomically } from "../atomicWrite.ts"; +import { ServerConfig } from "../config.ts"; + +/** Retain webhook debug rows for at most one day. */ +export const WEBHOOK_DEBUG_MAX_AGE_MS = 24 * 60 * 60 * 1000; +/** Safety cap so a flood cannot grow a source file without bound. */ +export const WEBHOOK_DEBUG_MAX_RECORDS = 5_000; +/** Cap stored request body previews (invalid/ignored diagnosis). */ +export const WEBHOOK_DEBUG_BODY_PREVIEW_CHARS = 4_000; + +/** Inbound integration webhook sources that write debug NDJSON. */ +export type WebhookSource = "github" | "jira"; + +export const WEBHOOK_DEBUG_SOURCES = [ + "github", + "jira", +] as const satisfies ReadonlyArray; + +export function webhookDebugFilename(source: WebhookSource): string { + return `${source}-webhook-debug.ndjson`; +} + +/** + * Shared outcome tags for GitHub + Jira webhook handlers. + * Source-specific denies use `repo_denied_202` / `project_denied_202`. + */ +export type WebhookDebugOutcome = + | "disabled_404" + | "too_large_413" + | "unauthorized_401" + | "invalid_400" + | "missing_delivery_id_400" + | "ignored_202" + | "repo_denied_202" + | "project_denied_202" + | "accepted_202"; + +export interface WebhookDebugRecord { + readonly ts: string; + readonly source: WebhookSource; + readonly outcome: WebhookDebugOutcome; + readonly status: number; + readonly reason?: string; + readonly bodyBytes: number; + readonly bodyPreview?: string; + readonly deliveryId?: string; + readonly webhookEvent?: string; + readonly mention?: string; + /** GitHub */ + readonly repository?: string; + readonly pullRequestNumber?: number; + readonly commentSurface?: string; + /** Jira */ + readonly issueKey?: string; + readonly projectKey?: string; + readonly commentId?: string; + readonly prompt?: string; + readonly commentText?: string; + readonly actorDisplayName?: string | null; + readonly actorAccountId?: string | null; +} + +export type WebhookDebugAppendInput = Omit & { + readonly ts?: string; +}; + +export function previewWebhookBody( + body: string, + maxChars: number = WEBHOOK_DEBUG_BODY_PREVIEW_CHARS, +): { readonly bodyBytes: number; readonly bodyPreview: string } { + const bodyBytes = new TextEncoder().encode(body).byteLength; + if (body.length <= maxChars) { + return { bodyBytes, bodyPreview: body }; + } + return { + bodyBytes, + bodyPreview: `${body.slice(0, maxChars)}…`, + }; +} + +/** + * Classify why a raw webhook body failed decode. + * Distinguishes broken JSON (common for Automation custom data with raw newlines) + * from schema mismatches on otherwise valid JSON. + */ +export function classifyWebhookBodyFailure(body: string): { + readonly reason: "json_parse_failed" | "schema_decode_failed" | "empty_body"; + readonly detail?: string; +} { + const trimmed = body.trim(); + if (trimmed.length === 0) { + return { reason: "empty_body" }; + } + try { + JSON.parse(trimmed); + } catch (error) { + const detail = error instanceof Error ? error.message : String(error); + return { reason: "json_parse_failed", detail: detail.slice(0, 300) }; + } + return { reason: "schema_decode_failed" }; +} + +export function pruneWebhookDebugRecords( + records: ReadonlyArray, + nowMs: number, + maxAgeMs: number = WEBHOOK_DEBUG_MAX_AGE_MS, + maxRecords: number = WEBHOOK_DEBUG_MAX_RECORDS, +): WebhookDebugRecord[] { + const cutoff = nowMs - maxAgeMs; + const kept = records.filter((record) => { + const ms = Date.parse(record.ts); + if (Number.isNaN(ms)) return false; + return ms >= cutoff; + }); + if (kept.length <= maxRecords) return kept; + // Keep the newest N when over the hard cap. + return kept.slice(kept.length - maxRecords); +} + +function parseDebugNdjson(raw: string): WebhookDebugRecord[] { + const records: WebhookDebugRecord[] = []; + for (const line of raw.split("\n")) { + const trimmed = line.trim(); + if (trimmed.length === 0) continue; + try { + const parsed: unknown = JSON.parse(trimmed); + if ( + parsed !== null && + typeof parsed === "object" && + "ts" in parsed && + typeof (parsed as { ts: unknown }).ts === "string" && + "outcome" in parsed && + typeof (parsed as { outcome: unknown }).outcome === "string" && + "status" in parsed && + typeof (parsed as { status: unknown }).status === "number" + ) { + records.push(parsed as WebhookDebugRecord); + } + } catch { + // Drop corrupt lines; file is best-effort diagnostics only. + } + } + return records; +} + +function encodeDebugNdjson(records: ReadonlyArray): string { + if (records.length === 0) return ""; + return `${records.map((record) => JSON.stringify(record)).join("\n")}\n`; +} + +export class WebhookDebugLog extends Context.Service< + WebhookDebugLog, + { + readonly append: (input: WebhookDebugAppendInput) => Effect.Effect; + } +>()("t3/webhooks/WebhookDebugLog") {} + +export const make = Effect.gen(function* () { + const config = yield* ServerConfig; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const bootNowMs = yield* Clock.currentTimeMillis; + + type SourceState = { + readonly filePath: string; + readonly records: Ref.Ref; + }; + + const sources = new Map(); + for (const source of WEBHOOK_DEBUG_SOURCES) { + const filePath = path.join(config.stateDir, webhookDebugFilename(source)); + const initial = yield* fileSystem.readFileString(filePath).pipe( + Effect.map((raw) => pruneWebhookDebugRecords(parseDebugNdjson(raw), bootNowMs)), + Effect.orElseSucceed((): WebhookDebugRecord[] => []), + ); + const records = yield* Ref.make(initial); + sources.set(source, { filePath, records }); + } + + const lock = yield* Semaphore.make(1); + + const persist = (filePath: string, records: ReadonlyArray) => + writeFileStringAtomically({ + filePath, + contents: encodeDebugNdjson(records), + }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + Effect.catch((cause) => + Effect.logWarning("Failed to persist webhook debug log", { + filePath, + cause, + }), + ), + ); + + // Drop anything already past retention on boot (per source file). + for (const state of sources.values()) { + const current = yield* Ref.get(state.records); + if (current.length > 0) { + yield* persist(state.filePath, current); + } + } + + return WebhookDebugLog.of({ + append: (input) => + lock + .withPermit( + Effect.gen(function* () { + const state = sources.get(input.source); + if (state === undefined) { + yield* Effect.logWarning("Webhook debug log: unknown source", { + source: input.source, + }); + return; + } + const ts = input.ts ?? DateTime.formatIso(yield* DateTime.now); + const record: WebhookDebugRecord = { ...input, ts }; + const parsedTs = Date.parse(ts); + const nowMs = Number.isNaN(parsedTs) ? yield* Clock.currentTimeMillis : parsedTs; + const next = yield* Ref.updateAndGet(state.records, (existing) => + pruneWebhookDebugRecords([...existing, record], nowMs), + ); + yield* persist(state.filePath, next); + }), + ) + .pipe( + Effect.catchCause((cause) => + Effect.logWarning("Webhook debug append failed", { + source: input.source, + cause, + }), + ), + ), + }); +}); + +export const layer = Layer.effect(WebhookDebugLog, make); + +// --------------------------------------------------------------------------- +// Backward-compatible aliases (Jira-first naming from the initial PR) +// --------------------------------------------------------------------------- + +/** @deprecated Use WEBHOOK_DEBUG_MAX_AGE_MS */ +export const JIRA_WEBHOOK_DEBUG_MAX_AGE_MS = WEBHOOK_DEBUG_MAX_AGE_MS; +/** @deprecated Use WEBHOOK_DEBUG_MAX_RECORDS */ +export const JIRA_WEBHOOK_DEBUG_MAX_RECORDS = WEBHOOK_DEBUG_MAX_RECORDS; +/** @deprecated Use WEBHOOK_DEBUG_BODY_PREVIEW_CHARS */ +export const JIRA_WEBHOOK_DEBUG_BODY_PREVIEW_CHARS = WEBHOOK_DEBUG_BODY_PREVIEW_CHARS; +/** @deprecated Use webhookDebugFilename("jira") */ +export const JIRA_WEBHOOK_DEBUG_FILENAME = webhookDebugFilename("jira"); +/** @deprecated Use pruneWebhookDebugRecords */ +export const pruneJiraWebhookDebugRecords = pruneWebhookDebugRecords; diff --git a/apps/server/src/workItems/ThreadWorkItemStore.test.ts b/apps/server/src/workItems/ThreadWorkItemStore.test.ts new file mode 100644 index 000000000000..03d428962bb5 --- /dev/null +++ b/apps/server/src/workItems/ThreadWorkItemStore.test.ts @@ -0,0 +1,61 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { + extractJiraIssueKeysFromText, + mergeOrderedUnique, + normalizeGitHubPullRequestRef, + normalizeJiraIssueKey, + resolveJiraIssueFromRecords, +} from "./ThreadWorkItemStore.ts"; + +describe("ThreadWorkItemStore helpers", () => { + it("normalizes Jira keys and drops false positives", () => { + expect(normalizeJiraIssueKey("sa-402")).toBe("SA-402"); + expect(normalizeJiraIssueKey("UTF-8")).toBeNull(); + expect(normalizeJiraIssueKey("not-a-key")).toBeNull(); + }); + + it("extracts Jira keys from free text", () => { + expect(extractJiraIssueKeysFromText("Fixes SA-401 and cfg-12")).toEqual(["SA-401", "CFG-12"]); + expect(extractJiraIssueKeysFromText("UTF-8 encoding")).toEqual([]); + expect(extractJiraIssueKeysFromText("SA-401 then SA-401 again")).toEqual(["SA-401"]); + }); + + it("normalizes GitHub PR URLs and short refs", () => { + expect(normalizeGitHubPullRequestRef("https://github.com/Acme/Widgets/pull/42")).toBe( + "github.com/acme/widgets/pull/42", + ); + expect(normalizeGitHubPullRequestRef("https://github.com/acme/widgets/pull/42/files")).toBe( + "github.com/acme/widgets/pull/42", + ); + expect(normalizeGitHubPullRequestRef("Acme/Widgets#42")).toBe( + "github.com/acme/widgets/pull/42", + ); + expect(normalizeGitHubPullRequestRef("not-a-pr")).toBeNull(); + }); + + it("merges ordered unique values", () => { + expect(mergeOrderedUnique(["SA-1"], ["sa-2", "SA-1", "bad"], normalizeJiraIssueKey)).toEqual([ + "SA-1", + "SA-2", + ]); + }); + + it("resolves unique / ambiguous / unlinked Jira associations", () => { + const records = [ + { threadId: "t1" as never, jiraIssueKeys: ["SA-402", "SA-409"] }, + { threadId: "t2" as never, jiraIssueKeys: ["CFG-1"] }, + ]; + expect(resolveJiraIssueFromRecords(records, "SA-402")).toEqual({ + _tag: "linked", + threadId: "t1", + }); + expect(resolveJiraIssueFromRecords(records, "NOPE-1")).toEqual({ _tag: "unlinked" }); + expect( + resolveJiraIssueFromRecords( + [...records, { threadId: "t3" as never, jiraIssueKeys: ["SA-402"] }], + "SA-402", + ), + ).toMatchObject({ _tag: "ambiguous" }); + }); +}); diff --git a/apps/server/src/workItems/ThreadWorkItemStore.ts b/apps/server/src/workItems/ThreadWorkItemStore.ts new file mode 100644 index 000000000000..b91a63a0910b --- /dev/null +++ b/apps/server/src/workItems/ThreadWorkItemStore.ts @@ -0,0 +1,386 @@ +/** + * Server-native associations between T3 threads and external work items + * (Jira issue keys, GitHub PR URLs). + * + * Source of truth for inbound bridges (Jira mentions, future GitHub lookup aids). + * Not limited to Discord — Discord may still mirror keys for pin UX, and its + * links.json can be imported as a migration/fallback source. + */ + +import type { ThreadId } from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; + +import { writeFileStringAtomically } from "../atomicWrite.ts"; +import { ServerConfig } from "../config.ts"; + +const FALSE_POSITIVE_JIRA_KEYS = new Set(["UTF-8", "ISO-8601", "HTTP-1", "HTTP-2", "TLS-1"]); + +export function normalizeJiraIssueKey(raw: string): string | null { + const key = raw.trim().toUpperCase(); + if (!/^[A-Z][A-Z0-9]{1,9}-\d{1,7}$/u.test(key)) return null; + if (FALSE_POSITIVE_JIRA_KEYS.has(key)) return null; + return key; +} + +/** Scan free text (PR title/body, Discord messages) for Jira issue keys. */ +export function extractJiraIssueKeysFromText(text: string): ReadonlyArray { + if (text.trim().length === 0) return []; + const found: string[] = []; + const seen = new Set(); + const matcher = /\b([A-Z][A-Z0-9]{1,9}-\d{1,7})\b/giu; + for (const match of text.matchAll(matcher)) { + const key = normalizeJiraIssueKey(match[1] ?? ""); + if (key === null || seen.has(key)) continue; + seen.add(key); + found.push(key); + } + return found; +} + +/** Normalize a GitHub PR URL or `owner/repo#n` form to a stable key. */ +export function normalizeGitHubPullRequestRef(raw: string): string | null { + const trimmed = raw.trim(); + if (trimmed.length === 0) return null; + + const urlMatch = trimmed.match( + /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:\/[^?\s]*)?(?:[?#]\S*)?$/iu, + ); + if (urlMatch) { + const owner = urlMatch[1]!.toLowerCase(); + const repo = urlMatch[2]!.toLowerCase(); + const number = urlMatch[3]!; + return `github.com/${owner}/${repo}/pull/${number}`; + } + + const shortMatch = trimmed.match(/^([^/\s]+)\/([^#\s]+)#(\d+)$/u); + if (shortMatch) { + const owner = shortMatch[1]!.toLowerCase(); + const repo = shortMatch[2]!.toLowerCase(); + const number = shortMatch[3]!; + return `github.com/${owner}/${repo}/pull/${number}`; + } + + return null; +} + +export function mergeOrderedUnique( + existing: ReadonlyArray | null | undefined, + incoming: ReadonlyArray | null | undefined, + normalize: (raw: string) => string | null, +): ReadonlyArray { + const result: string[] = []; + const seen = new Set(); + for (const raw of [...(existing ?? []), ...(incoming ?? [])]) { + const key = normalize(raw); + if (key === null || seen.has(key)) continue; + seen.add(key); + result.push(key); + } + return result; +} + +export type WorkItemLookupResult = + | { readonly _tag: "unlinked" } + | { readonly _tag: "ambiguous"; readonly threadIds: ReadonlyArray } + | { readonly _tag: "linked"; readonly threadId: ThreadId }; + +export const ThreadWorkItemRecord = Schema.Struct({ + threadId: Schema.String, + jiraIssueKeys: Schema.Array(Schema.String), + githubPullRequests: Schema.Array(Schema.String), + /** Optional sources that contributed (discord, jira-webhook, github-webhook, manual). */ + sources: Schema.optional(Schema.Array(Schema.String)), + updatedAt: Schema.String, +}); +export type ThreadWorkItemRecord = { + readonly threadId: ThreadId; + readonly jiraIssueKeys: ReadonlyArray; + readonly githubPullRequests: ReadonlyArray; + readonly sources: ReadonlyArray; + readonly updatedAt: string; +}; + +const ThreadWorkItemFile = Schema.Struct({ + version: Schema.Number, + records: Schema.Array(ThreadWorkItemRecord), +}); + +const decodeFile = Schema.decodeUnknownSync(Schema.fromJsonString(ThreadWorkItemFile)); + +const DiscordThreadLink = Schema.Struct({ + t3ThreadId: Schema.String, + status: Schema.optional(Schema.String), + jiraIssueKeys: Schema.optional(Schema.Array(Schema.String)), + prUrls: Schema.optional(Schema.Array(Schema.String)), +}); +const DiscordLinksFile = Schema.Struct({ + version: Schema.optional(Schema.Number), + links: Schema.Array(DiscordThreadLink), +}); +const decodeDiscordLinks = Schema.decodeUnknownSync(Schema.fromJsonString(DiscordLinksFile)); + +function parseDiscordLinksOrEmpty(linksJson: string): ReadonlyArray { + try { + return decodeDiscordLinks(linksJson).links; + } catch { + return []; + } +} + +export class ThreadWorkItemStore extends Context.Service< + ThreadWorkItemStore, + { + readonly getByThreadId: (threadId: ThreadId) => Effect.Effect; + readonly list: () => Effect.Effect>; + readonly appendForThread: (input: { + readonly threadId: ThreadId; + readonly jiraIssueKeys?: ReadonlyArray; + readonly githubPullRequests?: ReadonlyArray; + readonly source: string; + }) => Effect.Effect; + readonly resolveJiraIssue: (issueKey: string) => Effect.Effect; + readonly resolveGitHubPullRequest: (prRef: string) => Effect.Effect; + /** + * Import associations from a Discord bot links.json (active links only). + * Merges into the server store without removing existing entries. + */ + readonly importDiscordLinksJson: (linksJson: string) => Effect.Effect<{ + readonly threadsTouched: number; + readonly jiraKeysAdded: number; + readonly prsAdded: number; + }>; + } +>()("t3/workItems/ThreadWorkItemStore") {} + +function emptyRecord(threadId: ThreadId, updatedAt: string): ThreadWorkItemRecord { + return { + threadId, + jiraIssueKeys: [], + githubPullRequests: [], + sources: [], + updatedAt, + }; +} + +function resolveKey( + records: ReadonlyMap, + match: (record: ThreadWorkItemRecord) => boolean, +): WorkItemLookupResult { + const matches = new Set(); + for (const record of records.values()) { + if (!match(record)) continue; + matches.add(record.threadId); + } + if (matches.size === 0) return { _tag: "unlinked" }; + if (matches.size > 1) { + return { _tag: "ambiguous", threadIds: [...matches] as ThreadId[] }; + } + const [only] = matches; + return { _tag: "linked", threadId: only as ThreadId }; +} + +export const make = Effect.gen(function* () { + const config = yield* ServerConfig; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const filePath = path.join(config.stateDir, "thread-work-items.json"); + + const initial = yield* fileSystem.readFileString(filePath).pipe( + Effect.map((raw) => { + try { + const decoded = decodeFile(raw); + return decoded.records.map((record): ThreadWorkItemRecord => ({ + threadId: record.threadId as ThreadId, + jiraIssueKeys: mergeOrderedUnique([], record.jiraIssueKeys, normalizeJiraIssueKey), + githubPullRequests: mergeOrderedUnique( + [], + record.githubPullRequests, + normalizeGitHubPullRequestRef, + ), + sources: record.sources ?? [], + updatedAt: record.updatedAt, + })); + } catch { + return []; + } + }), + Effect.orElseSucceed((): ThreadWorkItemRecord[] => []), + ); + + const state = yield* Ref.make( + new Map(initial.map((record) => [record.threadId, record] as const)), + ); + const lock = yield* Semaphore.make(1); + + const persist = (records: ReadonlyMap) => { + const retained = [...records.values()].sort((left, right) => + right.updatedAt.localeCompare(left.updatedAt), + ); + return writeFileStringAtomically({ + filePath, + contents: `${JSON.stringify({ version: 1, records: retained }, null, 2)}\n`, + }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + Effect.orDie, + ); + }; + + return ThreadWorkItemStore.of({ + getByThreadId: (threadId) => + Ref.get(state).pipe(Effect.map((records) => records.get(threadId) ?? null)), + + list: () => Ref.get(state).pipe(Effect.map((records) => [...records.values()])), + + appendForThread: (input) => + lock.withPermit( + Effect.gen(function* () { + const now = DateTime.formatIso(yield* DateTime.now); + const next = yield* Ref.updateAndGet(state, (records) => { + const existing = records.get(input.threadId) ?? emptyRecord(input.threadId, now); + const jiraIssueKeys = mergeOrderedUnique( + existing.jiraIssueKeys, + input.jiraIssueKeys, + normalizeJiraIssueKey, + ); + const githubPullRequests = mergeOrderedUnique( + existing.githubPullRequests, + input.githubPullRequests, + normalizeGitHubPullRequestRef, + ); + const sources = mergeOrderedUnique(existing.sources, [input.source], (raw) => { + const value = raw.trim().toLowerCase(); + return value.length > 0 ? value : null; + }); + const updated: ThreadWorkItemRecord = { + threadId: input.threadId, + jiraIssueKeys, + githubPullRequests, + sources, + updatedAt: now, + }; + const copy = new Map(records); + copy.set(input.threadId, updated); + return copy; + }); + yield* persist(next); + return next.get(input.threadId)!; + }), + ), + + resolveJiraIssue: (issueKey) => + Ref.get(state).pipe( + Effect.map((records) => { + const normalized = normalizeJiraIssueKey(issueKey); + if (normalized === null) return { _tag: "unlinked" as const }; + return resolveKey(records, (record) => record.jiraIssueKeys.includes(normalized)); + }), + ), + + resolveGitHubPullRequest: (prRef) => + Ref.get(state).pipe( + Effect.map((records) => { + const normalized = normalizeGitHubPullRequestRef(prRef); + if (normalized === null) return { _tag: "unlinked" as const }; + return resolveKey(records, (record) => record.githubPullRequests.includes(normalized)); + }), + ), + + importDiscordLinksJson: (linksJson) => + lock.withPermit( + Effect.gen(function* () { + const links = parseDiscordLinksOrEmpty(linksJson); + if (links.length === 0) { + return { threadsTouched: 0, jiraKeysAdded: 0, prsAdded: 0 }; + } + + const now = DateTime.formatIso(yield* DateTime.now); + let threadsTouched = 0; + let jiraKeysAdded = 0; + let prsAdded = 0; + + const next = yield* Ref.updateAndGet(state, (records) => { + const copy = new Map(records); + for (const link of links) { + if (link.status !== undefined && link.status !== "active") continue; + const threadId = link.t3ThreadId.trim() as ThreadId; + if (threadId.length === 0) continue; + + const existing = copy.get(threadId) ?? emptyRecord(threadId, now); + const beforeJira = existing.jiraIssueKeys.length; + const beforePr = existing.githubPullRequests.length; + const jiraIssueKeys = mergeOrderedUnique( + existing.jiraIssueKeys, + link.jiraIssueKeys, + normalizeJiraIssueKey, + ); + const githubPullRequests = mergeOrderedUnique( + existing.githubPullRequests, + link.prUrls, + normalizeGitHubPullRequestRef, + ); + const sources = mergeOrderedUnique(existing.sources, ["discord"], (raw) => { + const value = raw.trim().toLowerCase(); + return value.length > 0 ? value : null; + }); + + if ( + jiraIssueKeys.length === beforeJira && + githubPullRequests.length === beforePr && + copy.has(threadId) + ) { + continue; + } + + jiraKeysAdded += jiraIssueKeys.length - beforeJira; + prsAdded += githubPullRequests.length - beforePr; + threadsTouched += 1; + copy.set(threadId, { + threadId, + jiraIssueKeys, + githubPullRequests, + sources, + updatedAt: now, + }); + } + return copy; + }); + + if (threadsTouched > 0) yield* persist(next); + return { threadsTouched, jiraKeysAdded, prsAdded }; + }), + ), + }); +}); + +export const layer = Layer.effect(ThreadWorkItemStore, make); + +/** Pure helper for tests / Discord fallback without the Effect store. */ +export function resolveJiraIssueFromRecords( + records: ReadonlyArray>, + issueKey: string, +): WorkItemLookupResult { + const normalized = normalizeJiraIssueKey(issueKey); + if (normalized === null) return { _tag: "unlinked" }; + const map = new Map( + records.map((record) => [ + record.threadId, + { + threadId: record.threadId, + jiraIssueKeys: record.jiraIssueKeys, + githubPullRequests: [] as string[], + sources: [] as string[], + updatedAt: "", + } satisfies ThreadWorkItemRecord, + ]), + ); + return resolveKey(map, (record) => record.jiraIssueKeys.includes(normalized)); +} diff --git a/apps/server/src/workspace/WorkspaceFileSystem.test.ts b/apps/server/src/workspace/WorkspaceFileSystem.test.ts index 5afc212ce172..47e892e7ccc3 100644 --- a/apps/server/src/workspace/WorkspaceFileSystem.test.ts +++ b/apps/server/src/workspace/WorkspaceFileSystem.test.ts @@ -5,8 +5,11 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; import { it, describe, expect } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; +import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; import * as Path from "effect/Path"; +import * as Stream from "effect/Stream"; import * as ServerConfig from "../config.ts"; import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts"; @@ -338,4 +341,42 @@ it.layer(TestLayer, { excludeTestServices: true })("WorkspaceFileSystemLive", (i }), ); }); + + describe("watchFile", () => { + it.effect("emits when a missing workspace file is created", () => + Effect.gen(function* () { + const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem; + const cwd = yield* makeTempDir; + const eventFiber = yield* workspaceFileSystem + .watchFile({ cwd, relativePath: "t3.json" }) + .pipe(Stream.runHead, Effect.timeout("5 seconds"), Effect.forkChild); + + yield* Effect.sleep("100 millis"); + yield* writeTextFile(cwd, "t3.json", '{"scripts":[]}'); + + const event = yield* Fiber.join(eventFiber); + expect(Option.getOrUndefined(event)).toEqual({ relativePath: "t3.json" }); + }), + ); + + it.effect("emits when an in-workspace symlink target changes", () => + Effect.gen(function* () { + const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const cwd = yield* makeTempDir; + yield* writeTextFile(cwd, "src/target.txt", "initial"); + yield* fileSystem.symlink(path.join(cwd, "src/target.txt"), path.join(cwd, "linked.txt")); + const eventFiber = yield* workspaceFileSystem + .watchFile({ cwd, relativePath: "linked.txt" }) + .pipe(Stream.runHead, Effect.timeout("5 seconds"), Effect.forkChild); + + yield* Effect.sleep("100 millis"); + yield* writeTextFile(cwd, "src/target.txt", "updated"); + + const event = yield* Fiber.join(eventFiber); + expect(Option.getOrUndefined(event)).toEqual({ relativePath: "linked.txt" }); + }), + ); + }); }); diff --git a/apps/server/src/workspace/WorkspaceFileSystem.ts b/apps/server/src/workspace/WorkspaceFileSystem.ts index 9ef3d4546d1d..3f5ee71593cd 100644 --- a/apps/server/src/workspace/WorkspaceFileSystem.ts +++ b/apps/server/src/workspace/WorkspaceFileSystem.ts @@ -13,17 +13,20 @@ import * as NodeFS from "node:fs"; import * as NodeFSP from "node:fs/promises"; import type { + ProjectFileChangeEvent, ProjectReadFileInput, ProjectReadFileResult, ProjectWriteFileInput, ProjectWriteFileResult, } from "@t3tools/contracts"; import * as Context from "effect/Context"; +import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; +import * as Stream from "effect/Stream"; import * as WorkspaceEntries from "./WorkspaceEntries.ts"; import * as WorkspacePaths from "./WorkspacePaths.ts"; @@ -40,10 +43,12 @@ export class WorkspaceFileSystemOperationError extends Schema.TaggedError; + /** Watch a workspace-relative file and emit after its directory entry changes. */ + readonly watchFile: ( + input: ProjectReadFileInput, + ) => Stream.Stream< + ProjectFileChangeEvent, + WorkspaceFileSystemError | WorkspacePaths.WorkspacePathOutsideRootError + >; /** * Write a file relative to the workspace root. * @@ -302,6 +314,126 @@ export const make = Effect.gen(function* () { ); }); + const watchFile: WorkspaceFileSystem["Service"]["watchFile"] = (input) => + Stream.unwrap( + Effect.gen(function* () { + const target = yield* workspacePaths.resolveRelativePathWithinRoot({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + }); + const watchDirectory = path.dirname(target.absolutePath); + const realWorkspaceRoot = yield* Effect.tryPromise({ + try: () => NodeFSP.realpath(input.cwd), + catch: (cause) => + new WorkspaceFileSystemOperationError({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + resolvedPath: target.absolutePath, + operationPath: input.cwd, + operation: "realpath-workspace-root", + cause, + }), + }); + const realWatchDirectory = yield* Effect.tryPromise({ + try: () => NodeFSP.realpath(watchDirectory), + catch: (cause) => + new WorkspaceFileSystemOperationError({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + resolvedPath: target.absolutePath, + operationPath: watchDirectory, + operation: "realpath-watch-directory", + cause, + }), + }); + const relativeRealDirectory = path.relative(realWorkspaceRoot, realWatchDirectory); + if ( + relativeRealDirectory.startsWith(`..${path.sep}`) || + relativeRealDirectory === ".." || + path.isAbsolute(relativeRealDirectory) + ) { + return yield* new WorkspaceFilePathEscapeError({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + resolvedWorkspaceRoot: realWorkspaceRoot, + resolvedPath: realWatchDirectory, + }); + } + + const realTargetPath = yield* Effect.tryPromise({ + try: async () => { + try { + return await NodeFSP.realpath(target.absolutePath); + } catch (cause) { + if ((cause as NodeJS.ErrnoException).code === "ENOENT") { + return null; + } + throw cause; + } + }, + catch: (cause) => + new WorkspaceFileSystemOperationError({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + resolvedPath: target.absolutePath, + operationPath: target.absolutePath, + operation: "realpath-target", + cause, + }), + }); + if (realTargetPath !== null) { + const relativeRealTarget = path.relative(realWorkspaceRoot, realTargetPath); + if ( + relativeRealTarget.startsWith(`..${path.sep}`) || + relativeRealTarget === ".." || + path.isAbsolute(relativeRealTarget) + ) { + return yield* new WorkspaceFilePathEscapeError({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + resolvedWorkspaceRoot: realWorkspaceRoot, + resolvedPath: realTargetPath, + }); + } + } + + const watchEntry = (watchPath: string, fileName: string) => { + const watchedAbsolutePath = path.join(watchPath, fileName); + return fileSystem.watch(watchPath).pipe( + Stream.filter((event) => { + return ( + event.path === fileName || + event.path === watchedAbsolutePath || + path.resolve(watchPath, event.path) === watchedAbsolutePath + ); + }), + Stream.mapError( + (cause) => + new WorkspaceFileSystemOperationError({ + workspaceRoot: input.cwd, + relativePath: input.relativePath, + resolvedPath: target.absolutePath, + operationPath: watchPath, + operation: "watch", + cause, + }), + ), + ); + }; + + const lexicalTargetPath = path.join(realWatchDirectory, path.basename(target.absolutePath)); + const lexicalEvents = watchEntry(realWatchDirectory, path.basename(target.absolutePath)); + const resolvedTargetEvents = + realTargetPath !== null && realTargetPath !== lexicalTargetPath + ? watchEntry(path.dirname(realTargetPath), path.basename(realTargetPath)) + : Stream.empty; + return Stream.merge(lexicalEvents, resolvedTargetEvents).pipe( + Stream.debounce(Duration.millis(100)), + Stream.map(() => ({ relativePath: target.relativePath })), + ); + }), + ); + const writeFile: WorkspaceFileSystem["Service"]["writeFile"] = Effect.fn( "WorkspaceFileSystem.writeFile", )(function* (input) { @@ -340,7 +472,7 @@ export const make = Effect.gen(function* () { return { relativePath: target.relativePath }; }); - return WorkspaceFileSystem.of({ readFile, writeFile }); + return WorkspaceFileSystem.of({ readFile, watchFile, writeFile }); }); export const layer = Layer.effect(WorkspaceFileSystem, make); diff --git a/apps/server/src/ws.test.ts b/apps/server/src/ws.test.ts new file mode 100644 index 000000000000..26a7e358eb20 --- /dev/null +++ b/apps/server/src/ws.test.ts @@ -0,0 +1,62 @@ +import { assert, describe, it } from "@effect/vitest"; + +import type { OrchestrationEvent } from "@t3tools/contracts"; + +import { isThreadDetailEvent } from "./ws.ts"; + +const event = (type: string): OrchestrationEvent => + ({ + type, + aggregateKind: "thread", + aggregateId: "thread-1", + sequence: 1, + occurredAt: "2026-07-14T00:00:00.000Z", + eventId: "event-1", + commandId: null, + causationEventId: null, + correlationId: null, + metadata: {}, + payload: {}, + }) as unknown as OrchestrationEvent; + +describe("isThreadDetailEvent", () => { + // A thread-detail subscriber resumes from `afterSequence` and never re-reads + // the projection, so anything omitted here never reaches the client at all. + it("passes the events a thread transcript is built from", () => { + for (const type of [ + "thread.message-sent", + "thread.messages-resynced", + "thread.meta-updated", + "thread.proposed-plan-upserted", + "thread.activity-appended", + "thread.turn-diff-completed", + "thread.reverted", + "thread.session-set", + ]) { + assert.isTrue(isThreadDetailEvent(event(type)), `${type} must reach thread subscribers`); + } + }); + + it("passes resync events so a rebuilt transcript reaches connected clients", () => { + // Regression: this was omitted, so backfills were written and projected but + // silently dropped en route to every client. + assert.isTrue(isThreadDetailEvent(event("thread.messages-resynced"))); + }); + + it("passes metadata updates so connected clients observe title changes", () => { + // Regression: MCP title updates reached the projection but not the live + // Discord bridge subscription, leaving the linked thread name stale. + assert.isTrue(isThreadDetailEvent(event("thread.meta-updated"))); + }); + + it("drops events a transcript does not render", () => { + for (const type of [ + "thread.created", + "thread.archived", + "thread.turn-start-requested", + "project.created", + ]) { + assert.isFalse(isThreadDetailEvent(event(type)), `${type} must not reach thread subscribers`); + } + }); +}); diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts index f59a753d9c72..0449ef6bcc4a 100644 --- a/apps/server/src/ws.ts +++ b/apps/server/src/ws.ts @@ -7,6 +7,7 @@ import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; @@ -15,9 +16,12 @@ import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; import { + RpcClientId, DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, + AuthOrchestrationReadScope, AuthAccessStreamError, type AuthAccessStreamEvent, + type AiUsageSnapshot, type AuthEnvironmentScope, AuthSessionId, ClientConnectionMethod, @@ -34,6 +38,7 @@ import { type OrchestrationCommand, type GitActionProgressEvent, type GitManagerServiceError, + type VcsCreateWorktreeResult, OrchestrationDispatchCommandError, type OrchestrationEvent, type OrchestrationShellStreamEvent, @@ -41,6 +46,7 @@ import { OrchestrationGetFullThreadDiffError, OrchestrationGetSnapshotError, OrchestrationSearchThreadsError, + OrchestrationGetThreadActivitiesError, OrchestrationGetTurnDiffError, ORCHESTRATION_WS_METHODS, ProjectId, @@ -63,7 +69,6 @@ import { FilesystemBrowseError, AssetWorkspaceContextNotFoundError, AssetWorkspaceContextResolutionError, - RpcClientId, EnvironmentAuthorizationError, ThreadId, type TerminalAttachStreamEvent, @@ -74,7 +79,6 @@ import { WS_METHODS, WsRpcGroup, } from "@t3tools/contracts"; -import { resolveServerBackgroundActivitySettings } from "@t3tools/shared/backgroundActivitySettings"; import { HttpRouter, HttpServerRequest, HttpServerRespondable } from "effect/unstable/http"; import { RpcSerialization, RpcServer } from "effect/unstable/rpc"; @@ -93,8 +97,10 @@ import { cleanupFailedUploadedAttachments, normalizeDispatchCommand, } from "./orchestration/Normalizer.ts"; +import { GrokTranscriptResync } from "./externalSessions/GrokTranscriptResync.ts"; import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts"; import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts"; +import * as WorktreeLifecycle from "./orchestration/Services/WorktreeLifecycle.ts"; import { ThreadDeletionReactor } from "./orchestration/Services/ThreadDeletionReactor.ts"; import { observeRpcEffect as instrumentRpcEffect, @@ -117,8 +123,10 @@ import * as PreviewAutomationBroker from "./mcp/PreviewAutomationBroker.ts"; import * as DeviceService from "./device/DeviceService.ts"; import * as PreviewManager from "./preview/Manager.ts"; import { issueAssetUrl } from "./assets/AssetAccess.ts"; +import * as PortExposure from "./preview/PortExposure.ts"; import { deletePendingAttachment, issueAttachmentUploadUrl } from "./assets/AttachmentUpload.ts"; import * as PortScanner from "./preview/PortScanner.ts"; +import * as AiUsageMonitorModule from "./aiUsage/AiUsageMonitor.ts"; import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts"; import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts"; import { readWorkflowScript } from "./orchestration/workflowScriptQuery.ts"; @@ -133,12 +141,15 @@ import * as AgentSessionScanner from "./project/AgentSessionScanner.ts"; import { importRecentAgentThreads } from "./project/AgentSessionImporter.ts"; import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts"; -import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import { requiredScopeForRpcMethod } from "./auth/RpcAuthorization.ts"; +import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; +import * as IdentityService from "./identity/IdentityService.ts"; +import { stampOrchestrationCommandSource } from "./identity/stampSource.ts"; import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts"; -import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts"; +import * as HostResourceProbe from "./diagnostics/HostResourceProbe.ts"; +import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; import * as HostResources from "./resourceTelemetry/HostResources.ts"; import * as AnalyticsService from "./telemetry/AnalyticsService.ts"; import * as UsageLimitSources from "./usage/UsageLimitSources.ts"; @@ -163,6 +174,12 @@ import * as PairingGrantStore from "./auth/PairingGrantStore.ts"; import * as SessionStore from "./auth/SessionStore.ts"; import { failEnvironmentAuthInvalid, failEnvironmentInternal } from "./auth/http.ts"; import * as RelayClient from "@t3tools/shared/relayClient"; +import { + isValidOmegentT3ProductHandshake, + OMEGENT_T3_CLIENT_REQUIRED_MESSAGE, + parseProductHandshakeFromSearchParams, +} from "@t3tools/shared/productFamily"; +import { deriveLocalBranchNameFromRemoteRef } from "@t3tools/shared/git"; const isOrchestrationDispatchCommandError = Schema.is(OrchestrationDispatchCommandError); const nowIso = Effect.map(DateTime.now, DateTime.formatIso); @@ -319,11 +336,22 @@ function projectSetupScriptCompatibilityDetail( } } +/** + * Which events a thread-detail subscriber needs. + * + * Exported for testing: a client resuming from `afterSequence` only ever sees + * what passes this filter, so a thread-detail event missing here is dropped on + * the floor and the client's transcript silently rots. + */ export function isThreadDetailEvent(event: OrchestrationEvent): event is Extract< OrchestrationEvent, { type: | "thread.message-sent" + | "thread.message-queued" + | "thread.queued-message-removed" + | "thread.messages-resynced" + | "thread.meta-updated" | "thread.proposed-plan-upserted" | "thread.activity-appended" | "thread.turn-diff-completed" @@ -333,6 +361,13 @@ export function isThreadDetailEvent(event: OrchestrationEvent): event is Extract > { return ( event.type === "thread.message-sent" || + event.type === "thread.message-queued" || + event.type === "thread.queued-message-removed" || + event.type === "thread.meta-updated" || + // Without this a resync is written, projected, and then silently dropped on + // its way to the client — which resumes from `afterSequence` and so never + // re-reads the projection. The transcript would stay stale forever. + event.type === "thread.messages-resynced" || event.type === "thread.proposed-plan-upserted" || event.type === "thread.activity-appended" || event.type === "thread.turn-diff-completed" || @@ -342,6 +377,11 @@ export function isThreadDetailEvent(event: OrchestrationEvent): event is Extract } const PROVIDER_STATUS_DEBOUNCE_MS = 200; +const BOOTSTRAP_WORKTREE_PROJECTION_TIMEOUT_MS = 5_000; +const BOOTSTRAP_WORKTREE_PROJECTION_POLL_MS = 50; +const BOOTSTRAP_WORKTREE_PROJECTION_ATTEMPTS = Math.ceil( + BOOTSTRAP_WORKTREE_PROJECTION_TIMEOUT_MS / BOOTSTRAP_WORKTREE_PROJECTION_POLL_MS, +); // When a resuming client's cursor is more than this many events behind the // current head, skip the per-event catch-up replay and send a fresh shell @@ -358,6 +398,11 @@ const THREAD_RESUME_MAX_EVENTS = 1_000; // payload bytes of the range in SQL and reset with a snapshot past this budget. const ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES = 8 * 1024 * 1024; +// Authorization scopes for every RPC live only in +// `auth/RpcAuthorization.ts` (`RPC_REQUIRED_SCOPES` / `requiredScopeForRpcMethod`). +// Do not reintroduce a parallel Map here — stack whole-file `theirs` on this path +// and Tim imports previously regressed main's typed auth (#2679), and identity.* +// methods drifted out of the runtime Map. function toAuthAccessStreamEvent( change: PairingGrantStore.BootstrapCredentialChange | SessionStore.SessionCredentialChange, revision: number, @@ -478,6 +523,7 @@ const makeWsRpcLayer = ( clientOrigin: OrchestrationClientOrigin, clientAnalyticsProps: Readonly>, previewAutomationBroker: PreviewAutomationBroker.PreviewAutomationBroker["Service"], + productHandshakeValid: boolean, ) => WsRpcGroup.toLayer( Effect.gen(function* () { @@ -496,6 +542,7 @@ const makeWsRpcLayer = ( Effect.orElseSucceed(() => null), ); const orchestrationEngine = yield* OrchestrationEngine.OrchestrationEngineService; + const grokTranscriptResync = yield* GrokTranscriptResync; const threadDeletionReactor = yield* ThreadDeletionReactor; const analytics = yield* AnalyticsService.AnalyticsService; // Every command dispatched on this connection carries the connecting @@ -535,10 +582,13 @@ const makeWsRpcLayer = ( const review = yield* ReviewService.ReviewService; const vcsProvisioning = yield* VcsProvisioningService.VcsProvisioningService; const vcsStatusBroadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster; + const worktreeLifecycle = yield* WorktreeLifecycle.WorktreeLifecycle; const terminalManager = yield* TerminalManager.TerminalManager; const previewManager = yield* PreviewManager.PreviewManager; const deviceService = yield* DeviceService.DeviceService; const portDiscovery = yield* PortScanner.PortDiscovery; + const portExposure = yield* PortExposure.PreviewPortExposure; + const aiUsageMonitor = yield* AiUsageMonitorModule.AiUsageMonitor; const providerRegistry = yield* ProviderRegistry.ProviderRegistry; const providerService = yield* ProviderService.ProviderService; const providerSessionDirectory = yield* ProviderSessionDirectory.ProviderSessionDirectory; @@ -553,6 +603,7 @@ const makeWsRpcLayer = ( const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup; const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries; const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem; + const fileSystem = yield* FileSystem.FileSystem; const canReplayPersistedRange = Effect.fnUntraced(function* ( afterSequence: number, headSequence: number, @@ -592,28 +643,10 @@ const makeWsRpcLayer = ( const projectSetupScriptRunner = yield* ProjectSetupScriptRunner.ProjectSetupScriptRunner; const agentSessionScanner = yield* AgentSessionScanner.AgentSessionScanner; const serverEnvironment = yield* ServerEnvironment.ServerEnvironment; - const backgroundPolicy = yield* BackgroundPolicy.BackgroundPolicy; - const rpcClientIds = yield* Ref.make(new Set()); - yield* Effect.addFinalizer(() => - Ref.get(rpcClientIds).pipe( - Effect.flatMap((clientIds) => - Effect.forEach( - clientIds, - (clientId) => backgroundPolicy.removeRpcClient(currentSessionId, clientId), - { - discard: true, - }, - ), - ), - Effect.ignore, - ), - ); const serverAuth = yield* EnvironmentAuth.EnvironmentAuth; const sourceControlDiscovery = yield* SourceControlDiscovery.SourceControlDiscovery; const automaticGitFetchInterval = serverSettings.getSettings.pipe( - Effect.map( - (settings) => resolveServerBackgroundActivitySettings(settings).automaticGitFetchInterval, - ), + Effect.map((settings) => settings.automaticGitFetchInterval), Effect.catch((cause) => Effect.logWarning("Failed to read automatic Git fetch interval setting", { detail: cause.message, @@ -626,10 +659,25 @@ const makeWsRpcLayer = ( const pullRequestSync = yield* PullRequestSyncReactor.PullRequestSyncReactor; const bootstrapCredentials = yield* PairingGrantStore.PairingGrantStore; const sessions = yield* SessionStore.SessionStore; + const identity = yield* IdentityService.IdentityService; const processDiagnostics = yield* ProcessDiagnostics.ProcessDiagnostics; + const backgroundPolicy = yield* BackgroundPolicy.BackgroundPolicy; const hostResources = yield* HostResources.HostResources; const processResourceMonitor = yield* ProcessResourceMonitor.ProcessResourceMonitor; const resourceTelemetry = yield* ResourceTelemetry.ResourceTelemetry; + const rpcClientIds = yield* Ref.make(new Set()); + yield* Effect.addFinalizer(() => + Ref.get(rpcClientIds).pipe( + Effect.flatMap((clientIds) => + Effect.forEach( + clientIds, + (clientId) => backgroundPolicy.removeRpcClient(currentSessionId, clientId), + { concurrency: "unbounded", discard: true }, + ), + ), + ), + ); + const hostResourceProbe = yield* HostResourceProbe.HostResourceProbe; const usage = yield* UsageService.UsageService; const relayClient = yield* RelayClient.RelayClient; const authorizationError = (requiredScope: AuthEnvironmentScope) => @@ -637,20 +685,33 @@ const makeWsRpcLayer = ( message: `The authenticated token is missing required scope: ${requiredScope}.`, requiredScope, }); + const productClientError = () => + new EnvironmentAuthorizationError({ + message: OMEGENT_T3_CLIENT_REQUIRED_MESSAGE, + requiredScope: AuthOrchestrationReadScope, + }); const authorizeEffect = ( requiredScope: AuthEnvironmentScope, effect: Effect.Effect, - ): Effect.Effect => - currentSession.scopes.includes(requiredScope) + ): Effect.Effect => { + if (!productHandshakeValid) { + return Effect.fail(productClientError()); + } + return currentSession.scopes.includes(requiredScope) ? effect : Effect.fail(authorizationError(requiredScope)); + }; const authorizeStream = ( requiredScope: AuthEnvironmentScope, stream: Stream.Stream, - ): Stream.Stream => - currentSession.scopes.includes(requiredScope) + ): Stream.Stream => { + if (!productHandshakeValid) { + return Stream.fail(productClientError()); + } + return currentSession.scopes.includes(requiredScope) ? stream : Stream.fail(authorizationError(requiredScope)); + }; const observeRpcEffect = ( method: string, effect: Effect.Effect, @@ -714,9 +775,13 @@ const makeWsRpcLayer = ( ), ); - const appendSetupScriptActivity = (input: { + const appendBootstrapActivity = (input: { readonly threadId: ThreadId; - readonly kind: "setup-script.requested" | "setup-script.started" | "setup-script.failed"; + readonly kind: + | "setup-script.requested" + | "setup-script.started" + | "setup-script.failed" + | "worktree-preparation.failed"; readonly summary: string; readonly createdAt: string; readonly payload: Record; @@ -980,6 +1045,7 @@ const makeWsRpcLayer = ( const bootstrap = command.bootstrap; const { bootstrap: _bootstrap, ...finalTurnStartCommand } = command; let createdThread = false; + let worktreeAlreadyPrepared = false; let targetProjectId = bootstrap?.createThread?.projectId; let targetProjectCwd = bootstrap?.prepareWorktree?.projectCwd; let targetWorktreePath = bootstrap?.createThread?.worktreePath ?? null; @@ -1004,7 +1070,7 @@ const makeWsRpcLayer = ( readonly worktreePath: string; }) => { const detail = projectSetupScriptCompatibilityDetail(input.error); - return appendSetupScriptActivity({ + return appendBootstrapActivity({ threadId: command.threadId, kind: "setup-script.failed", summary: "Setup script failed to start", @@ -1026,6 +1092,38 @@ const makeWsRpcLayer = ( ); }; + const recordWorktreePreparationFailure = ( + worktree: VcsCreateWorktreeResult, + ): Effect.Effect => { + const preparation = worktree.preparation; + if (preparation?._tag !== "degraded") { + return Effect.void; + } + return Effect.gen(function* () { + const createdAt = yield* nowIso; + yield* appendBootstrapActivity({ + threadId: command.threadId, + kind: "worktree-preparation.failed", + summary: "Worktree preparation failed; continuing in degraded mode", + createdAt, + payload: { + attempts: preparation.attempts, + command: preparation.command, + detail: preparation.detail, + ...(preparation.exitCode === undefined ? {} : { exitCode: preparation.exitCode }), + worktreePath: worktree.worktree.path, + }, + tone: "error", + }).pipe(Effect.ignoreCause({ log: false })); + yield* Effect.logWarning("worktree preparation failed; continuing bootstrap", { + threadId: command.threadId, + worktreePath: worktree.worktree.path, + attempts: preparation.attempts, + detail: preparation.detail, + }); + }); + }; + const recordSetupScriptStarted = (input: { readonly requestedAt: string; readonly worktreePath: string; @@ -1042,7 +1140,7 @@ const makeWsRpcLayer = ( worktreePath: input.worktreePath, }; yield* Effect.all([ - appendSetupScriptActivity({ + appendBootstrapActivity({ threadId: command.threadId, kind: "setup-script.requested", summary: "Starting setup script", @@ -1050,7 +1148,7 @@ const makeWsRpcLayer = ( payload, tone: "info", }), - appendSetupScriptActivity({ + appendBootstrapActivity({ threadId: command.threadId, kind: "setup-script.started", summary: "Setup script started", @@ -1075,9 +1173,33 @@ const makeWsRpcLayer = ( ); }); + const waitForWorktreeProjection = (worktreePath: string) => + Effect.gen(function* () { + for (let attempt = 0; attempt < BOOTSTRAP_WORKTREE_PROJECTION_ATTEMPTS; attempt++) { + const projectedThread = yield* projectionSnapshotQuery + .getThreadShellById(command.threadId) + .pipe(Effect.orElseSucceed(() => Option.none())); + if ( + Option.isSome(projectedThread) && + projectedThread.value.worktreePath === worktreePath + ) { + return; + } + yield* Effect.sleep(BOOTSTRAP_WORKTREE_PROJECTION_POLL_MS); + } + + return yield* new OrchestrationDispatchCommandError({ + message: "Worktree bootstrap did not become visible before provider start.", + cause: { + threadId: command.threadId, + worktreePath, + }, + }); + }); + const runSetupProgram = () => Effect.gen(function* () { - if (!bootstrap?.runSetupScript || !targetWorktreePath) { + if (!bootstrap?.runSetupScript || !targetWorktreePath || worktreeAlreadyPrepared) { return; } const worktreePath = targetWorktreePath; @@ -1127,49 +1249,158 @@ const makeWsRpcLayer = ( branch: bootstrap.createThread.branch, worktreePath: bootstrap.createThread.worktreePath, createdAt: bootstrap.createThread.createdAt, - }); - // The successful create is a fence in the engine command queue: - // every delete for the prior incarnation committed before it. - // Drain through that event before setup or turn start can own - // terminals and provider sessions under the reused thread id. - yield* threadDeletionReactor.drainThrough(created.sequence); - createdThread = true; + }).pipe( + Effect.catch((createError) => { + if ( + createError._tag !== "OrchestrationCommandInvariantError" || + !createError.detail.includes("already exists") + ) { + return Effect.fail(createError); + } + return projectionSnapshotQuery.getThreadShellById(command.threadId).pipe( + Effect.matchEffect({ + onFailure: () => Effect.fail(createError), + onSuccess: Option.match({ + // A reconnect can replay the bootstrap after its + // thread.create committed but before the turn-start + // response reached the client. Resume the remaining + // bootstrap instead of rejecting the duplicate. + onSome: () => Effect.succeed(null), + onNone: () => Effect.fail(createError), + }), + }), + ); + }), + ); + if (created !== null) { + // The successful create is a fence in the engine command queue: + // every delete for the prior incarnation committed before it. + // Drain through that event before setup or turn start can own + // terminals and provider sessions under the reused thread id. + yield* threadDeletionReactor.drainThrough(created.sequence); + createdThread = true; + } } - if (bootstrap?.prepareWorktree) { - let worktreeBaseRef = bootstrap.prepareWorktree.baseBranch; - // "Start from origin" is a stored default; repos without the - // requested remote branch fall back to the local base branch. - const startFromOrigin = - bootstrap.prepareWorktree.startFromOrigin === true && + if (bootstrap?.prepareWorktree && !(bootstrap.createThread && createdThread)) { + // A replayed bootstrap (reconnect or outbox retry) can reach + // this point after the original already prepared the worktree; + // re-running `git worktree add -b` would fail on the now-existing + // branch. When the thread pre-existed: + // - path still on disk → reuse and skip setup + // - path missing (GC / manual cleanup) → re-add worktree at the + // same path for the existing branch (post-checkout runs pnpm) + // and re-run project setup + const projectedShell = yield* projectionSnapshotQuery + .getThreadShellById(command.threadId) + .pipe(Effect.orElseSucceed(() => Option.none())); + const existingWorktreePath = Option.isSome(projectedShell) + ? projectedShell.value.worktreePath + : null; + const existingBranch = Option.isSome(projectedShell) + ? projectedShell.value.branch + : null; + if (existingWorktreePath !== null) { + const pathExists = yield* fileSystem + .exists(existingWorktreePath) + .pipe(Effect.orElseSucceed(() => false)); + if (pathExists) { + targetWorktreePath = existingWorktreePath; + worktreeAlreadyPrepared = true; + yield* refreshGitStatus(existingWorktreePath); + } else if (existingBranch !== null && existingBranch.length > 0) { + // Disk GC removed the tree; re-add at the same path. Leave + // worktreeAlreadyPrepared false so setup scripts re-run. + const prepareWorktree = bootstrap.prepareWorktree; + const worktree = yield* gitWorkflow.createWorktree({ + cwd: prepareWorktree.projectCwd, + // Existing branch: no newRefName → `git worktree add ` + refName: existingBranch, + path: existingWorktreePath, + ...(bootstrap.runSetupScript === true ? { deferDependencyInstall: true } : {}), + }); + targetWorktreePath = worktree.worktree.path; + yield* orchestrationEngine.dispatch({ + type: "thread.meta.update", + commandId: yield* serverCommandId("bootstrap-thread-meta-recreate-worktree"), + threadId: command.threadId, + branch: worktree.worktree.refName, + worktreePath: targetWorktreePath, + }); + yield* recordWorktreePreparationFailure(worktree); + yield* waitForWorktreeProjection(targetWorktreePath); + yield* refreshGitStatus(targetWorktreePath); + } + } + } + + // Recreate sets targetWorktreePath without worktreeAlreadyPrepared; + // skip a second createWorktree while still allowing setup scripts. + const worktreePathAlreadyMaterialized = + targetWorktreePath !== null && targetWorktreePath.length > 0; + + if ( + bootstrap?.prepareWorktree && + !worktreeAlreadyPrepared && + !worktreePathAlreadyMaterialized + ) { + const prepareWorktree = bootstrap.prepareWorktree; + let worktreeBaseRef = prepareWorktree.baseBranch; + let worktreeNewRefName = prepareWorktree.branch; + let worktreeBaseRefName: string | undefined = prepareWorktree.baseBranch; + if (prepareWorktree.reuseBaseBranch) { + // Reuse the selected branch: check it out in the worktree + // instead of branching off it. A remote ref cannot be checked + // out directly (it would detach), so materialize it as its + // derived local branch; the branch keeps its own history, so + // skip the gh-merge-base config that new branches record. + const refsResult = yield* gitWorkflow.listRefs({ + cwd: prepareWorktree.projectCwd, + query: prepareWorktree.baseBranch, + includeMatchingRemoteRefs: true, + }); + const selectedRef = refsResult.refs.find( + (ref) => ref.name === prepareWorktree.baseBranch, + ); + worktreeNewRefName = selectedRef?.isRemote + ? deriveLocalBranchNameFromRemoteRef(prepareWorktree.baseBranch) + : undefined; + worktreeBaseRefName = undefined; + } else if ( + prepareWorktree.startFromOrigin === true && + // "Start from origin" is a stored default; repos without an + // origin remote, or without the requested remote branch, fall + // back to the local base branch instead of failing bootstrap. + // Checked lazily so the reuse path never touches the remote. (yield* gitWorkflow.remoteExists({ - cwd: bootstrap.prepareWorktree.projectCwd, + cwd: prepareWorktree.projectCwd, remoteName: "origin", - })); - if (startFromOrigin) { + })) + ) { yield* gitWorkflow.fetchRemote({ - cwd: bootstrap.prepareWorktree.projectCwd, + cwd: prepareWorktree.projectCwd, remoteName: "origin", }); const remoteBaseExists = yield* gitWorkflow.remoteBranchExists({ - cwd: bootstrap.prepareWorktree.projectCwd, - refName: bootstrap.prepareWorktree.baseBranch, + cwd: prepareWorktree.projectCwd, + refName: prepareWorktree.baseBranch, remoteName: "origin", }); if (remoteBaseExists) { const resolvedRemoteBase = yield* gitWorkflow.resolveRemoteTrackingCommit({ - cwd: bootstrap.prepareWorktree.projectCwd, - refName: bootstrap.prepareWorktree.baseBranch, + cwd: prepareWorktree.projectCwd, + refName: prepareWorktree.baseBranch, fallbackRemoteName: "origin", }); worktreeBaseRef = resolvedRemoteBase.commitSha; } } const worktree = yield* gitWorkflow.createWorktree({ - cwd: bootstrap.prepareWorktree.projectCwd, + cwd: prepareWorktree.projectCwd, refName: worktreeBaseRef, - newRefName: bootstrap.prepareWorktree.branch, - baseRefName: bootstrap.prepareWorktree.baseBranch, + ...(worktreeNewRefName !== undefined ? { newRefName: worktreeNewRefName } : {}), + ...(worktreeBaseRefName !== undefined ? { baseRefName: worktreeBaseRefName } : {}), + ...(bootstrap.runSetupScript === true ? { deferDependencyInstall: true } : {}), path: null, }); targetWorktreePath = worktree.worktree.path; @@ -1180,6 +1411,8 @@ const makeWsRpcLayer = ( branch: worktree.worktree.refName, worktreePath: targetWorktreePath, }); + yield* recordWorktreePreparationFailure(worktree); + yield* waitForWorktreeProjection(targetWorktreePath); yield* refreshGitStatus(targetWorktreePath); } @@ -1188,6 +1421,8 @@ const makeWsRpcLayer = ( return yield* dispatchFromClient(finalTurnStartCommand); }); + // thread.created is externally visible once dispatched. Preserve that + // thread when later bootstrap work fails so the client can show and retry it. return yield* bootstrapProgram.pipe( Effect.catchCause((cause) => { const dispatchError = toBootstrapDispatchCommandCauseError(cause); @@ -1316,11 +1551,51 @@ const makeWsRpcLayer = ( .pipe(Effect.ignoreCause({ log: true }), Effect.forkDetach, Effect.asVoid); return WsRpcGroup.of({ + [WS_METHODS.identityGetSnapshot]: () => + observeRpcEffect(WS_METHODS.identityGetSnapshot, identity.getSnapshot()), + [WS_METHODS.identityGetSessionClaim]: () => + observeRpcEffect( + WS_METHODS.identityGetSessionClaim, + identity.getSessionClaim(currentSessionId), + ), + [WS_METHODS.identityClaim]: (payload) => + observeRpcEffect(WS_METHODS.identityClaim, identity.claim(currentSessionId, payload)), + [WS_METHODS.identityClearClaim]: () => + observeRpcEffect(WS_METHODS.identityClearClaim, identity.clearClaim(currentSessionId)), [ORCHESTRATION_WS_METHODS.dispatchCommand]: (command) => observeRpcEffect( ORCHESTRATION_WS_METHODS.dispatchCommand, Effect.gen(function* () { - const normalizedCommand = yield* normalizeDispatchCommand(command); + // Resolve deviceType so bot/integration sessions skip the interactive claim gate. + // Discord/Jira share one bot session across many humans; session claim cannot impersonate. + const clientDeviceType = yield* sessions.listActive().pipe( + Effect.map( + (active) => + active.find((entry) => entry.sessionId === currentSessionId)?.client.deviceType, + ), + Effect.orElseSucceed(() => undefined), + ); + const operateClaim = yield* identity + .requireOperateClaim( + currentSessionId, + clientDeviceType !== undefined ? { clientDeviceType } : {}, + ) + .pipe( + Effect.mapError( + (error) => + new OrchestrationDispatchCommandError({ + message: error.message, + code: error.code, + }), + ), + ); + const mapPeople = yield* identity.listMapPeople(); + const normalizedCommand = stampOrchestrationCommandSource({ + command: yield* normalizeDispatchCommand(command), + claim: operateClaim, + clientDeviceType, + people: mapPeople, + }); // Archive removes the thread from the client, so this transport // closes its session and terminals after the command lands. // Settlement cleanup is driven by thread.settled events in the @@ -1347,9 +1622,29 @@ const makeWsRpcLayer = ( ), ) : false; - const result = yield* dispatchNormalizedCommand(normalizedCommand).pipe( + const dispatchWithCleanup = dispatchNormalizedCommand(normalizedCommand).pipe( Effect.tapError(() => cleanupFailedUploadedAttachments(command, normalizedCommand)), ); + // Unarchive restores a missing worktree from the retained + // branch before the command commits; a failed restoration + // leaves the thread archived instead of silently detaching it + // to the main project checkout. + const result = + normalizedCommand.type === "thread.unarchive" + ? yield* worktreeLifecycle + .restoreThreadWorktree( + { threadId: normalizedCommand.threadId }, + dispatchWithCleanup, + ) + .pipe( + Effect.mapError((error) => + toDispatchCommandError( + error, + "Failed to restore the thread's worktree before unarchive.", + ), + ), + ) + : yield* dispatchWithCleanup; yield* recordClientCommandAnalytics(normalizedCommand); if (archiveCommand) { if (shouldStopSessionAfterCommand) { @@ -1418,6 +1713,20 @@ const makeWsRpcLayer = ( ), { "rpc.aggregate": "orchestration" }, ), + [ORCHESTRATION_WS_METHODS.getThreadActivities]: (input) => + observeRpcEffect( + ORCHESTRATION_WS_METHODS.getThreadActivities, + projectionSnapshotQuery.getThreadActivitiesPage(input).pipe( + Effect.mapError( + (cause) => + new OrchestrationGetThreadActivitiesError({ + message: "Failed to load thread activities page", + cause, + }), + ), + ), + { "rpc.aggregate": "orchestration" }, + ), [ORCHESTRATION_WS_METHODS.getFullThreadDiff]: (input) => observeRpcEffect( ORCHESTRATION_WS_METHODS.getFullThreadDiff, @@ -1623,6 +1932,13 @@ const makeWsRpcLayer = ( observeRpcStreamEffect( ORCHESTRATION_WS_METHODS.subscribeThread, Effect.gen(function* () { + // Opening a thread is when we find out its provider ran ahead of us + // (dropped ACP updates, or the session driven from another client). + // Awaited rather than forked: once this returns, any resync is + // persisted, so it is picked up by the snapshot read or the + // catch-up replay below instead of racing them. + yield* grokTranscriptResync.resyncThread(input.threadId); + const isThisThreadDetailEvent = (event: OrchestrationEvent) => event.aggregateKind === "thread" && event.aggregateId === input.threadId && @@ -1756,9 +2072,29 @@ const makeWsRpcLayer = ( if (replayOnMissingSnapshot !== undefined) { return replayOnMissingSnapshot; } + // Distinguish permanently unavailable threads from a row that + // may not be projected yet, so clients can stop resubscribing + // to deleted/archived threads instead of retrying forever. + const lifecycle = yield* projectionSnapshotQuery + .getThreadLifecycleById(input.threadId) + .pipe(Effect.orElseSucceed(() => Option.none())); + const reason = Option.match(lifecycle, { + onNone: () => "thread-missing" as const, + onSome: (row) => + row.deletedAt !== null + ? ("thread-deleted" as const) + : row.archivedAt !== null + ? ("thread-archived" as const) + : ("thread-missing" as const), + }); return yield* new OrchestrationGetSnapshotError({ - message: `Thread ${input.threadId} was not found`, - cause: input.threadId, + message: + reason === "thread-deleted" + ? `Thread ${input.threadId} was deleted` + : reason === "thread-archived" + ? `Thread ${input.threadId} is archived` + : `Thread ${input.threadId} was not found`, + reason, }); } @@ -2056,6 +2392,14 @@ const makeWsRpcLayer = ( "rpc.aggregate": "server", }, ), + [WS_METHODS.serverGetHostResourceSnapshot]: (_input) => + observeRpcEffect(WS_METHODS.serverGetHostResourceSnapshot, hostResourceProbe.read, { + "rpc.aggregate": "server", + }), + [WS_METHODS.serverSignalProcess]: (input) => + observeRpcEffect(WS_METHODS.serverSignalProcess, processDiagnostics.signal(input), { + "rpc.aggregate": "server", + }), [WS_METHODS.serverGetResourceTelemetryHistory]: (input) => observeRpcEffect( WS_METHODS.serverGetResourceTelemetryHistory, @@ -2076,10 +2420,6 @@ const makeWsRpcLayer = ( observeRpcEffect(WS_METHODS.serverRetryResourceTelemetry, resourceTelemetry.retry, { "rpc.aggregate": "server", }), - [WS_METHODS.serverSignalProcess]: (input) => - observeRpcEffect(WS_METHODS.serverSignalProcess, processDiagnostics.signal(input), { - "rpc.aggregate": "server", - }), [WS_METHODS.serverReportClientActivity]: (input, metadata) => Ref.update(rpcClientIds, (clientIds) => { const next = new Set(clientIds); @@ -2108,6 +2448,26 @@ const makeWsRpcLayer = ( observeRpcEffect(WS_METHODS.serverGetBackgroundPolicy, backgroundPolicy.snapshot, { "rpc.aggregate": "server", }), + [WS_METHODS.subscribeBackgroundPolicy]: (_input) => + observeRpcStream( + WS_METHODS.subscribeBackgroundPolicy, + Stream.unwrap( + Effect.map(backgroundPolicy.subscribe, ({ latest, changes }) => + Stream.concat(Stream.make(latest), changes), + ), + ), + { "rpc.aggregate": "server" }, + ), + [WS_METHODS.subscribeResourceTelemetry]: (_input) => + observeRpcStream( + WS_METHODS.subscribeResourceTelemetry, + Stream.unwrap( + Effect.map(resourceTelemetry.subscribe, ({ latest, changes }) => + Stream.concat(Stream.make(latest), changes), + ), + ), + { "rpc.aggregate": "server" }, + ), [WS_METHODS.cloudGetRelayClientStatus]: (_input) => observeRpcEffect(WS_METHODS.cloudGetRelayClientStatus, relayClient.resolve, { "rpc.aggregate": "cloud", @@ -2381,6 +2741,21 @@ const makeWsRpcLayer = ( ), { "rpc.aggregate": "workspace" }, ), + [WS_METHODS.projectsWatchFile]: (input) => + observeRpcStream( + WS_METHODS.projectsWatchFile, + workspaceFileSystem.watchFile(input).pipe( + Stream.mapError( + (cause) => + new ProjectReadFileError({ + ...input, + ...projectFileFailureContext(cause), + cause, + }), + ), + ), + { "rpc.aggregate": "workspace" }, + ), [WS_METHODS.projectsWriteFile]: (input) => observeRpcEffect( WS_METHODS.projectsWriteFile, @@ -2617,6 +2992,12 @@ const makeWsRpcLayer = ( observeRpcEffect(WS_METHODS.vcsListRefs, gitWorkflow.listRefs(input), { "rpc.aggregate": "vcs", }), + [WS_METHODS.vcsResolveBranchChangeRequest]: (input) => + observeRpcEffect( + WS_METHODS.vcsResolveBranchChangeRequest, + gitWorkflow.resolveBranchChangeRequest(input), + { "rpc.aggregate": "vcs" }, + ), [WS_METHODS.vcsCreateWorktree]: (input) => observeRpcEffect( WS_METHODS.vcsCreateWorktree, @@ -2629,6 +3010,18 @@ const makeWsRpcLayer = ( gitWorkflow.removeWorktree(input).pipe(Effect.tap(() => refreshGitStatus(input.cwd))), { "rpc.aggregate": "vcs" }, ), + [WS_METHODS.vcsPreviewWorktreeCleanup]: (input) => + observeRpcEffect( + WS_METHODS.vcsPreviewWorktreeCleanup, + worktreeLifecycle.previewCleanup(input), + { "rpc.aggregate": "vcs" }, + ), + [WS_METHODS.vcsCleanupThreadWorktree]: (input) => + observeRpcEffect( + WS_METHODS.vcsCleanupThreadWorktree, + worktreeLifecycle.cleanupThreadWorktree(input), + { "rpc.aggregate": "vcs" }, + ), [WS_METHODS.vcsCreateRef]: (input) => observeRpcEffect( WS_METHODS.vcsCreateRef, @@ -2740,6 +3133,10 @@ const makeWsRpcLayer = ( observeRpcEffect(WS_METHODS.previewList, previewManager.list(input), { "rpc.aggregate": "preview", }), + [WS_METHODS.previewResolvePort]: (input) => + observeRpcEffect(WS_METHODS.previewResolvePort, portExposure.resolve(input), { + "rpc.aggregate": "preview", + }), [WS_METHODS.previewReportStatus]: (input) => observeRpcEffect(WS_METHODS.previewReportStatus, previewManager.reportStatus(input), { "rpc.aggregate": "preview", @@ -2834,6 +3231,20 @@ const makeWsRpcLayer = ( ), { "rpc.aggregate": "preview" }, ), + [WS_METHODS.subscribeAiUsage]: (_input) => + observeRpcStream( + WS_METHODS.subscribeAiUsage, + Stream.callback((queue) => + Effect.gen(function* () { + yield* aiUsageMonitor.retain; + yield* Queue.offer(queue, yield* aiUsageMonitor.current()); + yield* aiUsageMonitor.subscribe((snapshot) => + Effect.asVoid(Queue.offer(queue, snapshot)), + ); + }), + ), + { "rpc.aggregate": "ai-usage" }, + ), [WS_METHODS.subscribeServerConfig]: (input) => observeRpcStreamEffect( WS_METHODS.subscribeServerConfig, @@ -2997,26 +3408,6 @@ const makeWsRpcLayer = ( }), { "rpc.aggregate": "auth" }, ), - [WS_METHODS.subscribeBackgroundPolicy]: (_input) => - observeRpcStream( - WS_METHODS.subscribeBackgroundPolicy, - Stream.unwrap( - Effect.map(backgroundPolicy.subscribe, ({ latest, changes }) => - Stream.concat(Stream.make(latest), changes), - ), - ), - { "rpc.aggregate": "server" }, - ), - [WS_METHODS.subscribeResourceTelemetry]: (_input) => - observeRpcStream( - WS_METHODS.subscribeResourceTelemetry, - Stream.unwrap( - Effect.map(resourceTelemetry.subscribe, ({ latest, changes }) => - Stream.concat(Stream.make(latest), changes), - ), - ), - { "rpc.aggregate": "server" }, - ), }); }), ); @@ -3071,6 +3462,12 @@ export const websocketRpcRouteLayer = Layer.unwrap( failEnvironmentInternal("internal_error", error), ), ); + const requestUrl = HttpServerRequest.toURL(request); + const productHandshakeValid = + Option.isSome(requestUrl) && + isValidOmegentT3ProductHandshake( + parseProductHandshakeFromSearchParams(requestUrl.value.searchParams), + ); const clientOrigin = readClientConnectionOrigin(request); const clientAnalyticsProps = readClientAnalyticsProps(request); yield* sessions.recordClientConnection(session.sessionId, clientOrigin); @@ -3084,6 +3481,7 @@ export const websocketRpcRouteLayer = Layer.unwrap( clientOrigin, clientAnalyticsProps, previewAutomationBroker, + productHandshakeValid, ).pipe( Layer.provideMerge(RpcSerialization.layerJson), Layer.provide(Layer.succeed(SqlClient.SqlClient, sql)), diff --git a/apps/server/test/ActivityPayloadProjection.test.ts b/apps/server/test/ActivityPayloadProjection.test.ts index 2fd7a3092beb..796df6ad5a90 100644 --- a/apps/server/test/ActivityPayloadProjection.test.ts +++ b/apps/server/test/ActivityPayloadProjection.test.ts @@ -63,6 +63,8 @@ function makeThread(activities: ReadonlyArray): Orc settledAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities, checkpoints: [], diff --git a/apps/server/vite.config.ts b/apps/server/vite.config.ts index 88c8c2f4d37f..bcf5676f65e6 100644 --- a/apps/server/vite.config.ts +++ b/apps/server/vite.config.ts @@ -22,6 +22,7 @@ export { shouldBundleCliDependency }; const repoEnv = loadRepoEnv(); const cliBuildChannel = packageJson.version.includes("-nightly.") ? "nightly" : "latest"; +const serverTestTimeout = 120_000; export default mergeConfig( baseConfig, @@ -39,7 +40,11 @@ export default mergeConfig( entry: ["src/bin.ts"], outDir: "dist", sourcemap: true, - clean: true, + // Never wipe dist/ wholesale: deploy builds the server while a live + // process is still serving dist/client. Full clean deletes that tree and + // desktop opens to an empty shell until (if) the client is recopied. + // cli.ts selectively removes non-client artifacts before pack instead. + clean: false, deps: { // Both halves are required. `alwaysBundle` forces the JS dependencies in // (declared deps are external by default, which is what this change is @@ -75,15 +80,81 @@ export default mergeConfig( }, }, test: { - // The server suite exercises sqlite, git, temp worktrees, and orchestration - // runtimes heavily. Running files in parallel introduces load-sensitive flakes. - fileParallelism: false, + fileParallelism: true, + maxWorkers: 4, // Appended to the root setup, which mergeConfig concatenates. setupFiles: ["./src/testUtils/gitConfig.setup.ts"], + projects: [ + { + test: { + name: "server", + isolate: false, + hookTimeout: serverTestTimeout, + testTimeout: serverTestTimeout, + include: ["integration/**/*.test.ts", "scripts/**/*.test.ts", "src/**/*.test.ts"], + exclude: [ + "src/assets/AssetAccess.test.ts", + "src/bootstrap.test.ts", + "src/cli/app.test.ts", + "src/provider/Layers/ClaudeCapabilitiesProbe.test.ts", + "src/provider/Layers/GrokAdapter.test.ts", + "src/provider/Layers/ProviderRegistry.test.ts", + "src/terminal/NodePtyAdapter.test.ts", + "src/workspace/WorkspaceEntries.test.ts", + ], + }, + }, + { + test: { + name: "server-isolated-module-mocks", + isolate: true, + hookTimeout: serverTestTimeout, + testTimeout: serverTestTimeout, + include: [ + // Mocks `node:fs/promises`.open so a path swap during open is + // visible. Under isolate:false the real module is already bound + // and the descriptor is not rejected. + "src/assets/AssetAccess.test.ts", + "src/bootstrap.test.ts", + // Mocks `node:os`.homedir so `t3 app` resolves ~/.t3 into the + // fixture tree. Under isolate:false an earlier file binds the + // real os module and the mock never applies — the CLI then + // connects to the live Linux desktop socket. + "src/cli/app.test.ts", + // xAI prompt-complete can land after the assertion under + // isolate:false CI load (`hello from ` vs `hello from mock`). + "src/provider/Layers/GrokAdapter.test.ts", + // Wraps ChildProcessSpawner and drives SettingsWatcherLive + // through TestClock. Under isolate:false a sibling file in + // the same worker can swallow the second binaryPath probe. + "src/provider/Layers/ProviderRegistry.test.ts", + "src/terminal/NodePtyAdapter.test.ts", + "src/workspace/WorkspaceEntries.test.ts", + ], + }, + }, + { + test: { + name: "server-isolated-claude-probe", + isolate: true, + fileParallelism: false, + maxWorkers: 1, + hookTimeout: serverTestTimeout, + testTimeout: serverTestTimeout, + include: [ + // Spies `@anthropic-ai/claude-agent-sdk`.query. Under isolate:false + // ClaudeProvider already bound the real query. Keep this file out + // of the Grok isolated pool so its 4s live timeout does not race + // prompt-complete assertions (`hello from ` vs `hello from mock`). + "src/provider/Layers/ClaudeCapabilitiesProbe.test.ts", + ], + }, + }, + ], // Server integration tests exercise sqlite, git, and orchestration together. // Under package-wide runs they can exceed the default budget on loaded CI hosts. - hookTimeout: 120_000, - testTimeout: 120_000, + hookTimeout: serverTestTimeout, + testTimeout: serverTestTimeout, }, }), ); diff --git a/apps/vscode/.vscodeignore b/apps/vscode/.vscodeignore new file mode 100644 index 000000000000..77f1925a04a4 --- /dev/null +++ b/apps/vscode/.vscodeignore @@ -0,0 +1,6 @@ +.vscode/** +node_modules/** +src/** +tsconfig.json +vite.config.* +*.test.* diff --git a/apps/vscode/README.md b/apps/vscode/README.md new file mode 100644 index 000000000000..d8f95d47c0de --- /dev/null +++ b/apps/vscode/README.md @@ -0,0 +1,45 @@ +# T3 Code for VS Code + +This package exposes T3 Code as a dedicated VS Code secondary-sidebar chat tab, alongside the +Claude Code, Chat, and Codex tabs. It connects directly to the same T3 Code server used by the web, +desktop, and mobile clients, so projects, threads, messages, turn state, and assistant streaming +remain synchronized. It also provides an optional native `@t3` participant inside VS Code Chat. + +## Development + +1. Start T3 Code (`pnpm dev`), which listens at `http://127.0.0.1:3773` by default. +2. Build the extension with `pnpm --filter t3-code build`. +3. Open this repository in VS Code, choose **Run Extension** from the Run and Debug view, and point + the extension-development host at `apps/vscode` if prompted. +4. Select the **T3 Code** tab in the secondary sidebar. Use **T3 Code: Open Chat** from the Command + Palette if the secondary sidebar is hidden. + +The extension first uses the backend advertised by the T3 Desktop runtime beside its extension +host. This works independently in local, SSH, and other remote windows and avoids treating a +synced `127.0.0.1` setting as the same machine. For a fallback backend, set `t3Code.serverUrl`. +Remote servers can use **T3 Code: Set Server Bearer Token**; the token is stored in VS Code secret +storage and exchanged for a short-lived WebSocket ticket. + +## Dedicated chat workflow + +The T3 Code tab contains a worktree-scoped thread picker, synchronized transcript, context control, +and prompt composer. Select a thread to continue it on any T3 client, or use **+** to create one for +the open worktree. Enter sends; Shift+Enter inserts a newline. + +The same operations are also available through the optional native Chat participant: + +- `@t3 /threads` selects an existing thread whose worktree matches the open workspace folder. +- `@t3 /new` creates a synchronized thread (and a project when the folder is not registered yet). +- A normal `@t3` prompt continues the last selected thread, or the most recently updated matching + thread. If none exists, it creates one. +- `@t3 /history`, `/status`, and `/stop` inspect or control the selected server thread. + +Active editor context is included by default and can be toggled from the composer, with +`@t3 /context`, or **T3 Code: Toggle Automatic Editor Context**. This preference is kept in VS Code's +extension state and never written to workspace settings. A non-empty +selection includes the exact character range; an empty selection includes the cursor line and +column. Explicit Chat references such as `#file` and attached selections are always included. + +The **T3 Code: Ask About Selection** editor action opens Chat with `@t3` prefilled. Context is sent +as structured-looking provider context using workspace-relative paths and language-aware Markdown +fences. T3 Code clients present that envelope as a context reference rather than authored text. diff --git a/apps/vscode/media/t3-code.svg b/apps/vscode/media/t3-code.svg new file mode 100644 index 000000000000..fd6dba4e5e5e --- /dev/null +++ b/apps/vscode/media/t3-code.svg @@ -0,0 +1,3 @@ + + + diff --git a/apps/vscode/package.json b/apps/vscode/package.json new file mode 100644 index 000000000000..241aa28b7f6e --- /dev/null +++ b/apps/vscode/package.json @@ -0,0 +1,216 @@ +{ + "name": "t3-code", + "displayName": "T3 Code", + "version": "0.0.40", + "private": true, + "description": "A dedicated VS Code chat client for synchronized T3 Code threads.", + "categories": [ + "AI", + "Chat", + "Other" + ], + "publisher": "patroza", + "type": "module", + "main": "./dist/extension.cjs", + "scripts": { + "build": "esbuild src/extension.ts --bundle --platform=node --format=cjs --target=node20 --external:vscode --outfile=dist/extension.cjs && esbuild src/webview.ts --bundle --platform=browser --format=iife --target=es2022 --outfile=dist/webview.js", + "typecheck": "tsc --noEmit", + "test": "vp test run" + }, + "dependencies": { + "@t3tools/client-runtime": "workspace:*", + "@t3tools/contracts": "workspace:*", + "@t3tools/shared": "workspace:*", + "dompurify": "^3.2.6", + "effect": "catalog:", + "marked": "^15.0.12" + }, + "devDependencies": { + "@types/vscode": "1.95.0", + "esbuild": "^0.28.0", + "vite-plus": "catalog:" + }, + "contributes": { + "viewsContainers": { + "activitybar": [ + { + "id": "t3CodeViewContainer", + "title": "T3 Code", + "icon": "media/t3-code.svg", + "when": "t3Code.useActivityBar" + } + ], + "secondarySidebar": [ + { + "id": "t3CodeSecondaryViewContainer", + "title": "T3 Code", + "icon": "media/t3-code.svg", + "when": "!t3Code.useActivityBar" + } + ] + }, + "views": { + "t3CodeViewContainer": [ + { + "id": "t3Code.chatView", + "type": "webview", + "name": "T3 Code", + "when": "t3Code.useActivityBar" + } + ], + "t3CodeSecondaryViewContainer": [ + { + "id": "t3Code.chatViewSecondary", + "type": "webview", + "name": "T3 Code", + "when": "!t3Code.useActivityBar" + } + ] + }, + "chatParticipants": [ + { + "id": "t3-code.chat", + "name": "t3", + "fullName": "T3 Code", + "description": "Work with synchronized Codex, Claude, Cursor, Grok, and OpenCode threads.", + "isSticky": true, + "commands": [ + { + "name": "new", + "description": "Create a thread for this worktree" + }, + { + "name": "threads", + "description": "Choose a thread for this worktree" + }, + { + "name": "history", + "description": "Show the synchronized thread history" + }, + { + "name": "context", + "description": "Toggle automatic editor context" + }, + { + "name": "stop", + "description": "Interrupt the active turn" + }, + { + "name": "status", + "description": "Show connection and thread status" + } + ] + } + ], + "commands": [ + { + "command": "t3Code.newThread", + "title": "T3 Code: New Thread for Worktree", + "category": "T3 Code" + }, + { + "command": "t3Code.selectThread", + "title": "T3 Code: Select Worktree Thread", + "category": "T3 Code" + }, + { + "command": "t3Code.askSelection", + "title": "T3 Code: Ask About Selection", + "category": "T3 Code", + "icon": "$(comment-discussion)" + }, + { + "command": "t3Code.toggleEditorContext", + "title": "T3 Code: Toggle Automatic Editor Context", + "category": "T3 Code" + }, + { + "command": "t3Code.showDiagnostics", + "title": "T3 Code: Show Diagnostics", + "category": "T3 Code" + }, + { + "command": "t3Code.pair", + "title": "Pair with Server…", + "category": "T3 Code" + }, + { + "command": "t3Code.setBearerToken", + "title": "T3 Code: Set Server Bearer Token", + "category": "T3 Code" + }, + { + "command": "t3Code.clearBearerToken", + "title": "T3 Code: Clear Server Bearer Token", + "category": "T3 Code" + }, + { + "command": "t3Code.openChat", + "title": "T3 Code: Open Chat", + "category": "T3 Code" + }, + { + "command": "t3Code.openInT3", + "title": "T3 Code: Open in T3", + "category": "T3 Code", + "icon": "$(link-external)" + } + ], + "menus": { + "editor/context": [ + { + "command": "t3Code.askSelection", + "group": "navigation@90", + "when": "editorHasSelection" + } + ] + }, + "configuration": { + "title": "T3 Code", + "properties": { + "t3Code.serverUrl": { + "type": "string", + "scope": "machine", + "default": "http://127.0.0.1:3773", + "description": "Fallback T3 Code server HTTP URL when no local T3 Desktop runtime is advertised. WebSocket and environment endpoints are derived from it." + }, + "t3Code.defaultRuntimeMode": { + "type": "string", + "enum": [ + "approval-required", + "auto-accept-edits", + "full-access" + ], + "default": "full-access", + "description": "Runtime mode for new T3 Code threads." + }, + "t3Code.desktopClientSettingsPath": { + "type": "string", + "default": "", + "description": "Optional path to T3 Desktop's client-settings.json for sharing provider and model favorites. The default auto-detects ~/.t3/userdata or ~/.t3/dev." + } + } + } + }, + "activationEvents": [ + "onChatParticipant:t3-code.chat", + "onCommand:t3Code.askSelection", + "onCommand:t3Code.clearBearerToken", + "onCommand:t3Code.newThread", + "onCommand:t3Code.openChat", + "onCommand:t3Code.openInT3", + "onCommand:t3Code.pair", + "onCommand:t3Code.selectThread", + "onCommand:t3Code.setBearerToken", + "onCommand:t3Code.showDiagnostics", + "onCommand:t3Code.toggleEditorContext", + "onView:t3Code.chatView", + "onView:t3Code.chatViewSecondary" + ], + "extensionKind": [ + "workspace" + ], + "engines": { + "vscode": "^1.95.0" + } +} diff --git a/apps/vscode/src/chatViewProvider.ts b/apps/vscode/src/chatViewProvider.ts new file mode 100644 index 000000000000..544325f3696e --- /dev/null +++ b/apps/vscode/src/chatViewProvider.ts @@ -0,0 +1,1195 @@ +/* oxlint-disable unicorn/require-post-message-target-origin -- VS Code Webview.postMessage is not Window.postMessage. */ +// @effect-diagnostics globalTimers:off globalDate:off cryptoRandomUUID:off +import type { + ModelSelection, + OrchestrationThread, + OrchestrationThreadShell, + RuntimeMode, + ThreadId, + UploadChatAttachment, +} from "@t3tools/contracts"; +import { ApprovalRequestId, MessageId, ProviderInstanceId } from "@t3tools/contracts"; +import * as vscode from "vscode"; + +import { + findLatestProposedPlan, + resolvePlanFollowUpSubmission, + shouldShowPlanFollowUpComposer, +} from "@t3tools/shared/proposedPlan"; +import { resolveChangeRequestIndicator } from "@t3tools/shared/sourceControl"; +import { composePrompt, type TextContext } from "./editorContext.ts"; +import { derivePendingInteractions } from "./pendingInteractions.ts"; +import { fitPromptStashImages } from "./promptStashModel.ts"; +import { PromptStashStore, type PromptStashEntry } from "./promptStashStore.ts"; +import type { T3Client } from "./t3Client.ts"; +import { resolveThreadDisplayStatus } from "./threadStatus.ts"; +import { presentTasks } from "./taskPresentation.ts"; +import { presentToolCalls } from "./toolPresentation.ts"; +import { presentResolvedUserInputs } from "./userInputPresentation.ts"; +import { deriveContextWindowUsage } from "./usagePresentation.ts"; +import { threadWebUrl } from "./threadWebUrl.ts"; + +const HOST_RESOURCE_IDLE_INTERVAL_MS = 10_000; +const HOST_RESOURCE_LIVE_INTERVAL_MS = 1_000; + +interface ChatViewActions { + readonly worktreePath: () => string; + readonly ensureConnected: () => Promise; + readonly restoreThread: () => Promise; + readonly createThread: ( + title?: string, + modelSelection?: ModelSelection, + interactionMode?: "default" | "plan", + ) => Promise; + readonly selectThread: (threadId: string) => Promise; + readonly archiveThread: (threadId: ThreadId) => Promise; + readonly toggleContext: () => Promise; + readonly contextEnabled: () => boolean; + readonly runtimeMode: () => RuntimeMode; + readonly editorContext: () => TextContext | null; + readonly favoriteProviderIds: () => ReadonlyArray; + readonly favoriteModelKeys: () => ReadonlyArray; + readonly toggleProviderFavorite: (instanceId: string) => Promise; + readonly toggleModelFavorite: (modelKey: string) => Promise; + readonly onFavoritesChanged: vscode.Event; +} + +type WebviewRequest = + | { + readonly type: "ready" | "refresh" | "stop" | "toggleContext" | "archiveThread" | "visitT3"; + } + | { + readonly type: "sendNewThread"; + readonly text: string; + readonly instanceId: string; + readonly model: string; + readonly options: ModelSelection["options"]; + readonly images: ReadonlyArray; + readonly interactionMode?: "default" | "plan"; + } + | { readonly type: "selectThread"; readonly threadId: string } + | { readonly type: "hostResourceLive"; readonly live: boolean } + | { + readonly type: "selectModel"; + readonly instanceId: string; + readonly model: string; + readonly options: ModelSelection["options"]; + } + | { readonly type: "openLink"; readonly href: string } + | { readonly type: "openEditorContext"; readonly path: string; readonly detail: string } + | { readonly type: "copyText"; readonly text: string } + | { + readonly type: "approvalResponse"; + readonly requestId: string; + readonly decision: "accept" | "acceptForSession" | "decline"; + } + | { + readonly type: "userInputResponse"; + readonly requestId: string; + readonly answers: Readonly>>; + } + | { readonly type: "toggleProviderFavorite"; readonly instanceId: string } + | { readonly type: "toggleModelFavorite"; readonly modelKey: string } + | { readonly type: "steerQueuedMessage"; readonly messageId: string } + | { readonly type: "removeQueuedMessage"; readonly messageId: string } + | { readonly type: "updateQueuedMessage"; readonly messageId: string; readonly text: string } + | { + readonly type: "send"; + readonly text: string; + readonly images: ReadonlyArray; + readonly interactionMode?: "default" | "plan"; + /** Client-chosen id so the webview can show a pending queue chip. */ + readonly messageId?: string; + } + | { readonly type: "setInteractionMode"; readonly interactionMode: "default" | "plan" } + | { + readonly type: "stashPrompt"; + readonly prompt: string; + readonly images: ReadonlyArray; + readonly providerInstanceId: string | null; + readonly modelSelection: ModelSelection | null; + readonly interactionMode: "default" | "plan"; + } + | { readonly type: "listPromptStash"; readonly providerInstanceId: string | null } + | { readonly type: "restorePromptStash"; readonly id: string } + | { + readonly type: "removePromptStash"; + readonly id: string; + readonly providerInstanceId: string | null; + }; + +function hasImageArray(value: object): boolean { + return ( + "images" in value && + Array.isArray(value.images) && + value.images.every( + (image) => + typeof image === "object" && + image !== null && + "type" in image && + image.type === "image" && + "name" in image && + typeof image.name === "string" && + "mimeType" in image && + typeof image.mimeType === "string" && + "sizeBytes" in image && + typeof image.sizeBytes === "number" && + "dataUrl" in image && + typeof image.dataUrl === "string", + ) + ); +} + +function nonce(): string { + return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(16)), (byte) => + byte.toString(16).padStart(2, "0"), + ).join(""); +} + +function isRequest(value: unknown): value is WebviewRequest { + if (typeof value !== "object" || value === null || !("type" in value)) return false; + const type = (value as { readonly type?: unknown }).type; + if ( + type === "ready" || + type === "refresh" || + type === "stop" || + type === "toggleContext" || + type === "archiveThread" || + type === "visitT3" + ) { + return true; + } + if (type === "sendNewThread") { + return ( + "text" in value && + typeof value.text === "string" && + "instanceId" in value && + typeof value.instanceId === "string" && + "model" in value && + typeof value.model === "string" && + "options" in value && + (value.options === undefined || Array.isArray(value.options)) && + hasImageArray(value) + ); + } + if (type === "selectThread") { + return "threadId" in value && typeof value.threadId === "string"; + } + if (type === "hostResourceLive") { + return "live" in value && typeof value.live === "boolean"; + } + if (type === "selectModel") { + return ( + "instanceId" in value && + typeof value.instanceId === "string" && + "model" in value && + typeof value.model === "string" && + "options" in value && + (value.options === undefined || Array.isArray(value.options)) + ); + } + if (type === "openLink") return "href" in value && typeof value.href === "string"; + if (type === "approvalResponse") { + return ( + "requestId" in value && + typeof value.requestId === "string" && + "decision" in value && + (value.decision === "accept" || + value.decision === "acceptForSession" || + value.decision === "decline") + ); + } + if (type === "userInputResponse") { + return ( + "requestId" in value && + typeof value.requestId === "string" && + "answers" in value && + typeof value.answers === "object" && + value.answers !== null && + Object.values(value.answers).every( + (answer) => + typeof answer === "string" || + (Array.isArray(answer) && answer.every((entry) => typeof entry === "string")), + ) + ); + } + if (type === "openEditorContext") { + return ( + "path" in value && + typeof value.path === "string" && + "detail" in value && + typeof value.detail === "string" + ); + } + if (type === "copyText") return "text" in value && typeof value.text === "string"; + if (type === "toggleProviderFavorite") { + return "instanceId" in value && typeof value.instanceId === "string"; + } + if (type === "toggleModelFavorite") { + return "modelKey" in value && typeof value.modelKey === "string"; + } + if (type === "steerQueuedMessage" || type === "removeQueuedMessage") { + return "messageId" in value && typeof value.messageId === "string"; + } + if (type === "updateQueuedMessage") { + return ( + "messageId" in value && + typeof value.messageId === "string" && + "text" in value && + typeof value.text === "string" + ); + } + if (type === "setInteractionMode") { + return ( + "interactionMode" in value && + (value.interactionMode === "default" || value.interactionMode === "plan") + ); + } + if (type === "listPromptStash") { + return ( + "providerInstanceId" in value && + (value.providerInstanceId === null || typeof value.providerInstanceId === "string") + ); + } + if (type === "restorePromptStash") return "id" in value && typeof value.id === "string"; + if (type === "removePromptStash") { + return ( + "id" in value && + typeof value.id === "string" && + "providerInstanceId" in value && + (value.providerInstanceId === null || typeof value.providerInstanceId === "string") + ); + } + if (type === "stashPrompt") { + return ( + "prompt" in value && + typeof value.prompt === "string" && + hasImageArray(value) && + "providerInstanceId" in value && + (value.providerInstanceId === null || typeof value.providerInstanceId === "string") && + "interactionMode" in value && + (value.interactionMode === "default" || value.interactionMode === "plan") + ); + } + if (type === "send") { + if (!("text" in value) || typeof value.text !== "string" || !hasImageArray(value)) { + return false; + } + if ( + "interactionMode" in value && + value.interactionMode !== undefined && + value.interactionMode !== "default" && + value.interactionMode !== "plan" + ) { + return false; + } + if ( + "messageId" in value && + value.messageId !== undefined && + typeof value.messageId !== "string" + ) { + return false; + } + return true; + } + return false; +} + +export class T3ChatViewProvider implements vscode.WebviewViewProvider, vscode.Disposable { + static readonly primaryViewType = "t3Code.chatView"; + static readonly secondaryViewType = "t3Code.chatViewSecondary"; + + #view: vscode.WebviewView | null = null; + #busy = false; + #error: string | null = null; + #hostResourcesLive = false; + #hostResourceTimer: ReturnType | null = null; + readonly client: T3Client; + readonly actions: ChatViewActions; + readonly extensionUri: vscode.Uri; + readonly #disposables: vscode.Disposable[]; + readonly #attachmentUrls = new Map(); + readonly #attachmentLoads = new Set(); + readonly #promptStash: PromptStashStore; + + constructor( + client: T3Client, + actions: ChatViewActions, + extensionUri: vscode.Uri, + storageUri: vscode.Uri | undefined, + ) { + this.client = client; + this.actions = actions; + this.extensionUri = extensionUri; + this.#promptStash = new PromptStashStore(storageUri); + this.#disposables = [ + client.onShellChanged(() => this.#publish()), + client.onThreadChanged(() => this.#publish()), + client.onAiUsageChanged(() => this.#publish()), + client.onVcsStatusChanged(() => this.#publish()), + client.onConnectionChanged((connected) => { + if (!connected) this.#error = "Connection lost. Refresh to reconnect to T3 Code."; + this.#publish(); + }), + vscode.window.onDidChangeActiveTextEditor(() => this.#publish()), + vscode.window.onDidChangeTextEditorSelection(() => this.#publish()), + vscode.workspace.onDidChangeConfiguration((event) => { + if (event.affectsConfiguration("t3Code")) void this.#refresh(); + }), + actions.onFavoritesChanged(() => this.#publish()), + ]; + } + + resolveWebviewView(view: vscode.WebviewView): void { + this.#view = view; + view.webview.options = { + enableScripts: true, + localResourceRoots: [vscode.Uri.joinPath(this.extensionUri, "dist")], + }; + view.webview.html = this.#html(view.webview); + this.#disposables.push( + view.webview.onDidReceiveMessage((message: unknown) => { + if (isRequest(message)) void this.#handle(message); + }), + view.onDidDispose(() => { + if (this.#view === view) this.#view = null; + }), + view.onDidChangeVisibility(() => { + if (view.visible && this.client.serverConfig === null) void this.#refresh(); + this.#syncHostResourcePolling(); + }), + ); + this.#syncHostResourcePolling(); + } + + dispose(): void { + this.#stopHostResourcePolling(); + for (const disposable of this.#disposables) disposable.dispose(); + this.#disposables.length = 0; + } + + async reveal(): Promise { + try { + await vscode.commands.executeCommand(`${T3ChatViewProvider.secondaryViewType}.focus`); + } catch { + await vscode.commands.executeCommand(`${T3ChatViewProvider.primaryViewType}.focus`); + } + await this.#view?.webview.postMessage({ type: "focusComposer" }); + } + + async openInT3(): Promise { + const thread = this.client.activeThread; + const httpBaseUrl = this.client.httpBaseUrl; + if (thread === null || httpBaseUrl === null) { + await vscode.window.showInformationMessage("Select a T3 thread before opening it."); + return; + } + // The extension host can run remotely, where its connected server URL is + // only locally reachable. Let VS Code map that origin through its active + // SSH/tunnel/proxy, then add T3's browser-level thread selector. + const externalBase = await vscode.env.asExternalUri(vscode.Uri.parse(httpBaseUrl)); + await vscode.env.openExternal( + vscode.Uri.parse(threadWebUrl(externalBase.toString(true), thread.id)), + ); + } + + async #handle(message: WebviewRequest): Promise { + try { + switch (message.type) { + case "ready": + case "refresh": + await this.#refresh(); + this.#syncHostResourcePolling(); + return; + case "hostResourceLive": + if (this.#hostResourcesLive === message.live) return; + this.#hostResourcesLive = message.live; + this.#syncHostResourcePolling(); + return; + case "visitT3": { + await this.openInT3(); + return; + } + case "listPromptStash": + await this.#publishPromptStash(message.providerInstanceId); + return; + case "stashPrompt": { + const entry: PromptStashEntry = { + id: globalThis.crypto.randomUUID(), + createdAt: new Date().toISOString(), + prompt: message.prompt, + ...fitPromptStashImages(message.images), + providerInstanceId: message.providerInstanceId, + modelSelection: message.modelSelection, + interactionMode: message.interactionMode, + }; + const entries = await this.#promptStash.add(entry); + await this.#view?.webview.postMessage({ type: "promptStash", entries, stashed: true }); + return; + } + case "restorePromptStash": { + const entry = await this.#promptStash.take(message.id); + if (entry !== null) { + await this.#view?.webview.postMessage({ type: "restorePromptStash", entry }); + await this.#publishPromptStash(entry.providerInstanceId); + } + return; + } + case "removePromptStash": + await this.#promptStash.remove(message.id); + await this.#publishPromptStash(message.providerInstanceId); + return; + case "archiveThread": { + const thread = this.client.activeThread; + if (thread === null) return; + if (thread.session?.status === "running") { + throw new Error("Stop the running thread before archiving it."); + } + await this.#run(() => this.actions.archiveThread(thread.id)); + return; + } + case "sendNewThread": + await this.#run(async () => { + const authored = message.text.trim(); + if (authored === "" && message.images.length === 0) return; + const modelSelection: ModelSelection = { + instanceId: ProviderInstanceId.make(message.instanceId), + model: message.model, + ...(message.options === undefined ? {} : { options: message.options }), + }; + const interactionMode = message.interactionMode ?? "default"; + const threadId = await this.actions.createThread( + authored.slice(0, 80) || "Image", + modelSelection, + interactionMode, + ); + const editorContext = this.actions.contextEnabled() + ? this.actions.editorContext() + : null; + await this.client.sendPrompt({ + threadId, + prompt: composePrompt(authored, editorContext === null ? [] : [editorContext]), + runtimeMode: this.actions.runtimeMode(), + interactionMode, + modelSelection, + attachments: message.images, + }); + // The shell/title update can arrive before the detail stream. Hydrate + // the authoritative first message before the webview leaves draft mode. + await this.client.selectThread(threadId); + await this.client.waitForActiveThread(); + await this.#view?.webview.postMessage({ type: "sentNewThread" }); + }); + return; + case "selectThread": + await this.#run(async () => { + await this.actions.selectThread(message.threadId); + await this.client.waitForActiveThread(); + }); + return; + case "selectModel": + await this.#run(() => + this.client.setModelSelection({ + instanceId: ProviderInstanceId.make(message.instanceId), + model: message.model, + ...(message.options === undefined ? {} : { options: message.options }), + }), + ); + return; + case "openLink": + await this.#openLink(message.href); + return; + case "openEditorContext": { + if (message.path.split("/").includes("..")) return; + const uri = vscode.Uri.joinPath( + vscode.Uri.file(this.actions.worktreePath()), + ...message.path.split("/"), + ); + const document = await vscode.workspace.openTextDocument(uri); + const editor = await vscode.window.showTextDocument(document); + const line = /(?:line|lines)\s+(\d+)/u.exec(message.detail)?.[1]; + if (line !== undefined) { + const position = new vscode.Position(Math.max(0, Number(line) - 1), 0); + editor.selection = new vscode.Selection(position, position); + editor.revealRange(new vscode.Range(position, position)); + } + return; + } + case "copyText": + await vscode.env.clipboard.writeText(message.text); + return; + case "approvalResponse": + await this.#run(() => + this.client.respondToApproval( + ApprovalRequestId.make(message.requestId), + message.decision, + ), + ); + return; + case "userInputResponse": + await this.#run(() => + this.client.respondToUserInput(ApprovalRequestId.make(message.requestId), { + ...message.answers, + }), + ); + return; + case "toggleProviderFavorite": + await this.actions.toggleProviderFavorite(message.instanceId); + this.#publish(); + return; + case "toggleModelFavorite": + await this.actions.toggleModelFavorite(message.modelKey); + this.#publish(); + return; + case "stop": + await this.#run(() => this.client.interrupt()); + return; + case "toggleContext": + await this.actions.toggleContext(); + this.#publish(); + return; + case "setInteractionMode": + await this.#run(async () => { + if (this.client.activeThread === null) return; + await this.client.setInteractionMode(message.interactionMode); + }); + return; + case "steerQueuedMessage": + await this.#run(() => this.client.steerQueuedMessage(MessageId.make(message.messageId))); + return; + case "removeQueuedMessage": + await this.#run(() => this.client.removeQueuedMessage(MessageId.make(message.messageId))); + return; + case "updateQueuedMessage": + await this.#run(() => + this.client.updateQueuedMessage(MessageId.make(message.messageId), message.text), + ); + return; + case "send": { + await this.#run(async () => { + await this.actions.ensureConnected(); + const thread = this.client.activeThread; + const pendingUserInput = thread + ? derivePendingInteractions(thread.activities).some( + (entry) => entry.kind === "user-input", + ) + : false; + const activePlan = thread + ? findLatestProposedPlan( + thread.proposedPlans.map((plan) => ({ + id: plan.id, + createdAt: plan.createdAt, + updatedAt: plan.updatedAt, + turnId: plan.turnId, + planMarkdown: plan.planMarkdown, + implementedAt: plan.implementedAt, + implementationThreadId: plan.implementationThreadId, + })), + thread.latestTurn?.turnId ?? null, + ) + : null; + const showPlanFollowUp = shouldShowPlanFollowUpComposer({ + interactionMode: message.interactionMode ?? thread?.interactionMode ?? "default", + hasPendingUserInput: pendingUserInput, + proposedPlan: activePlan, + }); + const followUp = + showPlanFollowUp && activePlan + ? resolvePlanFollowUpSubmission({ + draftText: message.text, + planMarkdown: activePlan.planMarkdown, + }) + : null; + const authored = (followUp?.text ?? message.text).trim(); + if (authored === "" && message.images.length === 0) return; + const requestedMode = + followUp?.interactionMode ?? + message.interactionMode ?? + thread?.interactionMode ?? + "default"; + const threadId = + thread?.id ?? + (await this.actions.restoreThread()) ?? + (await this.actions.createThread(authored.slice(0, 80), undefined, requestedMode)); + if (this.client.activeThread?.id === threadId) { + await this.client.setInteractionMode(requestedMode); + } + const context = this.actions.contextEnabled() ? this.actions.editorContext() : null; + await this.client.sendPrompt({ + threadId, + prompt: composePrompt(authored, context === null ? [] : [context]), + runtimeMode: this.actions.runtimeMode(), + interactionMode: requestedMode, + attachments: message.images, + ...(message.messageId !== undefined + ? { messageId: MessageId.make(message.messageId) } + : {}), + ...(followUp?.interactionMode === "default" && activePlan + ? { + sourceProposedPlan: { + threadId, + planId: activePlan.id, + }, + } + : {}), + }); + await this.#view?.webview.postMessage({ type: "sent" }); + }); + return; + } + } + } catch (cause) { + this.#error = cause instanceof Error ? cause.message : String(cause); + this.#publish(); + } + } + + async #publishPromptStash(providerInstanceId: string | null): Promise { + const entries = await this.#promptStash.list(providerInstanceId); + await this.#view?.webview.postMessage({ type: "promptStash", entries }); + } + + async #refresh(): Promise { + await this.#run(async () => { + await this.actions.ensureConnected(); + this.#watchWorktreeVcsStatus(); + await this.actions.restoreThread(); + }); + } + + #watchWorktreeVcsStatus(): void { + try { + this.client.watchVcsStatus(this.actions.worktreePath()); + } catch { + // No workspace folder is open, so there is no checkout to track. + } + } + + /** + * Host metrics poll on a slow heartbeat and step up to a live cadence while the + * pointer is over the gauge, mirroring the web client. Polling is suspended + * while the view is hidden so a collapsed panel costs nothing. + */ + #syncHostResourcePolling(): void { + this.#stopHostResourcePolling(); + if (this.#view?.visible !== true) return; + void this.#pollHostResources(); + this.#hostResourceTimer = setInterval( + () => void this.#pollHostResources(), + this.#hostResourcesLive ? HOST_RESOURCE_LIVE_INTERVAL_MS : HOST_RESOURCE_IDLE_INTERVAL_MS, + ); + } + + #stopHostResourcePolling(): void { + if (this.#hostResourceTimer === null) return; + clearInterval(this.#hostResourceTimer); + this.#hostResourceTimer = null; + } + + async #pollHostResources(): Promise { + try { + // A null snapshot means "disconnected" and hides the gauge, so stale numbers + // never outlive the connection they came from. + const snapshot = await this.client.hostResourceSnapshot(); + // Published on its own channel rather than through `#publish` so a 1s hover + // cadence never re-renders the conversation. + await this.#view?.webview.postMessage({ type: "hostResources", snapshot }); + } catch { + // Host metrics are advisory; a failed probe leaves the last values on screen. + } + } + + async #run(action: () => Promise): Promise { + if (this.#busy) return; + this.#busy = true; + this.#error = null; + this.#publish(); + try { + await action(); + } catch (cause) { + this.#error = cause instanceof Error ? cause.message : String(cause); + } finally { + this.#busy = false; + this.#publish(); + } + } + + #publish(): void { + const view = this.#view; + if (view === null) return; + let threads: ReadonlyArray = []; + try { + threads = this.client.threadsForWorktree(this.actions.worktreePath()); + } catch { + // The empty-workspace message below is more useful than surfacing this as a connection error. + } + const editorContext = this.actions.editorContext(); + const vcsStatus = this.client.vcsStatus; + this.#loadAttachmentUrls(this.client.activeThread); + void view.webview.postMessage({ + type: "state", + state: { + busy: this.#busy, + error: this.#error, + connected: this.client.serverConfig !== null, + supportsQueuedMessages: this.client.serverCapabilities.queuedMessages, + environmentLabel: this.client.serverConfig?.environment.label ?? "T3 Code", + // Scoped to the workspace checkout rather than the active thread's branch: + // the panel follows the worktree VS Code has open. + changeRequest: resolveChangeRequestIndicator( + vcsStatus?.pr, + vcsStatus?.sourceControlProvider, + ), + threads: threads.map((thread) => ({ + id: thread.id, + title: thread.title, + model: thread.modelSelection.model, + status: resolveThreadDisplayStatus(thread), + updatedAt: thread.updatedAt, + })), + activeThread: this.#serializeThread(this.client.activeThread), + models: + this.client.serverConfig?.providers + .filter((provider) => provider.enabled && provider.installed) + .flatMap((provider) => + provider.models.map((model) => ({ + instanceId: provider.instanceId, + model: model.slug, + driver: provider.driver, + providerLabel: provider.displayName ?? provider.driver, + modelLabel: model.name, + optionDescriptors: model.capabilities?.optionDescriptors ?? [], + })), + ) ?? [], + aiUsage: this.client.aiUsage, + favoriteProviderIds: this.actions.favoriteProviderIds(), + favoriteModelKeys: this.actions.favoriteModelKeys(), + contextEnabled: this.actions.contextEnabled(), + editorContext: + editorContext === null + ? null + : { + path: editorContext.relativePath, + startLine: editorContext.startLine, + endLine: editorContext.endLine, + kind: editorContext.kind, + }, + }, + }); + } + + #serializeThread(thread: OrchestrationThread | null) { + if (thread === null) return null; + const pendingInteractions = derivePendingInteractions(thread.activities); + const hasPendingUserInput = pendingInteractions.some((entry) => entry.kind === "user-input"); + const proposedPlans = thread.proposedPlans.map((plan) => ({ + id: plan.id, + createdAt: plan.createdAt, + updatedAt: plan.updatedAt, + turnId: plan.turnId, + planMarkdown: plan.planMarkdown, + implementedAt: plan.implementedAt, + implementationThreadId: plan.implementationThreadId, + })); + const activeProposedPlan = findLatestProposedPlan( + proposedPlans, + thread.latestTurn?.turnId ?? null, + ); + const showPlanFollowUp = shouldShowPlanFollowUpComposer({ + interactionMode: thread.interactionMode, + hasPendingUserInput, + proposedPlan: activeProposedPlan, + }); + return { + id: thread.id, + title: thread.title, + model: thread.modelSelection.model, + instanceId: thread.modelSelection.instanceId, + // Without this the composer cannot read back the thread's option choices + // and every re-render resets each control to its descriptor default. + ...(thread.modelSelection.options === undefined + ? {} + : { options: thread.modelSelection.options }), + runtimeMode: thread.runtimeMode, + interactionMode: thread.interactionMode, + status: resolveThreadDisplayStatus({ + latestTurn: thread.latestTurn, + session: thread.session, + hasPendingApprovals: pendingInteractions.some((entry) => entry.kind === "approval"), + hasPendingUserInput, + interactionMode: thread.interactionMode, + hasActionableProposedPlan: showPlanFollowUp, + }), + turnStartedAt: thread.latestTurn?.startedAt ?? thread.latestTurn?.requestedAt ?? null, + contextWindow: deriveContextWindowUsage(thread.activities), + pendingInteractions, + showPlanFollowUp, + activeProposedPlan: activeProposedPlan + ? { + id: activeProposedPlan.id, + planMarkdown: activeProposedPlan.planMarkdown, + title: + activeProposedPlan.planMarkdown.match(/^\s{0,3}#{1,6}\s+(.+)$/m)?.[1]?.trim() ?? + "Proposed plan", + createdAt: activeProposedPlan.createdAt, + } + : null, + queuedMessages: thread.queuedMessages.map((message) => ({ + messageId: message.messageId, + text: message.text, + attachmentCount: message.attachments.length, + queuedAt: message.queuedAt, + })), + sessionStatus: thread.session?.status ?? null, + hasPendingTurnStart: thread.pendingTurnStart !== null, + proposedPlans: proposedPlans.map((plan) => ({ + id: plan.id, + planMarkdown: plan.planMarkdown, + createdAt: plan.createdAt, + implementedAt: plan.implementedAt, + })), + tasks: presentTasks(thread.activities, thread.latestTurn?.turnId ?? null), + toolCalls: presentToolCalls(thread.activities, { + latestTurn: thread.latestTurn, + session: thread.session, + }), + resolvedUserInputs: presentResolvedUserInputs(thread.activities), + messages: thread.messages.map((message) => ({ + id: message.id, + role: message.role, + text: message.text, + streaming: message.streaming, + createdAt: message.createdAt, + attachments: (message.attachments ?? []).map((attachment) => ({ + ...attachment, + previewUrl: this.#attachmentUrls.get(attachment.id) ?? null, + })), + })), + }; + } + + #loadAttachmentUrls(thread: OrchestrationThread | null): void { + for (const message of thread?.messages ?? []) { + for (const attachment of message.attachments ?? []) { + if (this.#attachmentUrls.has(attachment.id) || this.#attachmentLoads.has(attachment.id)) { + continue; + } + this.#attachmentLoads.add(attachment.id); + void this.client + .createAttachmentUrl(attachment.id) + .then((url) => vscode.env.asExternalUri(vscode.Uri.parse(url))) + .then((uri) => this.#attachmentUrls.set(attachment.id, uri.toString(true))) + .catch(() => undefined) + .finally(() => { + this.#attachmentLoads.delete(attachment.id); + this.#publish(); + }); + } + } + } + + async #openLink(rawHref: string): Promise { + const href = rawHref.trim(); + if (href === "" || href.startsWith("#")) return; + if (/^https?:\/\//iu.test(href)) { + await vscode.env.openExternal(vscode.Uri.parse(href)); + return; + } + if (/^[a-z][a-z0-9+.-]*:/iu.test(href) && !href.startsWith("file:")) return; + const [pathPart = "", fragment = ""] = href.replace(/^file:\/\//iu, "").split("#", 2); + const uri = pathPart.startsWith("/") + ? vscode.Uri.file(pathPart) + : vscode.Uri.joinPath(vscode.Uri.file(this.actions.worktreePath()), pathPart); + const document = await vscode.workspace.openTextDocument(uri); + const lineMatch = /^(?:L)?(\d+)/u.exec(fragment); + const line = Math.max(0, Number(lineMatch?.[1] ?? 1) - 1); + await vscode.window.showTextDocument(document, { + selection: new vscode.Range(line, 0, line, 0), + preview: true, + }); + } + + #html(webview: vscode.Webview): string { + const scriptNonce = nonce(); + const scriptUri = webview.asWebviewUri( + vscode.Uri.joinPath(this.extensionUri, "dist", "webview.js"), + ); + return ` + + + + + + + + +
+
+ + + +
⋯
+
+
Connecting to T3 Code…
+
+
+
+
+
+
+
+
+
0
Open to load stashed prompts.
+
+
+ + +`; + } +} diff --git a/apps/vscode/src/conversationRevision.test.ts b/apps/vscode/src/conversationRevision.test.ts new file mode 100644 index 000000000000..6a1dcd52548c --- /dev/null +++ b/apps/vscode/src/conversationRevision.test.ts @@ -0,0 +1,35 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { conversationRenderRevision } from "./conversationRevision.ts"; + +const conversation = { + draft: false, + thread: { + id: "thread-1", + messages: [{ id: "message-1", text: "Selectable text" }], + toolCalls: [], + resolvedUserInputs: [], + proposedPlans: [], + }, +} as const; + +describe("conversationRenderRevision", () => { + it("stays stable when unrelated view state changes", () => { + const before = { ...conversation, busy: false, usage: null }; + const after = { ...conversation, busy: true, usage: { primary: 42 } }; + + expect(conversationRenderRevision(before)).toBe(conversationRenderRevision(after)); + }); + + it("changes when rendered conversation content changes", () => { + const changed = { + ...conversation, + thread: { + ...conversation.thread, + messages: [{ id: "message-1", text: "Updated text" }], + }, + }; + + expect(conversationRenderRevision(conversation)).not.toBe(conversationRenderRevision(changed)); + }); +}); diff --git a/apps/vscode/src/conversationRevision.ts b/apps/vscode/src/conversationRevision.ts new file mode 100644 index 000000000000..29d52c518b52 --- /dev/null +++ b/apps/vscode/src/conversationRevision.ts @@ -0,0 +1,26 @@ +interface ConversationRevisionThread { + readonly id: string; + readonly messages: ReadonlyArray; + readonly toolCalls: ReadonlyArray; + readonly resolvedUserInputs: ReadonlyArray; + readonly proposedPlans: ReadonlyArray; +} + +export function conversationRenderRevision(input: { + readonly draft: boolean; + readonly thread: ConversationRevisionThread | null; +}): string { + return JSON.stringify({ + draft: input.draft, + thread: + input.thread === null + ? null + : { + id: input.thread.id, + messages: input.thread.messages, + toolCalls: input.thread.toolCalls, + resolvedUserInputs: input.thread.resolvedUserInputs, + proposedPlans: input.thread.proposedPlans, + }, + }); +} diff --git a/apps/vscode/src/desktopFavorites.ts b/apps/vscode/src/desktopFavorites.ts new file mode 100644 index 000000000000..8d0d676d5c16 --- /dev/null +++ b/apps/vscode/src/desktopFavorites.ts @@ -0,0 +1,196 @@ +// @effect-diagnostics nodeBuiltinImport:off - VS Code extension host persistence uses Node's filesystem directly. +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as vscode from "vscode"; + +interface FavoriteEntry { + readonly provider: string; + readonly model: string; +} + +interface DesktopServerRuntime { + readonly origin?: unknown; +} + +export async function readDesktopServerUrl(): Promise { + for (const candidate of [ + NodePath.join(NodeOS.homedir(), ".t3", "userdata", "server-runtime.json"), + NodePath.join(NodeOS.homedir(), ".t3", "dev", "server-runtime.json"), + ]) { + try { + const runtime = JSON.parse( + await NodeFS.promises.readFile(candidate, "utf8"), + ) as DesktopServerRuntime; + if (typeof runtime.origin === "string" && runtime.origin.trim() !== "") { + return new URL(runtime.origin).toString(); + } + } catch (cause) { + if ((cause as NodeJS.ErrnoException).code !== "ENOENT") continue; + } + } + return null; +} + +export async function readDesktopBootstrapCredential(): Promise { + for (const candidate of [ + NodePath.join(NodeOS.homedir(), ".t3", "userdata", "local-bootstrap-credential"), + NodePath.join(NodeOS.homedir(), ".t3", "dev", "local-bootstrap-credential"), + ]) { + try { + const credential = (await NodeFS.promises.readFile(candidate, "utf8")).trim(); + if (credential !== "") return credential; + } catch (cause) { + if ((cause as NodeJS.ErrnoException).code !== "ENOENT") continue; + } + } + return null; +} + +function isFavoriteEntry(value: unknown): value is FavoriteEntry { + return ( + typeof value === "object" && + value !== null && + "provider" in value && + typeof value.provider === "string" && + "model" in value && + typeof value.model === "string" + ); +} + +function parseDocument(text: string): Record { + const value: unknown = JSON.parse(text); + if (typeof value !== "object" || value === null || Array.isArray(value)) { + throw new Error("T3 desktop client settings are not a JSON object."); + } + return value as Record; +} + +export class DesktopFavoritesStore implements vscode.Disposable { + readonly #changed = new vscode.EventEmitter(); + #watcher: vscode.FileSystemWatcher | null = null; + #settingsPath = ""; + #favorites: ReadonlyArray = []; + #providerFavorites: ReadonlyArray = []; + + readonly onDidChange = this.#changed.event; + + get providerIds(): ReadonlyArray { + return this.#providerFavorites; + } + + get modelKeys(): ReadonlyArray { + return this.#favorites.map((favorite) => `${favorite.provider}:${favorite.model}`); + } + + async initialize(): Promise { + this.#settingsPath = await this.#resolveSettingsPath(); + await this.#reload(); + this.#watcher?.dispose(); + this.#watcher = vscode.workspace.createFileSystemWatcher( + new vscode.RelativePattern( + NodePath.dirname(this.#settingsPath), + NodePath.basename(this.#settingsPath), + ), + ); + this.#watcher.onDidChange(() => void this.#reload()); + this.#watcher.onDidCreate(() => void this.#reload()); + this.#watcher.onDidDelete(() => { + this.#favorites = []; + this.#providerFavorites = []; + this.#changed.fire(); + }); + } + + async toggleProvider(instanceId: string): Promise { + await this.#update((document) => { + const favorites = Array.isArray(document.providerFavorites) + ? document.providerFavorites.filter((value): value is string => typeof value === "string") + : []; + const index = favorites.indexOf(instanceId); + if (index >= 0) favorites.splice(index, 1); + else favorites.push(instanceId); + document.providerFavorites = favorites; + }); + } + + async toggleModel(modelKey: string): Promise { + const separator = modelKey.indexOf(":"); + if (separator <= 0 || separator === modelKey.length - 1) { + throw new Error("Invalid model favorite."); + } + await this.#toggle(modelKey.slice(0, separator), modelKey.slice(separator + 1)); + } + + dispose(): void { + this.#watcher?.dispose(); + this.#changed.dispose(); + } + + async #resolveSettingsPath(): Promise { + const configured = vscode.workspace + .getConfiguration("t3Code") + .get("desktopClientSettingsPath", "") + .trim(); + if (configured !== "") return configured.replace(/^~/u, NodeOS.homedir()); + const candidates = [ + NodePath.join(NodeOS.homedir(), ".t3", "userdata", "client-settings.json"), + NodePath.join(NodeOS.homedir(), ".t3", "dev", "client-settings.json"), + ]; + for (const candidate of candidates) { + try { + await NodeFS.promises.access(candidate); + return candidate; + } catch { + // Try the next desktop channel. + } + } + return candidates[0]!; + } + + async #reload(): Promise { + try { + const document = parseDocument(await NodeFS.promises.readFile(this.#settingsPath, "utf8")); + this.#favorites = Array.isArray(document.favorites) + ? document.favorites.filter(isFavoriteEntry) + : []; + this.#providerFavorites = Array.isArray(document.providerFavorites) + ? document.providerFavorites.filter((value): value is string => typeof value === "string") + : []; + } catch (cause) { + if ((cause as NodeJS.ErrnoException).code !== "ENOENT") throw cause; + this.#favorites = []; + this.#providerFavorites = []; + } + this.#changed.fire(); + } + + async #toggle(provider: string, model: string): Promise { + await this.#update((document) => { + const favorites = Array.isArray(document.favorites) + ? document.favorites.filter(isFavoriteEntry) + : []; + const index = favorites.findIndex( + (favorite) => favorite.provider === provider && favorite.model === model, + ); + if (index >= 0) favorites.splice(index, 1); + else favorites.push({ provider, model }); + document.favorites = favorites; + }); + } + + async #update(mutate: (document: Record) => void): Promise { + let document: Record = {}; + try { + document = parseDocument(await NodeFS.promises.readFile(this.#settingsPath, "utf8")); + } catch (cause) { + if ((cause as NodeJS.ErrnoException).code !== "ENOENT") throw cause; + } + mutate(document); + await NodeFS.promises.mkdir(NodePath.dirname(this.#settingsPath), { recursive: true }); + const temporaryPath = `${this.#settingsPath}.${process.pid}.tmp`; + await NodeFS.promises.writeFile(temporaryPath, `${JSON.stringify(document)}\n`, "utf8"); + await NodeFS.promises.rename(temporaryPath, this.#settingsPath); + await this.#reload(); + } +} diff --git a/apps/vscode/src/editorContext.test.ts b/apps/vscode/src/editorContext.test.ts new file mode 100644 index 000000000000..608590d4dda2 --- /dev/null +++ b/apps/vscode/src/editorContext.test.ts @@ -0,0 +1,38 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { composePrompt, renderTextContext, splitEditorContext } from "./editorContext.ts"; + +describe("editor context", () => { + it("describes precise selections", () => { + expect( + renderTextContext({ + relativePath: "src/main.ts", + languageId: "typescript", + text: "const answer = 42;", + startLine: 8, + endLine: 8, + kind: "selection", + }), + ).toContain("src/main.ts (line 8)\n```typescript\nconst answer = 42;\n```"); + }); + + it("keeps context separate from the authored prompt", () => { + const rendered = composePrompt("Explain this", [ + { + relativePath: "readme.md", + languageId: "markdown", + text: "hello", + startLine: 1, + endLine: 1, + cursorColumn: 3, + kind: "cursor-line", + }, + ]); + expect(rendered).toMatch(/^Explain this\n\n/); + expect(rendered).toContain("line 1, column 3"); + expect(splitEditorContext(rendered)).toEqual({ + text: "Explain this", + references: [{ path: "readme.md", detail: "line 1, column 3" }], + }); + }); +}); diff --git a/apps/vscode/src/editorContext.ts b/apps/vscode/src/editorContext.ts new file mode 100644 index 000000000000..e7254520e4eb --- /dev/null +++ b/apps/vscode/src/editorContext.ts @@ -0,0 +1,55 @@ +export interface TextContext { + readonly relativePath: string; + readonly languageId: string; + readonly text: string; + readonly startLine: number; + readonly endLine: number; + readonly cursorColumn?: number; + readonly kind: "selection" | "cursor-line" | "reference"; +} + +export interface ParsedEditorContext { + readonly text: string; + readonly references: ReadonlyArray<{ readonly path: string; readonly detail: string }>; +} + +const MAX_CONTEXT_CHARS = 48_000; + +function fenceFor(text: string): string { + let fence = "```"; + while (text.includes(fence)) fence += "`"; + return fence; +} + +export function renderTextContext(context: TextContext): string { + const clipped = + context.text.length > MAX_CONTEXT_CHARS + ? `${context.text.slice(0, MAX_CONTEXT_CHARS)}\n… (context truncated)` + : context.text; + const range = + context.startLine === context.endLine + ? `line ${context.startLine}` + : `lines ${context.startLine}-${context.endLine}`; + const cursor = context.cursorColumn === undefined ? "" : `, column ${context.cursorColumn}`; + const fence = fenceFor(clipped); + return `### ${context.relativePath} (${range}${cursor})\n${fence}${context.languageId}\n${clipped}\n${fence}`; +} + +export function composePrompt(prompt: string, contexts: ReadonlyArray): string { + if (contexts.length === 0) return prompt; + return `${prompt}\n\n\n${contexts.map(renderTextContext).join("\n\n")}\n`; +} + +export function splitEditorContext(prompt: string): ParsedEditorContext { + const references: Array<{ path: string; detail: string }> = []; + const text = prompt.replace( + /\n*\s*([\s\S]*?)\s*<\/editor_context>\s*/gu, + (_match, body: string) => { + for (const heading of body.matchAll(/^###\s+(.+?)\s+\(([^\n)]+)\)\s*$/gmu)) { + references.push({ path: heading[1]!, detail: heading[2]! }); + } + return ""; + }, + ); + return { text: text.trim(), references }; +} diff --git a/apps/vscode/src/extension.ts b/apps/vscode/src/extension.ts new file mode 100644 index 000000000000..b33d5e582ffe --- /dev/null +++ b/apps/vscode/src/extension.ts @@ -0,0 +1,578 @@ +// @effect-diagnostics globalDate:off +import type { + ModelSelection, + OrchestrationMessage, + OrchestrationThread, + OrchestrationThreadShell, + RuntimeMode, + ThreadId, +} from "@t3tools/contracts"; +import { resolveRemotePairingTarget } from "@t3tools/shared/remote"; +import * as vscode from "vscode"; + +import { composePrompt, type TextContext } from "./editorContext.ts"; +import { + DesktopFavoritesStore, + readDesktopBootstrapCredential, + readDesktopServerUrl, +} from "./desktopFavorites.ts"; +import { classifyPairingInput, describeTokenExpiry } from "./pairing.ts"; +import { bearerTokenAppliesTo, serverCandidates } from "./serverResolution.ts"; +import { T3ChatViewProvider } from "./chatViewProvider.ts"; +import { T3Client } from "./t3Client.ts"; +import { filterIdentityPeople, type IdentityPerson } from "./identity.ts"; + +const ACTIVE_THREAD_KEY_PREFIX = "t3Code.activeThread"; +const BEARER_TOKEN_SECRET = "t3Code.serverBearerToken"; +// The endpoint a paired bearer token was issued by. Stored beside the token so +// the two are cleared together; see bearerTokenAppliesTo. +const BEARER_TOKEN_ENDPOINT_SECRET = "t3Code.serverBearerTokenEndpoint"; + +function workspaceFolder(): vscode.WorkspaceFolder | undefined { + const activeUri = vscode.window.activeTextEditor?.document.uri; + return ( + (activeUri === undefined ? undefined : vscode.workspace.getWorkspaceFolder(activeUri)) ?? + vscode.workspace.workspaceFolders?.[0] + ); +} + +function worktreePath(): string { + const folder = workspaceFolder(); + if (folder === undefined) throw new Error("Open a workspace folder before using T3 Code."); + return folder.uri.fsPath; +} + +function activeThreadStorageKey(): string { + return `${ACTIVE_THREAD_KEY_PREFIX}:${workspaceFolder()?.uri.toString() ?? "none"}`; +} + +function relativePath(uri: vscode.Uri): string { + const folder = vscode.workspace.getWorkspaceFolder(uri); + return folder === undefined ? uri.fsPath : vscode.workspace.asRelativePath(uri, false); +} + +function languageFor(uri: vscode.Uri, fallback = "text"): string { + return ( + vscode.workspace.textDocuments.find((document) => document.uri.toString() === uri.toString()) + ?.languageId ?? fallback + ); +} + +function activeEditorContext(): TextContext | null { + const editor = vscode.window.activeTextEditor; + if (editor === undefined || editor.document.uri.scheme !== "file") return null; + const selection = editor.selection; + if (!selection.isEmpty) { + return { + relativePath: relativePath(editor.document.uri), + languageId: editor.document.languageId, + text: editor.document.getText(selection), + startLine: selection.start.line + 1, + endLine: selection.end.line + 1, + kind: "selection", + }; + } + const line = editor.document.lineAt(selection.active.line); + return { + relativePath: relativePath(editor.document.uri), + languageId: editor.document.languageId, + text: line.text, + startLine: line.lineNumber + 1, + endLine: line.lineNumber + 1, + cursorColumn: selection.active.character + 1, + kind: "cursor-line", + }; +} + +async function referenceContexts( + references: ReadonlyArray, +): Promise> { + const contexts: TextContext[] = []; + for (const reference of references.toReversed()) { + const value = reference.value; + if (value instanceof vscode.Location) { + const document = await vscode.workspace.openTextDocument(value.uri); + contexts.push({ + relativePath: relativePath(value.uri), + languageId: document.languageId, + text: document.getText(value.range), + startLine: value.range.start.line + 1, + endLine: value.range.end.line + 1, + kind: "reference", + }); + } else if (value instanceof vscode.Uri && value.scheme === "file") { + const document = await vscode.workspace.openTextDocument(value); + contexts.push({ + relativePath: relativePath(value), + languageId: languageFor(value, document.languageId), + text: document.getText(), + startLine: 1, + endLine: document.lineCount, + kind: "reference", + }); + } else if (typeof value === "string" && value.trim() !== "") { + contexts.push({ + relativePath: reference.modelDescription ?? reference.id, + languageId: "text", + text: value, + startLine: 1, + endLine: 1, + kind: "reference", + }); + } + } + return contexts; +} + +function configuration(): { + readonly serverUrl: string; + readonly runtimeMode: RuntimeMode; +} { + const config = vscode.workspace.getConfiguration("t3Code"); + return { + serverUrl: config.get("serverUrl", "http://127.0.0.1:3773"), + runtimeMode: config.get("defaultRuntimeMode", "full-access"), + }; +} + +function threadLabel( + thread: OrchestrationThreadShell, +): vscode.QuickPickItem & { threadId: ThreadId } { + const state = thread.latestTurn?.state ?? thread.session?.status ?? "idle"; + return { + label: thread.title, + description: state, + detail: `${thread.modelSelection.model} · ${new Date(thread.updatedAt).toLocaleString()}`, + threadId: thread.id, + }; +} + +function renderHistory(thread: OrchestrationThread): string { + if (thread.messages.length === 0) return "_No messages yet._"; + return thread.messages + .map( + (message) => + `**${message.role === "assistant" ? "T3 Code" : message.role}**\n\n${message.text}`, + ) + .join("\n\n---\n\n"); +} + +function newestAssistantMessage(thread: OrchestrationThread): OrchestrationMessage | null { + return thread.messages.findLast((message) => message.role === "assistant") ?? null; +} + +export function activate(context: vscode.ExtensionContext): void { + const output = vscode.window.createOutputChannel( + vscode.env.remoteName === undefined ? "T3 Code" : "T3 Code (Remote)", + ); + context.subscriptions.push(output); + const log = (message: string): void => { + output.appendLine(`${new Date().toISOString()} ${message}`); + }; + log( + `activate version=${String(context.extension.packageJSON.version)} remote=${vscode.env.remoteName ?? "local"} workspace=${worktreePath()}`, + ); + const client = new T3Client(log); + const desktopFavorites = new DesktopFavoritesStore(); + context.subscriptions.push(desktopFavorites); + void desktopFavorites.initialize().catch((error: unknown) => { + void vscode.window.showWarningMessage( + `T3 Code could not load desktop favorites: ${error instanceof Error ? error.message : String(error)}`, + ); + }); + const [major = 1, minor = 0] = vscode.version.split(".").map(Number); + const supportsSecondarySidebar = major > 1 || (major === 1 && minor >= 106); + void vscode.commands.executeCommand( + "setContext", + "t3Code.useActivityBar", + !supportsSecondarySidebar, + ); + + const pickIdentity = ( + people: ReadonlyArray, + ): Promise => + new Promise((resolve) => { + const picker = vscode.window.createQuickPick< + vscode.QuickPickItem & { person: IdentityPerson } + >(); + picker.title = "Choose your T3 Code identity"; + picker.placeholder = "Type at least 3 characters"; + picker.matchOnDescription = true; + picker.items = []; + picker.onDidChangeValue((value) => { + picker.items = filterIdentityPeople(people, value).map((person) => ({ + label: person.username, + ...(person.name === undefined ? {} : { description: person.name }), + person, + })); + }); + picker.onDidAccept(() => { + const selected = picker.selectedItems[0]?.person; + picker.hide(); + resolve(selected); + }); + picker.onDidHide(() => { + picker.dispose(); + resolve(undefined); + }); + picker.show(); + }); + + const ensureIdentityClaim = async (): Promise => { + const status = await client.identityStatus(); + if (!status.snapshot.enabled || status.claim !== null) return; + const person = await pickIdentity(status.snapshot.people); + if (person === undefined) throw new Error("Choose your T3 Code identity before sending."); + const claim = await client.claimIdentity(person.personId); + void vscode.window.showInformationMessage(`Using ${claim.username}@vscode`); + }; + + const ensureConnected = async (): Promise => { + const config = configuration(); + const bearerToken = await context.secrets.get(BEARER_TOKEN_SECRET); + const bearerEndpoint = (await context.secrets.get(BEARER_TOKEN_ENDPOINT_SECRET)) ?? null; + const bootstrapCredential = await readDesktopBootstrapCredential(); + const connect = async (serverUrl: string): Promise => { + if ( + bearerToken !== undefined && + bearerToken !== "" && + bearerTokenAppliesTo(bearerEndpoint, serverUrl) + ) { + try { + await client.connect(serverUrl, bearerToken); + return; + } catch (bearerCause) { + if (bootstrapCredential === null) throw bearerCause; + } + } + if (bootstrapCredential !== null) { + await client.connectWithBootstrap(serverUrl, bootstrapCredential); + } else { + await client.connect(serverUrl); + } + }; + const desktopServerUrl = await readDesktopServerUrl(); + const candidates = serverCandidates(desktopServerUrl, config.serverUrl, bearerEndpoint); + let lastCause: unknown = new Error("No T3 Code server endpoint is available."); + let connected = false; + for (const candidate of candidates) { + try { + log(`connection candidate source=${candidate.source} endpoint=${candidate.url}`); + await connect(candidate.url); + await client.waitForShell(); + connected = true; + break; + } catch (cause) { + lastCause = cause; + log( + `connection candidate failed source=${candidate.source} endpoint=${candidate.url} error=${cause instanceof Error ? cause.message : String(cause)}`, + ); + } + } + if (!connected) throw lastCause; + await ensureIdentityClaim(); + }; + + const rememberThread = async (threadId: ThreadId): Promise => { + await context.workspaceState.update(activeThreadStorageKey(), threadId); + }; + + const selectThread = async (): Promise => { + await ensureConnected(); + const threads = client.threadsForWorktree(worktreePath()); + if (threads.length === 0) { + void vscode.window.showInformationMessage("No T3 Code threads exist for this worktree yet."); + return undefined; + } + const picked = await vscode.window.showQuickPick(threads.map(threadLabel), { + title: "T3 Code threads for this worktree", + placeHolder: "Choose a synchronized thread", + }); + if (picked === undefined) return undefined; + await client.selectThread(picked.threadId); + await client.waitForActiveThread(); + await rememberThread(picked.threadId); + return picked.threadId; + }; + + const createThread = async ( + title = "New thread", + modelSelection?: ModelSelection, + interactionMode?: "default" | "plan", + ): Promise => { + await ensureConnected(); + const threadId = await client.createThreadForWorktree({ + worktreePath: worktreePath(), + title, + runtimeMode: configuration().runtimeMode, + ...(interactionMode === undefined ? {} : { interactionMode }), + ...(modelSelection === undefined ? {} : { modelSelection }), + }); + await rememberThread(threadId); + return threadId; + }; + + const restoreThread = async (): Promise => { + await ensureConnected(); + const stored = context.workspaceState.get(activeThreadStorageKey()); + const threads = client.threadsForWorktree(worktreePath()); + const thread = threads.find((candidate) => candidate.id === stored) ?? threads[0]; + if (thread === undefined) return undefined; + await client.selectThread(thread.id); + await client.waitForActiveThread(); + await rememberThread(thread.id); + return thread.id; + }; + + const editorContextStateKey = "t3Code.includeEditorContext"; + const contextEnabled = () => context.globalState.get(editorContextStateKey, true); + const toggleContext = async (): Promise => { + const next = !contextEnabled(); + await context.globalState.update(editorContextStateKey, next); + return next; + }; + + const selectThreadById = async (threadId: string): Promise => { + await ensureConnected(); + const thread = client.shell?.threads.find((candidate) => candidate.id === threadId); + if (thread === undefined) throw new Error("The selected T3 Code thread no longer exists."); + await client.selectThread(thread.id); + await client.waitForActiveThread(); + await rememberThread(thread.id); + }; + + const archiveThreadById = async (threadId: ThreadId): Promise => { + await ensureConnected(); + await client.archiveThread(threadId); + const replacement = client.threadsForWorktree(worktreePath())[0]; + if (replacement !== undefined) { + await client.selectThread(replacement.id); + await client.waitForActiveThread(); + await rememberThread(replacement.id); + } else { + await context.workspaceState.update(activeThreadStorageKey(), undefined); + } + }; + + const chatView = new T3ChatViewProvider( + client, + { + worktreePath, + ensureConnected, + restoreThread, + createThread, + selectThread: selectThreadById, + archiveThread: archiveThreadById, + toggleContext, + contextEnabled, + runtimeMode: () => configuration().runtimeMode, + editorContext: activeEditorContext, + favoriteProviderIds: () => desktopFavorites.providerIds, + favoriteModelKeys: () => desktopFavorites.modelKeys, + toggleProviderFavorite: (instanceId) => desktopFavorites.toggleProvider(instanceId), + toggleModelFavorite: (modelKey) => desktopFavorites.toggleModel(modelKey), + onFavoritesChanged: desktopFavorites.onDidChange, + }, + context.extensionUri, + context.storageUri, + ); + + const handler: vscode.ChatRequestHandler = async (request, _chatContext, response, token) => { + try { + if (request.command === "context") { + const enabled = await toggleContext(); + response.markdown( + `Automatic active-editor context is now **${enabled ? "on" : "off"}**. Explicit \`#file\` and selection references are always included.`, + ); + return; + } + if (request.command === "threads") { + const selected = await selectThread(); + if (selected !== undefined) + response.markdown(`Selected synchronized thread \`${selected}\`.`); + return; + } + if (request.command === "new") { + const title = request.prompt.trim() || "New thread"; + const threadId = await createThread(title.slice(0, 80)); + response.markdown( + `Created synchronized thread **${title.slice(0, 80)}** (\`${threadId}\`).`, + ); + return; + } + const threadId = + (await restoreThread()) ?? + (await createThread(request.prompt.trim().slice(0, 80) || "New thread")); + if (request.command === "history") { + response.markdown(renderHistory(await client.waitForActiveThread())); + return; + } + if (request.command === "status") { + const thread = await client.waitForActiveThread(); + response.markdown( + `Connected to **${client.serverConfig?.environment.label ?? "T3 Code"}**.\n\nThread: **${thread.title}** \nModel: \`${thread.modelSelection.model}\` \nRuntime: \`${thread.runtimeMode}\` \nState: \`${thread.latestTurn?.state ?? thread.session?.status ?? "idle"}\``, + ); + return; + } + if (request.command === "stop") { + await client.interrupt(); + response.markdown("Interrupt requested."); + return; + } + + const explicit = await referenceContexts(request.references); + const automatic = contextEnabled() ? activeEditorContext() : null; + const contexts = automatic === null ? explicit : [automatic, ...explicit]; + const prompt = composePrompt(request.prompt, contexts); + for (const reference of request.references) { + if (reference.value instanceof vscode.Uri) response.reference(reference.value); + else if (reference.value instanceof vscode.Location) response.reference(reference.value); + } + + const initial = client.activeThread; + const initialAssistant = initial === null ? null : newestAssistantMessage(initial); + const initialTurnId = initial?.latestTurn?.turnId ?? null; + let emitted = ""; + let turnObserved = false; + let finished = false; + let disposeThreadChange = (): void => {}; + response.progress(`Sending to ${initial?.modelSelection.model ?? "T3 Code"}…`); + + const completion = new Promise((resolve, reject) => { + const disposable = client.onThreadChanged((thread) => { + if (thread === null || finished) return; + const turn = thread.latestTurn; + if (turn !== null && (turn.state === "running" || turn.turnId !== initialTurnId)) { + turnObserved = true; + } + const assistant = newestAssistantMessage(thread); + if (assistant !== null && assistant.id !== initialAssistant?.id) { + const next = assistant.text; + if (next.startsWith(emitted)) response.markdown(next.slice(emitted.length)); + else if (next !== emitted) response.markdown(`\n\n${next}`); + emitted = next; + } + if (turnObserved && turn !== null && turn.state !== "running") { + finished = true; + disposable.dispose(); + if (turn.state === "error") + reject(new Error(thread.session?.lastError ?? "The T3 Code turn failed.")); + else resolve(); + } + }); + token.onCancellationRequested(() => { + if (finished) return; + finished = true; + disposable.dispose(); + void client.interrupt().finally(resolve); + }); + disposeThreadChange = () => disposable.dispose(); + }); + try { + await client.sendPrompt({ threadId, prompt, runtimeMode: configuration().runtimeMode }); + await completion; + } finally { + disposeThreadChange(); + } + if (emitted === "") response.markdown("_Turn completed without an assistant message._"); + return { metadata: { threadId } }; + } catch (cause) { + const message = cause instanceof Error ? cause.message : String(cause); + response.markdown(`$(error) ${message}`); + return { errorDetails: { message } }; + } + }; + + const participant = vscode.chat.createChatParticipant("t3-code.chat", handler); + participant.iconPath = new vscode.ThemeIcon("comment-discussion"); + context.subscriptions.push( + vscode.commands.registerCommand("t3Code.showDiagnostics", () => output.show(true)), + chatView, + vscode.window.registerWebviewViewProvider(T3ChatViewProvider.primaryViewType, chatView, { + webviewOptions: { retainContextWhenHidden: true }, + }), + vscode.window.registerWebviewViewProvider(T3ChatViewProvider.secondaryViewType, chatView, { + webviewOptions: { retainContextWhenHidden: true }, + }), + participant, + vscode.commands.registerCommand("t3Code.newThread", async () => { + const title = await vscode.window.showInputBox({ + prompt: "Thread title", + value: "New thread", + }); + if (title !== undefined) await createThread(title.trim() || "New thread"); + }), + vscode.commands.registerCommand("t3Code.selectThread", selectThread), + vscode.commands.registerCommand("t3Code.toggleEditorContext", toggleContext), + vscode.commands.registerCommand("t3Code.askSelection", async () => { + await chatView.reveal(); + }), + vscode.commands.registerCommand("t3Code.openChat", () => chatView.reveal()), + vscode.commands.registerCommand("t3Code.openInT3", () => chatView.openInT3()), + vscode.commands.registerCommand("t3Code.setBearerToken", async () => { + const token = await vscode.window.showInputBox({ + prompt: "T3 Code server bearer token", + password: true, + ignoreFocusOut: true, + }); + if (token !== undefined && token.trim() !== "") { + await context.secrets.store(BEARER_TOKEN_SECRET, token.trim()); + await context.secrets.delete(BEARER_TOKEN_ENDPOINT_SECRET); + void vscode.window.showInformationMessage( + "T3 Code bearer token stored in VS Code secret storage.", + ); + } + }), + vscode.commands.registerCommand("t3Code.pair", async () => { + const input = await vscode.window.showInputBox({ + password: true, + ignoreFocusOut: true, + prompt: "Paste the T3 Code pairing URL or pairing token", + placeHolder: "http://127.0.0.1:3773/pair#token=… or the bare token", + }); + if (input === undefined || input.trim() === "") return; + try { + const desktopServerUrl = await readDesktopServerUrl(); + const fallbackUrl = + serverCandidates(desktopServerUrl, configuration().serverUrl)[0]?.url ?? + configuration().serverUrl; + const classified = classifyPairingInput(input, fallbackUrl); + const { credential, httpBaseUrl } = + classified.kind === "url" + ? resolveRemotePairingTarget({ pairingUrl: classified.pairingUrl }) + : resolveRemotePairingTarget({ + host: classified.host, + pairingCode: classified.pairingCode, + }); + const { accessToken, expiresInSeconds } = await client.exchangePairingCredential( + httpBaseUrl, + credential, + ); + // Validate against the issuing endpoint before touching SecretStorage. + // Storing first would destroy a working credential whenever pairing + // failed, and the token is only ever valid for the server that issued + // it, so this must not fall back to the desktop or configured candidate. + await client.connect(httpBaseUrl, accessToken); + await client.waitForShell(); + await context.secrets.store(BEARER_TOKEN_SECRET, accessToken); + await context.secrets.store(BEARER_TOKEN_ENDPOINT_SECRET, httpBaseUrl); + await ensureIdentityClaim(); + void vscode.window.showInformationMessage( + `T3 Code paired with ${httpBaseUrl}, valid ${describeTokenExpiry(expiresInSeconds)}.`, + ); + } catch (cause) { + const message = cause instanceof Error ? cause.message : String(cause); + log(`pairing failed error=${message}`); + void vscode.window.showErrorMessage(`T3 Code pairing failed: ${message}`); + } + }), + vscode.commands.registerCommand("t3Code.clearBearerToken", async () => { + await context.secrets.delete(BEARER_TOKEN_SECRET); + await context.secrets.delete(BEARER_TOKEN_ENDPOINT_SECRET); + void vscode.window.showInformationMessage("T3 Code bearer token cleared."); + }), + { dispose: () => void client.dispose() }, + ); +} + +export function deactivate(): void {} diff --git a/apps/vscode/src/identity.test.ts b/apps/vscode/src/identity.test.ts new file mode 100644 index 000000000000..e474af8ef50f --- /dev/null +++ b/apps/vscode/src/identity.test.ts @@ -0,0 +1,19 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { filterIdentityPeople } from "./identity.ts"; + +const people = [ + { personId: "patroza", username: "patroza", name: "Patrick" }, + { personId: "joshua", username: "joshuadima", name: "Joshua" }, +]; + +describe("filterIdentityPeople", () => { + it("does not disclose the roster before three characters", () => { + expect(filterIdentityPeople(people, "pa")).toEqual([]); + }); + + it("matches usernames and names case-insensitively", () => { + expect(filterIdentityPeople(people, "PAT")).toEqual([people[0]]); + expect(filterIdentityPeople(people, "shu")).toEqual([people[1]]); + }); +}); diff --git a/apps/vscode/src/identity.ts b/apps/vscode/src/identity.ts new file mode 100644 index 000000000000..c577f1dab7a0 --- /dev/null +++ b/apps/vscode/src/identity.ts @@ -0,0 +1,34 @@ +export interface IdentityPerson { + readonly personId: string; + readonly username: string; + readonly name?: string; +} + +export interface IdentitySnapshot { + readonly enabled: boolean; + readonly claimRequired: boolean; + readonly people: ReadonlyArray; +} + +export interface SessionIdentityClaim { + readonly personId: string; + readonly username: string; +} + +export interface IdentityStatus { + readonly snapshot: IdentitySnapshot; + readonly claim: SessionIdentityClaim | null; +} + +export function filterIdentityPeople( + people: ReadonlyArray, + query: string, +): ReadonlyArray { + const normalized = query.trim().toLocaleLowerCase(); + if (normalized.length < 3) return []; + return people.filter((person) => + [person.username, person.name] + .filter((value): value is string => value !== undefined) + .some((value) => value.toLocaleLowerCase().includes(normalized)), + ); +} diff --git a/apps/vscode/src/identitySurface.test.ts b/apps/vscode/src/identitySurface.test.ts new file mode 100644 index 000000000000..b686f2a681b6 --- /dev/null +++ b/apps/vscode/src/identitySurface.test.ts @@ -0,0 +1,18 @@ +// @effect-diagnostics nodeBuiltinImport:off - existence contract reads extension source on disk. +import * as NodeFS from "node:fs"; +import { describe, expect, it } from "vite-plus/test"; + +const extensionSource = NodeFS.readFileSync(new URL("./extension.ts", import.meta.url), "utf8"); +const clientSource = NodeFS.readFileSync(new URL("./t3Client.ts", import.meta.url), "utf8"); + +describe("VS Code identity surface", () => { + it("prompts for an identity and claims the selected person", () => { + expect(extensionSource).toContain("createQuickPick"); + expect(extensionSource).toContain("client.claimIdentity(person.personId)"); + expect(extensionSource).toContain("@vscode"); + }); + + it("attributes prompts to the VS Code channel", () => { + expect(clientSource).toContain('sourceHint: { channel: "vscode" }'); + }); +}); diff --git a/apps/vscode/src/ids.ts b/apps/vscode/src/ids.ts new file mode 100644 index 000000000000..e2e74dbb0646 --- /dev/null +++ b/apps/vscode/src/ids.ts @@ -0,0 +1,14 @@ +import { CommandId, MessageId, ProjectId, ThreadId } from "@t3tools/contracts"; + +function randomUuid(): string { + const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16)); + bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40; + bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80; + const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(""); + return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`; +} + +export const newCommandId = (): CommandId => CommandId.make(randomUuid()); +export const newMessageId = (): MessageId => MessageId.make(randomUuid()); +export const newProjectId = (): ProjectId => ProjectId.make(randomUuid()); +export const newThreadId = (): ThreadId => ThreadId.make(randomUuid()); diff --git a/apps/vscode/src/pairing.test.ts b/apps/vscode/src/pairing.test.ts new file mode 100644 index 000000000000..437122ea2af2 --- /dev/null +++ b/apps/vscode/src/pairing.test.ts @@ -0,0 +1,97 @@ +import { resolveRemotePairingTarget } from "@t3tools/shared/remote"; +import { describe, expect, it } from "vite-plus/test"; + +import { classifyPairingInput, describeTokenExpiry } from "./pairing.ts"; + +const FALLBACK_SERVER_URL = "http://127.0.0.1:3773"; + +describe("classifyPairingInput", () => { + it("treats input containing a scheme as a pairing URL", () => { + expect( + classifyPairingInput("http://127.0.0.1:3773/pair#token=abc123", FALLBACK_SERVER_URL), + ).toEqual({ kind: "url", pairingUrl: "http://127.0.0.1:3773/pair#token=abc123" }); + }); + + it("trims surrounding whitespace from a pairing URL", () => { + expect( + classifyPairingInput(" https://t3.example/pair#token=xyz ", FALLBACK_SERVER_URL), + ).toEqual({ kind: "url", pairingUrl: "https://t3.example/pair#token=xyz" }); + }); + + it("treats a bare token as a pairing code against the fallback host", () => { + expect(classifyPairingInput("pair-token-123", FALLBACK_SERVER_URL)).toEqual({ + kind: "code", + host: FALLBACK_SERVER_URL, + pairingCode: "pair-token-123", + }); + }); + + it("throws on empty or whitespace-only input", () => { + expect(() => classifyPairingInput("", FALLBACK_SERVER_URL)).toThrow( + "Enter a pairing URL or pairing token.", + ); + expect(() => classifyPairingInput(" \n\t ", FALLBACK_SERVER_URL)).toThrow( + "Enter a pairing URL or pairing token.", + ); + }); +}); + +describe("describeTokenExpiry", () => { + it("describes multi-day expiries in days", () => { + expect(describeTokenExpiry(2_592_000)).toBe("~30 days"); + expect(describeTokenExpiry(86_400)).toBe("~1 days"); + }); + + it("describes sub-day expiries in hours", () => { + expect(describeTokenExpiry(18_000)).toBe("~5 hours"); + expect(describeTokenExpiry(3_600)).toBe("~1 hours"); + }); + + it("describes sub-hour expiries in minutes", () => { + expect(describeTokenExpiry(300)).toBe("~5 minutes"); + }); + + it("clamps very short or invalid expiries", () => { + expect(describeTokenExpiry(30)).toBe("~1 minute"); + expect(describeTokenExpiry(0)).toBe("unknown duration"); + expect(describeTokenExpiry(-5)).toBe("unknown duration"); + expect(describeTokenExpiry(Number.NaN)).toBe("unknown duration"); + }); +}); + +describe("classifyPairingInput composed with resolveRemotePairingTarget", () => { + it("resolves a pairing URL to a credential and base URLs", () => { + const classified = classifyPairingInput( + "http://127.0.0.1:3773/pair#token=abc123", + FALLBACK_SERVER_URL, + ); + const resolved = + classified.kind === "url" + ? resolveRemotePairingTarget({ pairingUrl: classified.pairingUrl }) + : resolveRemotePairingTarget({ + host: classified.host, + pairingCode: classified.pairingCode, + }); + expect(resolved).toEqual({ + credential: "abc123", + httpBaseUrl: "http://127.0.0.1:3773/", + wsBaseUrl: "ws://127.0.0.1:3773/", + }); + }); + + it("resolves a bare token against the fallback host", () => { + const classified = classifyPairingInput("abc123", FALLBACK_SERVER_URL); + const resolved = + classified.kind === "url" + ? resolveRemotePairingTarget({ pairingUrl: classified.pairingUrl }) + : resolveRemotePairingTarget({ + host: classified.host, + pairingCode: classified.pairingCode, + }); + expect(resolved).toEqual({ + credential: "abc123", + httpBaseUrl: "http://127.0.0.1:3773/", + wsBaseUrl: "ws://127.0.0.1:3773/", + }); + }); +}); diff --git a/apps/vscode/src/pairing.ts b/apps/vscode/src/pairing.ts new file mode 100644 index 000000000000..0c8a1ce8f0d5 --- /dev/null +++ b/apps/vscode/src/pairing.ts @@ -0,0 +1,35 @@ +export type PairingInput = + | { readonly kind: "url"; readonly pairingUrl: string } + | { readonly kind: "code"; readonly host: string; readonly pairingCode: string }; + +/** + * Classify raw user input as either a full pairing URL (anything containing + * "://") or a bare pairing token to be resolved against a fallback server. + * The real parsing is left to `resolveRemotePairingTarget` from + * `@t3tools/shared/remote`, whose typed errors are fine to let bubble. + */ +export function classifyPairingInput(raw: string, fallbackServerUrl: string): PairingInput { + const trimmed = raw.trim(); + if (trimmed === "") throw new Error("Enter a pairing URL or pairing token."); + if (trimmed.includes("://")) return { kind: "url", pairingUrl: trimmed }; + return { kind: "code", host: fallbackServerUrl, pairingCode: trimmed }; +} + +const DAY_IN_SECONDS = 86_400; +const HOUR_IN_SECONDS = 3_600; +const MINUTE_IN_SECONDS = 60; + +/** Rough human-readable lifetime for the success message, e.g. "~30 days". */ +export function describeTokenExpiry(expiresInSeconds: number): string { + if (!Number.isFinite(expiresInSeconds) || expiresInSeconds <= 0) return "unknown duration"; + if (expiresInSeconds >= DAY_IN_SECONDS) { + return `~${Math.round(expiresInSeconds / DAY_IN_SECONDS)} days`; + } + if (expiresInSeconds >= HOUR_IN_SECONDS) { + return `~${Math.round(expiresInSeconds / HOUR_IN_SECONDS)} hours`; + } + if (expiresInSeconds >= MINUTE_IN_SECONDS) { + return `~${Math.round(expiresInSeconds / MINUTE_IN_SECONDS)} minutes`; + } + return "~1 minute"; +} diff --git a/apps/vscode/src/pendingInteractions.test.ts b/apps/vscode/src/pendingInteractions.test.ts new file mode 100644 index 000000000000..f8326dcec33e --- /dev/null +++ b/apps/vscode/src/pendingInteractions.test.ts @@ -0,0 +1,79 @@ +import type { OrchestrationThreadActivity } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { derivePendingInteractions } from "./pendingInteractions.ts"; + +const activity = (kind: string, payload: unknown, sequence: number): OrchestrationThreadActivity => + ({ + id: `activity-${sequence}`, + kind, + payload, + sequence, + tone: "approval", + summary: kind, + turnId: null, + createdAt: `2026-07-10T00:00:0${sequence}.000Z`, + }) as OrchestrationThreadActivity; + +describe("derivePendingInteractions", () => { + it("keeps unresolved approvals and removes resolved ones", () => { + expect( + derivePendingInteractions([ + activity("approval.requested", { requestId: "one", requestKind: "command" }, 1), + activity("approval.requested", { requestId: "two", requestType: "file_read_approval" }, 2), + activity("approval.resolved", { requestId: "one" }, 3), + ]), + ).toEqual([ + expect.objectContaining({ requestId: "two", requestKind: "file-read", kind: "approval" }), + ]); + }); + + it("preserves structured user-input questions", () => { + const [pending] = derivePendingInteractions([ + activity( + "user-input.requested", + { + requestId: "question", + questions: [ + { + id: "choice", + header: "Choice", + question: "Which one?", + options: [{ label: "First", description: "Use the first option." }], + multiSelect: false, + }, + ], + }, + 1, + ), + ]); + expect(pending).toMatchObject({ kind: "user-input", requestId: "question" }); + }); + + it("removes requests that the provider reports as stale", () => { + expect( + derivePendingInteractions([ + activity( + "user-input.requested", + { + requestId: "stale", + questions: [ + { + id: "choice", + header: "Choice", + question: "Which?", + options: [{ label: "One", description: "First." }], + }, + ], + }, + 1, + ), + activity( + "provider.user-input.respond.failed", + { requestId: "stale", detail: "Stale pending user-input request: stale" }, + 2, + ), + ]), + ).toEqual([]); + }); +}); diff --git a/apps/vscode/src/pendingInteractions.ts b/apps/vscode/src/pendingInteractions.ts new file mode 100644 index 000000000000..75c2fc4965ed --- /dev/null +++ b/apps/vscode/src/pendingInteractions.ts @@ -0,0 +1,113 @@ +import type { OrchestrationThreadActivity, UserInputQuestion } from "@t3tools/contracts"; + +export interface PendingApproval { + readonly kind: "approval"; + readonly requestId: string; + readonly requestKind: "command" | "file-read" | "file-change"; + readonly detail: string | null; + readonly createdAt: string; +} + +export interface PendingUserInput { + readonly kind: "user-input"; + readonly requestId: string; + readonly questions: ReadonlyArray; + readonly createdAt: string; +} + +export type PendingInteraction = PendingApproval | PendingUserInput; + +function record(value: unknown): Record | null { + return typeof value === "object" && value !== null && !Array.isArray(value) + ? (value as Record) + : null; +} + +function requestKind(value: unknown): PendingApproval["requestKind"] | null { + if (value === "command" || value === "file-read" || value === "file-change") return value; + if ( + value === "command_execution_approval" || + value === "exec_command_approval" || + value === "dynamic_tool_call" + ) + return "command"; + if (value === "file_read_approval") return "file-read"; + if (value === "file_change_approval" || value === "apply_patch_approval") return "file-change"; + return null; +} + +function questions(value: unknown): ReadonlyArray | null { + if (!Array.isArray(value)) return null; + const parsed = value.filter((entry): entry is UserInputQuestion => { + const question = record(entry); + return ( + typeof question?.id === "string" && + typeof question.header === "string" && + typeof question.question === "string" && + Array.isArray(question.options) && + question.options.every((option) => { + const value = record(option); + return typeof value?.label === "string" && typeof value.description === "string"; + }) + ); + }); + return parsed.length === value.length && parsed.length > 0 ? parsed : null; +} + +function isStaleFailure(payload: Record): boolean { + const detail = typeof payload.detail === "string" ? payload.detail.toLowerCase() : ""; + return ( + detail.includes("stale pending approval request") || + detail.includes("stale pending user-input request") || + detail.includes("unknown pending approval request") || + detail.includes("unknown pending user-input request") + ); +} + +export function derivePendingInteractions( + activities: ReadonlyArray, +): ReadonlyArray { + const pending = new Map(); + for (const activity of [...activities].toSorted((left, right) => { + if (left.sequence !== undefined && right.sequence !== undefined) + return left.sequence - right.sequence; + return left.createdAt.localeCompare(right.createdAt); + })) { + const payload = record(activity.payload); + if (payload === null || typeof payload.requestId !== "string") continue; + const requestId = payload.requestId; + if (activity.kind === "approval.requested") { + const kind = requestKind(payload.requestKind ?? payload.requestType); + if (kind !== null) { + pending.set(requestId, { + kind: "approval", + requestId, + requestKind: kind, + detail: typeof payload.detail === "string" ? payload.detail : null, + createdAt: activity.createdAt, + }); + } + } else if (activity.kind === "user-input.requested") { + const parsed = questions(payload.questions); + if (parsed !== null) { + pending.set(requestId, { + kind: "user-input", + requestId, + questions: parsed, + createdAt: activity.createdAt, + }); + } + } else if (activity.kind === "approval.resolved" || activity.kind === "user-input.resolved") { + pending.delete(requestId); + } else if ( + (activity.kind === "provider.approval.respond.failed" || + activity.kind === "provider.user-input.respond.failed") && + isStaleFailure(payload) + ) { + pending.delete(requestId); + } + } + return [...pending.values()].toSorted((left, right) => + left.createdAt.localeCompare(right.createdAt), + ); +} diff --git a/apps/vscode/src/promptStashModel.ts b/apps/vscode/src/promptStashModel.ts new file mode 100644 index 000000000000..0edd5e03c4c3 --- /dev/null +++ b/apps/vscode/src/promptStashModel.ts @@ -0,0 +1,49 @@ +import type { ModelSelection, UploadChatAttachment } from "@t3tools/contracts"; + +export interface PromptStashEntry { + readonly id: string; + readonly createdAt: string; + readonly prompt: string; + readonly images: ReadonlyArray; + readonly droppedImageNames: ReadonlyArray; + readonly providerInstanceId: string | null; + readonly modelSelection: ModelSelection | null; + readonly interactionMode: "default" | "plan"; +} + +const MAX_ENTRIES_PER_PROVIDER = 20; +const MAX_TOTAL_ENTRIES = 100; +const MAX_ENTRY_IMAGE_CHARS = 2_700_000; + +export function fitPromptStashImages( + images: ReadonlyArray, +): Pick { + let used = 0; + const kept: UploadChatAttachment[] = []; + const droppedImageNames: string[] = []; + for (const image of images) { + if (used + image.dataUrl.length > MAX_ENTRY_IMAGE_CHARS) { + droppedImageNames.push(image.name); + continue; + } + used += image.dataUrl.length; + kept.push(image); + } + return { images: kept, droppedImageNames }; +} + +export function addPromptStashEntry( + entries: ReadonlyArray, + entry: PromptStashEntry, +): ReadonlyArray { + let scopeEntries = 0; + return [entry, ...entries] + .filter((candidate) => { + if (candidate.providerInstanceId !== entry.providerInstanceId) return true; + scopeEntries += 1; + return scopeEntries <= MAX_ENTRIES_PER_PROVIDER; + }) + .slice(0, MAX_TOTAL_ENTRIES); +} + +export const MAX_PERSISTED_PROMPT_STASH_ENTRIES = MAX_TOTAL_ENTRIES; diff --git a/apps/vscode/src/promptStashStore.test.ts b/apps/vscode/src/promptStashStore.test.ts new file mode 100644 index 000000000000..1abbd8b0c212 --- /dev/null +++ b/apps/vscode/src/promptStashStore.test.ts @@ -0,0 +1,54 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + addPromptStashEntry, + fitPromptStashImages, + type PromptStashEntry, +} from "./promptStashModel.ts"; + +function entry(id: string, providerInstanceId: string): PromptStashEntry { + return { + id, + createdAt: "2026-07-28T00:00:00.000Z", + prompt: id, + images: [], + droppedImageNames: [], + providerInstanceId, + modelSelection: null, + interactionMode: "default", + }; +} + +describe("addPromptStashEntry", () => { + it("caps each provider queue independently", () => { + const existing = [ + ...Array.from({ length: 20 }, (_, index) => entry(`a-${index}`, "a")), + entry("b-0", "b"), + ]; + + const next = addPromptStashEntry(existing, entry("a-new", "a")); + + expect(next.filter((candidate) => candidate.providerInstanceId === "a")).toHaveLength(20); + expect(next[0]?.id).toBe("a-new"); + expect(next.some((candidate) => candidate.id === "a-19")).toBe(false); + expect(next.some((candidate) => candidate.id === "b-0")).toBe(true); + }); + + it("bounds attachment data stored for an entry", () => { + const image = (name: string, chars: number) => ({ + type: "image" as const, + name, + mimeType: "image/png", + sizeBytes: chars, + dataUrl: "x".repeat(chars), + }); + + const result = fitPromptStashImages([ + image("first.png", 2_000_000), + image("second.png", 800_000), + ]); + + expect(result.images.map(({ name }) => name)).toEqual(["first.png"]); + expect(result.droppedImageNames).toEqual(["second.png"]); + }); +}); diff --git a/apps/vscode/src/promptStashStore.ts b/apps/vscode/src/promptStashStore.ts new file mode 100644 index 000000000000..9ea7614e6d2c --- /dev/null +++ b/apps/vscode/src/promptStashStore.ts @@ -0,0 +1,110 @@ +import * as vscode from "vscode"; + +import { + addPromptStashEntry, + MAX_PERSISTED_PROMPT_STASH_ENTRIES, + type PromptStashEntry, +} from "./promptStashModel.ts"; +export type { PromptStashEntry } from "./promptStashModel.ts"; + +interface PersistedPromptStash { + readonly version: 1; + readonly entries: ReadonlyArray; +} + +const FILE_NAME = "prompt-stash-v1.json"; + +function isEntry(value: unknown): value is PromptStashEntry { + if (typeof value !== "object" || value === null) return false; + const entry = value as Partial; + return ( + typeof entry.id === "string" && + typeof entry.createdAt === "string" && + typeof entry.prompt === "string" && + Array.isArray(entry.images) && + Array.isArray(entry.droppedImageNames) && + (entry.providerInstanceId === null || typeof entry.providerInstanceId === "string") && + (entry.modelSelection === null || + (typeof entry.modelSelection === "object" && entry.modelSelection !== null)) && + (entry.interactionMode === "default" || entry.interactionMode === "plan") + ); +} + +export class PromptStashStore { + readonly #storageUri: vscode.Uri | undefined; + #entries: ReadonlyArray | null = null; + #write: Promise = Promise.resolve(); + + constructor(storageUri: vscode.Uri | undefined) { + this.#storageUri = storageUri; + } + + async list(providerInstanceId: string | null): Promise> { + const entries = await this.#load(); + return entries.filter((entry) => entry.providerInstanceId === providerInstanceId); + } + + async add(entry: PromptStashEntry): Promise> { + const entries = await this.#load(); + this.#entries = addPromptStashEntry(entries, entry); + await this.#persist(); + return this.list(entry.providerInstanceId); + } + + async take(id: string): Promise { + const entries = await this.#load(); + const entry = entries.find((candidate) => candidate.id === id) ?? null; + if (entry === null) return null; + this.#entries = entries.filter((candidate) => candidate.id !== id); + await this.#persist(); + return entry; + } + + async remove(id: string): Promise { + const entries = await this.#load(); + const next = entries.filter((candidate) => candidate.id !== id); + if (next.length === entries.length) return; + this.#entries = next; + await this.#persist(); + } + + async #load(): Promise> { + if (this.#entries !== null) return this.#entries; + if (this.#storageUri === undefined) return (this.#entries = []); + try { + const bytes = await vscode.workspace.fs.readFile( + vscode.Uri.joinPath(this.#storageUri, FILE_NAME), + ); + const decoded: unknown = JSON.parse(new TextDecoder().decode(bytes)); + if ( + typeof decoded === "object" && + decoded !== null && + "version" in decoded && + decoded.version === 1 && + "entries" in decoded && + Array.isArray(decoded.entries) + ) { + return (this.#entries = decoded.entries + .filter(isEntry) + .slice(0, MAX_PERSISTED_PROMPT_STASH_ENTRIES)); + } + } catch (cause) { + if (!(cause instanceof vscode.FileSystemError && cause.code === "FileNotFound")) throw cause; + } + return (this.#entries = []); + } + + async #persist(): Promise { + if (this.#storageUri === undefined) return; + const payload: PersistedPromptStash = { version: 1, entries: this.#entries ?? [] }; + const bytes = new TextEncoder().encode(JSON.stringify(payload)); + this.#write = this.#write.then(async () => { + await vscode.workspace.fs.createDirectory(this.#storageUri!); + const target = vscode.Uri.joinPath(this.#storageUri!, FILE_NAME); + const temporary = vscode.Uri.joinPath(this.#storageUri!, `${FILE_NAME}.tmp`); + await vscode.workspace.fs.writeFile(temporary, bytes); + await vscode.workspace.fs.rename(temporary, target, { overwrite: true }); + }); + await this.#write; + } +} diff --git a/apps/vscode/src/providerIcon.ts b/apps/vscode/src/providerIcon.ts new file mode 100644 index 000000000000..99f527dc1fea --- /dev/null +++ b/apps/vscode/src/providerIcon.ts @@ -0,0 +1,58 @@ +interface ProviderIconSpec { + readonly viewBox: string; + readonly color?: string; + readonly paths: ReadonlyArray; +} + +const ICONS: Readonly> = { + codex: { + viewBox: "0 0 256 260", + paths: [ + "M239.184 106.203a64.716 64.716 0 0 0-5.576-53.103C219.452 28.459 191 15.784 163.213 21.74A65.586 65.586 0 0 0 52.096 45.22a64.716 64.716 0 0 0-43.23 31.36c-14.31 24.602-11.061 55.634 8.033 76.74a64.665 64.665 0 0 0 5.525 53.102c14.174 24.65 42.644 37.324 70.446 31.36a64.72 64.72 0 0 0 48.754 21.744c28.481.025 53.714-18.361 62.414-45.481a64.767 64.767 0 0 0 43.229-31.36c14.137-24.558 10.875-55.423-8.083-76.483Zm-97.56 136.338a48.397 48.397 0 0 1-31.105-11.255l1.535-.87 51.67-29.825a8.595 8.595 0 0 0 4.247-7.367v-72.85l21.845 12.636c.218.111.37.32.409.563v60.367c-.056 26.818-21.783 48.545-48.601 48.601Zm-104.466-44.61a48.345 48.345 0 0 1-5.781-32.589l1.534.921 51.722 29.826a8.339 8.339 0 0 0 8.441 0l63.181-36.425v25.221a.87.87 0 0 1-.358.665l-52.335 30.184c-23.257 13.398-52.97 5.431-66.404-17.803ZM23.549 85.38a48.499 48.499 0 0 1 25.58-21.333v61.39a8.288 8.288 0 0 0 4.195 7.316l62.874 36.272-21.845 12.636a.819.819 0 0 1-.767 0L41.353 151.53c-23.211-13.454-31.171-43.144-17.804-66.405v.256Zm179.466 41.695-63.08-36.63L161.73 77.86a.819.819 0 0 1 .768 0l52.233 30.184a48.6 48.6 0 0 1-7.316 87.635v-61.391a8.544 8.544 0 0 0-4.4-7.213Zm21.742-32.69-1.535-.922-51.619-30.081a8.39 8.39 0 0 0-8.492 0L99.98 99.808V74.587a.716.716 0 0 1 .307-.665l52.233-30.133a48.652 48.652 0 0 1 72.236 50.391v.205ZM88.061 139.097l-21.845-12.585a.87.87 0 0 1-.41-.614V65.685a48.652 48.652 0 0 1 79.757-37.346l-1.535.87-51.67 29.825a8.595 8.595 0 0 0-4.246 7.367l-.051 72.697Zm11.868-25.58 28.138-16.217 28.188 16.218v32.434l-28.086 16.218-28.188-16.218-.052-32.434Z", + ], + }, + claudeAgent: { + viewBox: "0 0 24 24", + color: "#d97757", + paths: [ + "M12 1.5c.7 0 1.2.5 1.2 1.2v5l3.5-3.5a1.2 1.2 0 1 1 1.7 1.7l-3.5 3.5h5a1.2 1.2 0 1 1 0 2.4h-5l3.5 3.5a1.2 1.2 0 1 1-1.7 1.7l-3.5-3.5v5a1.2 1.2 0 1 1-2.4 0v-5L7.3 17a1.2 1.2 0 1 1-1.7-1.7l3.5-3.5h-5a1.2 1.2 0 1 1 0-2.4h5L5.6 5.9a1.2 1.2 0 1 1 1.7-1.7l3.5 3.5v-5c0-.7.5-1.2 1.2-1.2Z", + ], + }, + cursor: { + viewBox: "0 0 466.73 532.09", + paths: [ + "M457.43 125.94 244.42 2.96c-6.84-3.95-15.28-3.95-22.12 0L9.3 125.94C3.55 129.26 0 135.4 0 142.05v247.99c0 6.65 3.55 12.79 9.3 16.11l213.01 122.98c6.84 3.95 15.28 3.95 22.12 0l213.01-122.98c5.75-3.32 9.3-9.46 9.3-16.11V142.05c0-6.65-3.55-12.79-9.3-16.11ZM444.05 151.99 238.42 508.15c-1.39 2.4-5.06 1.42-5.06-1.36V273.58c0-4.66-2.49-8.97-6.53-11.31L24.87 145.67c-2.4-1.39-1.42-5.06 1.36-5.06h411.26c5.84 0 9.49 6.33 6.57 11.39Z", + ], + }, + grok: { + viewBox: "0 0 24 24", + paths: [ + "M9.269 15.284 17.248 9.361c.391-.291.95-.177 1.137.274.98 2.378.542 5.237-1.41 7.2-1.951 1.963-4.667 2.393-7.149 1.413l-2.711 1.262c3.889 2.673 8.612 2.012 11.563-.958 2.34-2.354 3.065-5.563 2.387-8.456-.983-4.245.242-5.944 2.757-9.668l-3.123 3.32L9.269 15.284Zm-1.647 1.44c-2.791-2.682-2.31-6.832.072-9.225 1.761-1.771 4.647-2.494 7.166-1.431l2.705-1.257c-.487-.354-1.112-.735-1.828-1.003-3.24-1.34-7.119-.673-9.753 1.973-2.533 2.548-3.33 6.465-1.962 9.808 1.384 3.383-2.2 5.816-4.022 7.983l7.622-6.848Z", + ], + }, + opencode: { + viewBox: "0 0 32 40", + paths: ["M24 32H8V16h16v16Z", "M24 8H8v24h16V8Zm8 32H0V0h32v40Z"], + }, +}; + +const SVG_NS = "http://www.w3.org/2000/svg"; + +export function renderProviderIcon(container: HTMLElement, driver: string, label: string): void { + container.replaceChildren(); + const spec = ICONS[driver]; + if (spec === undefined) { + container.textContent = label.slice(0, 2).toUpperCase(); + return; + } + const svg = document.createElementNS(SVG_NS, "svg"); + svg.setAttribute("viewBox", spec.viewBox); + svg.setAttribute("aria-hidden", "true"); + svg.setAttribute("fill", spec.color ?? "currentColor"); + for (const pathData of spec.paths) { + const path = document.createElementNS(SVG_NS, "path"); + path.setAttribute("d", pathData); + svg.append(path); + } + container.append(svg); +} diff --git a/apps/vscode/src/queueSurface.test.ts b/apps/vscode/src/queueSurface.test.ts new file mode 100644 index 000000000000..33d465d8d4d8 --- /dev/null +++ b/apps/vscode/src/queueSurface.test.ts @@ -0,0 +1,37 @@ +// @effect-diagnostics nodeBuiltinImport:off - existence contract reads extension source on disk. +import * as NodeFS from "node:fs"; +import { describe, expect, it } from "vite-plus/test"; + +const webviewSource = NodeFS.readFileSync(new URL("./webview.ts", import.meta.url), "utf8"); +const providerSource = NodeFS.readFileSync( + new URL("./chatViewProvider.ts", import.meta.url), + "utf8", +); +const clientSource = NodeFS.readFileSync(new URL("./t3Client.ts", import.meta.url), "utf8"); + +describe("VS Code queue / steer surface (align with web/mobile)", () => { + it("labels send-now and dequeues before edit", () => { + expect(webviewSource).toContain('textContent = "Send now"'); + expect(webviewSource).toContain('ariaLabel = "Send queued message now"'); + expect(webviewSource).toContain("Remove from queue and edit in composer"); + expect(webviewSource).toContain('post({ type: "removeQueuedMessage", messageId })'); + // Edit no longer persists via queue.update — resubmit is a normal send. + expect(webviewSource).not.toContain('type: "updateQueuedMessage"'); + }); + + it("optimistically steers and predicts queue-bound sends", () => { + expect(webviewSource).toContain("sendEntersSteeringQueue"); + expect(webviewSource).toContain("steeringQueuedMessageIds"); + expect(webviewSource).toContain("optimisticSteeredMessages"); + expect(webviewSource).toContain("pendingQueuedMessages"); + expect(webviewSource).toContain("willSendEnterSteeringQueue"); + expect(webviewSource).toContain("!state.supportsQueuedMessages"); + expect(webviewSource).toContain("upstream server does not support queued follow-ups"); + expect(providerSource).toContain("sessionStatus: thread.session?.status ?? null"); + expect(providerSource).toContain( + "supportsQueuedMessages: this.client.serverCapabilities.queuedMessages", + ); + expect(providerSource).toContain("hasPendingTurnStart: thread.pendingTurnStart !== null"); + expect(clientSource).toContain("input.messageId ?? newMessageId()"); + }); +}); diff --git a/apps/vscode/src/serverCompatibility.test.ts b/apps/vscode/src/serverCompatibility.test.ts new file mode 100644 index 000000000000..f39978569288 --- /dev/null +++ b/apps/vscode/src/serverCompatibility.test.ts @@ -0,0 +1,26 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + detectServerCapabilities, + FORK_SERVER_CAPABILITIES, + UPSTREAM_SERVER_CAPABILITIES, +} from "./serverCompatibility.ts"; + +describe("detectServerCapabilities", () => { + it("enables fork-only surfaces when the compatibility probe succeeds", async () => { + let calls = 0; + const probe = async () => { + calls += 1; + return { enabled: false }; + }; + + await expect(detectServerCapabilities(probe)).resolves.toEqual(FORK_SERVER_CAPABILITIES); + expect(calls).toBe(1); + }); + + it("keeps shared VS Code features available when an upstream server rejects the probe", async () => { + const probe = async () => Promise.reject(new Error("method not found")); + + await expect(detectServerCapabilities(probe)).resolves.toEqual(UPSTREAM_SERVER_CAPABILITIES); + }); +}); diff --git a/apps/vscode/src/serverCompatibility.ts b/apps/vscode/src/serverCompatibility.ts new file mode 100644 index 000000000000..72930538af19 --- /dev/null +++ b/apps/vscode/src/serverCompatibility.ts @@ -0,0 +1,40 @@ +export interface ServerCapabilities { + readonly forkExtensions: boolean; + readonly identity: boolean; + readonly queuedMessages: boolean; + readonly aiUsage: boolean; + readonly hostResources: boolean; +} + +export const UPSTREAM_SERVER_CAPABILITIES: ServerCapabilities = { + forkExtensions: false, + identity: false, + queuedMessages: false, + aiUsage: false, + hostResources: false, +}; + +export const FORK_SERVER_CAPABILITIES: ServerCapabilities = { + forkExtensions: true, + identity: true, + queuedMessages: true, + aiUsage: true, + hostResources: true, +}; + +/** + * Fork RPC clients contain every locally-known method even when the connected + * server does not implement it, so property-existence checks cannot distinguish + * an upstream server. Identity is a harmless fork-only read and doubles as the + * compatibility probe; a method-not-found response selects the upstream subset. + */ +export async function detectServerCapabilities( + probeForkRpc: () => Promise, +): Promise { + try { + await probeForkRpc(); + return FORK_SERVER_CAPABILITIES; + } catch { + return UPSTREAM_SERVER_CAPABILITIES; + } +} diff --git a/apps/vscode/src/serverResolution.test.ts b/apps/vscode/src/serverResolution.test.ts new file mode 100644 index 000000000000..cbb2f700c452 --- /dev/null +++ b/apps/vscode/src/serverResolution.test.ts @@ -0,0 +1,69 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { bearerTokenAppliesTo, serverCandidates } from "./serverResolution.ts"; + +describe("serverCandidates", () => { + it("prefers the backend advertised by the local desktop runtime", () => { + expect(serverCandidates("http://127.0.0.1:3773", "http://127.0.0.1:8080")).toEqual([ + { source: "desktop", url: "http://127.0.0.1:3773/" }, + { source: "configured", url: "http://127.0.0.1:8080/" }, + ]); + }); + + it("deduplicates equivalent desktop and configured URLs", () => { + expect(serverCandidates("http://127.0.0.1:3773", "http://127.0.0.1:3773/")).toEqual([ + { source: "desktop", url: "http://127.0.0.1:3773/" }, + ]); + }); + + it("uses the configured URL when no desktop runtime is advertised", () => { + expect(serverCandidates(null, "http://remote.example:8080")).toEqual([ + { source: "configured", url: "http://remote.example:8080/" }, + ]); + }); +}); + +describe("paired endpoint candidates", () => { + it("tries the paired endpoint before desktop and configured ones", () => { + expect( + serverCandidates("http://127.0.0.1:3773", "http://127.0.0.1:8080", "http://paired.example"), + ).toEqual([ + { source: "paired", url: "http://paired.example/" }, + { source: "desktop", url: "http://127.0.0.1:3773/" }, + { source: "configured", url: "http://127.0.0.1:8080/" }, + ]); + }); + + it("does not list the paired endpoint twice when it is also the desktop one", () => { + expect( + serverCandidates("http://127.0.0.1:3773", "http://127.0.0.1:8080", "http://127.0.0.1:3773/"), + ).toEqual([ + { source: "paired", url: "http://127.0.0.1:3773/" }, + { source: "configured", url: "http://127.0.0.1:8080/" }, + ]); + }); + + it("is unchanged when nothing is paired", () => { + expect(serverCandidates("http://127.0.0.1:3773", "http://127.0.0.1:8080", null)).toEqual( + serverCandidates("http://127.0.0.1:3773", "http://127.0.0.1:8080"), + ); + }); +}); + +describe("bearerTokenAppliesTo", () => { + it("keeps a paired token away from every server but its issuer", () => { + // Pairing with B must not disclose B's token to the desktop or configured + // server A, which is what an unscoped token would do on the first candidate. + expect(bearerTokenAppliesTo("http://server-b.example", "http://server-a.example")).toBe(false); + expect(bearerTokenAppliesTo("http://server-b.example", "http://server-b.example")).toBe(true); + }); + + it("compares endpoints after normalisation rather than as raw strings", () => { + expect(bearerTokenAppliesTo("http://server-b.example", "http://server-b.example/")).toBe(true); + }); + + it("leaves hand-entered and pre-pinning tokens unscoped", () => { + expect(bearerTokenAppliesTo(null, "http://anything.example")).toBe(true); + expect(bearerTokenAppliesTo("", "http://anything.example")).toBe(true); + }); +}); diff --git a/apps/vscode/src/serverResolution.ts b/apps/vscode/src/serverResolution.ts new file mode 100644 index 000000000000..d9d409e2a4c0 --- /dev/null +++ b/apps/vscode/src/serverResolution.ts @@ -0,0 +1,53 @@ +export interface ServerCandidate { + readonly source: "paired" | "desktop" | "configured"; + readonly url: string; +} + +export function normalizeServerUrl(value: string | null): string | null { + if (value === null || value.trim() === "") return null; + return new URL(value).toString(); +} + +/** + * Prefer the backend advertised by the T3 process running beside this + * extension host. A configured localhost URL may be synced between machines + * or refer to a VS Code-forwarded port, so it is only a fallback. + */ +export function serverCandidates( + desktopServerUrl: string | null, + configuredServerUrl: string, + pairedServerUrl: string | null = null, +): ReadonlyArray { + const paired = normalizeServerUrl(pairedServerUrl); + const desktop = normalizeServerUrl(desktopServerUrl); + const configured = normalizeServerUrl(configuredServerUrl); + const candidates: Array = []; + // An explicit pairing is the strongest signal of intent, and it is the only + // endpoint the paired bearer token may be sent to, so try it first. + if (paired !== null) candidates.push({ source: "paired", url: paired }); + if (desktop !== null && desktop !== paired) candidates.push({ source: "desktop", url: desktop }); + if (configured !== null && configured !== desktop && configured !== paired) { + candidates.push({ source: "configured", url: configured }); + } + return candidates; +} + +/** + * Whether a stored bearer token may be sent to `targetServerUrl`. + * + * A token obtained by pairing is issued by, and only valid for, the server that + * issued it. Offering it to the desktop or configured candidate would disclose + * one server's credential to another, so a scoped token is pinned to its issuer. + * + * A null scope means the token predates endpoint pinning or was entered by hand + * through "Set Server Bearer Token", where the user chose the destination + * themselves. Those stay unpinned so existing setups keep working. + */ +export function bearerTokenAppliesTo( + tokenEndpoint: string | null, + targetServerUrl: string, +): boolean { + const scope = normalizeServerUrl(tokenEndpoint); + if (scope === null) return true; + return scope === normalizeServerUrl(targetServerUrl); +} diff --git a/apps/vscode/src/serverSystemInfoSurface.test.ts b/apps/vscode/src/serverSystemInfoSurface.test.ts new file mode 100644 index 000000000000..a97d81497b03 --- /dev/null +++ b/apps/vscode/src/serverSystemInfoSurface.test.ts @@ -0,0 +1,15 @@ +// @effect-diagnostics nodeBuiltinImport:off - existence contract reads extension source on disk. +import * as NodeFS from "node:fs"; +import { describe, expect, it } from "vite-plus/test"; + +const providerSource = NodeFS.readFileSync( + new URL("./chatViewProvider.ts", import.meta.url), + "utf8", +); + +describe("VS Code server system info surface", () => { + it("keeps horizontal padding when the status bar becomes visible", () => { + expect(providerSource).toContain("#status:not(:empty) { padding: 0 10px 6px; }"); + expect(providerSource).not.toContain("#status:not(:empty) { padding: 0 0 6px; }"); + }); +}); diff --git a/apps/vscode/src/t3Client.ts b/apps/vscode/src/t3Client.ts new file mode 100644 index 000000000000..9b41d171b7ce --- /dev/null +++ b/apps/vscode/src/t3Client.ts @@ -0,0 +1,916 @@ +// @effect-diagnostics globalDate:off globalFetch:off +import { + DEFAULT_MODEL, + DEFAULT_RUNTIME_MODE, + type AiUsageSnapshot, + EnvironmentId, + ORCHESTRATION_WS_METHODS, + PRIMARY_LOCAL_ENVIRONMENT_ID, + ProviderInstanceId, + type ClientOrchestrationCommand, + type ModelSelection, + type OrchestrationProjectShell, + OrchestrationShellSnapshot, + OrchestrationThreadDetailSnapshot, + type OrchestrationThread, + type OrchestrationThreadShell, + type MessageId, + type RuntimeMode, + type ProviderInteractionMode, + type ApprovalRequestId, + type ProviderApprovalDecision, + type ProviderUserInputAnswers, + type ServerConfig, + type ServerHostResourceSnapshot, + type ThreadId, + type UploadChatAttachment, + type VcsStatusResult, + WS_METHODS, +} from "@t3tools/contracts"; +import { applyGitStatusStreamEvent } from "@t3tools/shared/git"; +import { appendOmegentT3ProductHandshake } from "@t3tools/shared/productFamily"; +import { + PrimaryConnectionTarget, + type PreparedConnection, +} from "@t3tools/client-runtime/connection"; +import { + remoteHttpClientLayer, + RpcSessionFactory, + rpcSessionFactoryLayer, + type RpcSession, +} from "@t3tools/client-runtime/rpc"; +import { resolveRemoteWebSocketConnectionUrl } from "@t3tools/client-runtime/authorization"; +import { bootstrapRemoteBearerSession } from "@t3tools/client-runtime/authorization"; +import { fetchRemoteEnvironmentDescriptor } from "@t3tools/client-runtime/environment"; +import { applyShellStreamEvent } from "@t3tools/client-runtime/state/shell"; +import { applyThreadDetailEvent } from "@t3tools/client-runtime/state/threads"; +import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Fiber from "effect/Fiber"; +import * as Layer from "effect/Layer"; +import * as ManagedRuntime from "effect/ManagedRuntime"; +import * as Scope from "effect/Scope"; +import * as Schema from "effect/Schema"; +import * as Stream from "effect/Stream"; +import * as Socket from "effect/unstable/socket/Socket"; + +import { newCommandId, newMessageId, newProjectId, newThreadId } from "./ids.ts"; +import type { IdentitySnapshot, IdentityStatus, SessionIdentityClaim } from "./identity.ts"; +import { + detectServerCapabilities, + type ServerCapabilities, + UPSTREAM_SERVER_CAPABILITIES, +} from "./serverCompatibility.ts"; + +type ThreadListener = (thread: OrchestrationThread | null) => void; +type ShellListener = (shell: OrchestrationShellSnapshot) => void; +type ConnectionListener = (connected: boolean) => void; +type VcsStatusListener = (status: VcsStatusResult | null) => void; + +type CompatibilityRpcClient = Record< + string, + ((payload: unknown) => Effect.Effect) | undefined +>; + +function wsBaseUrl(httpBaseUrl: string): string { + const url = new URL(httpBaseUrl); + url.protocol = url.protocol === "https:" ? "wss:" : "ws:"; + return url.toString(); +} + +function localSocketUrl(httpBaseUrl: string): string { + const url = new URL(wsBaseUrl(httpBaseUrl)); + url.pathname = "/ws"; + url.search = ""; + url.hash = ""; + return appendOmegentT3ProductHandshake(url.toString()); +} + +function normalizedPath(path: string): string { + return path.replaceAll("\\", "/").replace(/\/$/u, "").toLocaleLowerCase(); +} + +function messageFromCause(cause: unknown): string { + if (cause instanceof Error && cause.message.trim() !== "") return cause.message; + return String(cause); +} + +export class T3Client { + readonly #log: (message: string) => void; + readonly #runtime = ManagedRuntime.make( + Layer.merge( + rpcSessionFactoryLayer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal)), + remoteHttpClientLayer((input, init) => globalThis.fetch(input, init)), + ), + ); + #scope: Scope.Closeable | null = null; + #session: RpcSession | null = null; + #shellFiber: Fiber.Fiber | null = null; + #threadFiber: Fiber.Fiber | null = null; + #usageFiber: Fiber.Fiber | null = null; + #vcsStatusFiber: Fiber.Fiber | null = null; + #closedFiber: Fiber.Fiber | null = null; + #vcsStatus: VcsStatusResult | null = null; + #vcsStatusCwd: string | null = null; + #shell: OrchestrationShellSnapshot | null = null; + #activeThread: OrchestrationThread | null = null; + #activeThreadSequence: number | null = null; + #activeThreadId: ThreadId | null = null; + #serverConfig: ServerConfig | null = null; + #serverCapabilities: ServerCapabilities = UPSTREAM_SERVER_CAPABILITIES; + #aiUsage: AiUsageSnapshot | null = null; + #httpBaseUrl: string | null = null; + #bearerToken: string | null = null; + #connectionKey = ""; + #listeners = new Set(); + #shellListeners = new Set(); + #connectionListeners = new Set(); + #usageListeners = new Set<(snapshot: AiUsageSnapshot | null) => void>(); + #vcsStatusListeners = new Set(); + #shellWaiters = new Set<(snapshot: OrchestrationShellSnapshot) => void>(); + #threadWaiters = new Set<(thread: OrchestrationThread) => void>(); + + constructor(log: (message: string) => void = () => {}) { + this.#log = log; + } + + get shell(): OrchestrationShellSnapshot | null { + return this.#shell; + } + + get activeThread(): OrchestrationThread | null { + return this.#activeThread; + } + + get serverConfig(): ServerConfig | null { + return this.#serverConfig; + } + + get aiUsage(): AiUsageSnapshot | null { + return this.#aiUsage; + } + + get serverCapabilities(): ServerCapabilities { + return this.#serverCapabilities; + } + + onThreadChanged(listener: ThreadListener): { dispose(): void } { + this.#listeners.add(listener); + return { dispose: () => this.#listeners.delete(listener) }; + } + + onShellChanged(listener: ShellListener): { dispose(): void } { + this.#shellListeners.add(listener); + return { dispose: () => this.#shellListeners.delete(listener) }; + } + + onConnectionChanged(listener: ConnectionListener): { dispose(): void } { + this.#connectionListeners.add(listener); + return { dispose: () => this.#connectionListeners.delete(listener) }; + } + + onAiUsageChanged(listener: (snapshot: AiUsageSnapshot | null) => void): { dispose(): void } { + this.#usageListeners.add(listener); + return { dispose: () => this.#usageListeners.delete(listener) }; + } + + /** Base URL of the connected server, for building deep links into the T3 web app. */ + get httpBaseUrl(): string | null { + return this.#httpBaseUrl; + } + + get vcsStatus(): VcsStatusResult | null { + return this.#vcsStatus; + } + + onVcsStatusChanged(listener: VcsStatusListener): { dispose(): void } { + this.#vcsStatusListeners.add(listener); + return { dispose: () => this.#vcsStatusListeners.delete(listener) }; + } + + /** + * Tracks the git status of `cwd` for as long as the client lives, re-subscribing + * across reconnects. Calling it again with the same checkout is a no-op. + */ + watchVcsStatus(cwd: string): void { + if (this.#vcsStatusCwd === cwd) return; + this.#vcsStatusCwd = cwd; + void this.#restartVcsStatusSubscription(); + } + + /** + * Host CPU/memory/load for the environment serving this session. Returns null + * while disconnected so callers can poll without guarding on connection state. + */ + async hostResourceSnapshot(): Promise { + const session = this.#session; + if (session === null || !this.#serverCapabilities.hostResources) return null; + return this.#runtime.runPromise(session.client[WS_METHODS.serverGetHostResourceSnapshot]({})); + } + + async waitForShell(): Promise { + if (this.#shell !== null) return this.#shell; + return new Promise((resolve) => this.#shellWaiters.add(resolve)); + } + + async identityStatus(): Promise { + if (!this.#serverCapabilities.identity) { + return { + snapshot: { enabled: false, claimRequired: false, people: [] }, + claim: null, + }; + } + const client = this.#requireSession().client as unknown as CompatibilityRpcClient; + const getSnapshot = client["identity.getSnapshot"]; + const getSessionClaim = client["identity.getSessionClaim"]; + if (getSnapshot === undefined || getSessionClaim === undefined) { + return { + snapshot: { enabled: false, claimRequired: false, people: [] }, + claim: null, + }; + } + const snapshot = (await this.#runtime.runPromise(getSnapshot({}))) as IdentitySnapshot; + if (!snapshot.enabled) return { snapshot, claim: null }; + const result = (await this.#runtime.runPromise(getSessionClaim({}))) as { + readonly claim: SessionIdentityClaim | null; + }; + return { snapshot, claim: result.claim }; + } + + async claimIdentity(personId: string): Promise { + const client = this.#requireSession().client as unknown as CompatibilityRpcClient; + const claim = client["identity.claim"]; + if (claim === undefined) + throw new Error("This T3 Code server does not support identity claims."); + const result = (await this.#runtime.runPromise(claim({ personId, method: "typeahead" }))) as { + readonly claim: SessionIdentityClaim; + }; + return result.claim; + } + + async waitForActiveThread(): Promise { + if (this.#activeThread !== null) return this.#activeThread; + return new Promise((resolve) => this.#threadWaiters.add(resolve)); + } + + async connect(httpBaseUrl: string, bearerToken?: string): Promise { + const startedAt = Date.now(); + const normalizedBaseUrl = new URL(httpBaseUrl).toString(); + const key = `${normalizedBaseUrl}|${bearerToken ?? ""}`; + if (this.#session !== null && this.#connectionKey === key) return; + this.#log(`connect start endpoint=${normalizedBaseUrl}`); + await this.#closeConnection(); + + let environmentId = EnvironmentId.make(PRIMARY_LOCAL_ENVIRONMENT_ID); + let socketUrl = localSocketUrl(normalizedBaseUrl); + let label = "T3 Code"; + if (bearerToken !== undefined && bearerToken !== "") { + const descriptor = await this.#runtime.runPromise( + fetchRemoteEnvironmentDescriptor({ httpBaseUrl: normalizedBaseUrl }), + ); + socketUrl = await this.#runtime.runPromise( + resolveRemoteWebSocketConnectionUrl({ + wsBaseUrl: wsBaseUrl(normalizedBaseUrl), + httpBaseUrl: normalizedBaseUrl, + bearerToken, + }), + ); + label = descriptor.label; + environmentId = descriptor.environmentId; + } + const target = new PrimaryConnectionTarget({ + environmentId, + label, + httpBaseUrl: normalizedBaseUrl, + wsBaseUrl: wsBaseUrl(normalizedBaseUrl), + }); + const prepared: PreparedConnection = { + environmentId, + label, + httpBaseUrl: normalizedBaseUrl, + socketUrl, + httpAuthorization: + bearerToken === undefined || bearerToken === "" + ? null + : { _tag: "Bearer", token: bearerToken }, + target, + }; + const scope = await this.#runtime.runPromise(Scope.make()); + try { + const session = await this.#runtime.runPromise( + Effect.gen(function* () { + const factory = yield* RpcSessionFactory; + const connected = yield* factory.connect(prepared); + yield* connected.ready; + return connected; + }).pipe(Scope.provide(scope)), + ); + this.#scope = scope; + this.#session = session; + this.#connectionKey = key; + this.#serverConfig = await this.#runtime.runPromise(session.initialConfig); + const compatibilityClient = session.client as unknown as CompatibilityRpcClient; + const identityProbe = compatibilityClient["identity.getSnapshot"]; + this.#serverCapabilities = await detectServerCapabilities(() => { + if (identityProbe === undefined) + return Promise.reject(new Error("identity RPC unavailable")); + return this.#runtime.runPromise(identityProbe({})); + }); + this.#log( + `server compatibility=${this.#serverCapabilities.forkExtensions ? "fork" : "upstream"}`, + ); + this.#log(`rpc ready in ${Date.now() - startedAt}ms endpoint=${normalizedBaseUrl}`); + this.#httpBaseUrl = normalizedBaseUrl; + this.#bearerToken = bearerToken ?? null; + await this.#loadShellSnapshot(normalizedBaseUrl, bearerToken); + this.#emitConnection(true); + this.#startShellSubscription(session); + if (this.#serverCapabilities.aiUsage) this.#startUsageSubscription(session); + if (this.#vcsStatusCwd !== null) + this.#startVcsStatusSubscription(session, this.#vcsStatusCwd); + if (this.#activeThreadId !== null) + this.#startThreadSubscription(session, this.#activeThreadId); + this.#closedFiber = this.#runtime.runFork( + Effect.exit(session.closed).pipe( + Effect.tap(() => + Effect.sync(() => { + if (this.#session === session) { + this.#session = null; + this.#serverConfig = null; + this.#connectionKey = ""; + this.#emitConnection(false); + } + }), + ), + Effect.asVoid, + ), + ); + this.#log(`connect complete in ${Date.now() - startedAt}ms endpoint=${normalizedBaseUrl}`); + } catch (cause) { + await this.#runtime.runPromise(Scope.close(scope, Exit.void)); + throw new Error(`Could not connect to T3 Code: ${messageFromCause(cause)}`, { cause }); + } + } + + async connectWithBootstrap(httpBaseUrl: string, credential: string): Promise { + const baseUrl = new URL(httpBaseUrl); + if (this.#session !== null && this.#httpBaseUrl === baseUrl.toString()) return; + const startedAt = Date.now(); + this.#log(`bootstrap start endpoint=${baseUrl}`); + const session = await this.#runtime.runPromise( + bootstrapRemoteBearerSession({ + httpBaseUrl, + credential, + clientMetadata: { label: "T3 Code for VS Code", deviceType: "desktop" }, + }), + ); + this.#log(`bootstrap complete in ${Date.now() - startedAt}ms endpoint=${baseUrl}`); + await this.connect(httpBaseUrl, session.access_token); + } + + /** + * Exchanges a pairing credential for a bearer access token without + * connecting, so callers can persist the token before establishing a + * session. + */ + async exchangePairingCredential( + httpBaseUrl: string, + credential: string, + ): Promise<{ accessToken: string; expiresInSeconds: number }> { + const startedAt = Date.now(); + this.#log(`pairing exchange start endpoint=${httpBaseUrl}`); + const session = await this.#runtime.runPromise( + bootstrapRemoteBearerSession({ + httpBaseUrl, + credential, + clientMetadata: { label: "T3 Code for VS Code", deviceType: "desktop" }, + }), + ); + this.#log(`pairing exchange complete in ${Date.now() - startedAt}ms endpoint=${httpBaseUrl}`); + return { accessToken: session.access_token, expiresInSeconds: session.expires_in }; + } + + projectsForWorktree(worktreePath: string): ReadonlyArray { + const shell = this.#shell; + if (shell === null) return []; + const target = normalizedPath(worktreePath); + const projectIds = new Set( + shell.threads + .filter((thread) => { + const project = shell.projects.find((candidate) => candidate.id === thread.projectId); + return normalizedPath(thread.worktreePath ?? project?.workspaceRoot ?? "") === target; + }) + .map((thread) => thread.projectId), + ); + return shell.projects.filter( + (project) => normalizedPath(project.workspaceRoot) === target || projectIds.has(project.id), + ); + } + + threadsForWorktree(worktreePath: string): ReadonlyArray { + const shell = this.#shell; + if (shell === null) return []; + const target = normalizedPath(worktreePath); + return shell.threads + .filter((thread) => { + const project = shell.projects.find((candidate) => candidate.id === thread.projectId); + return normalizedPath(thread.worktreePath ?? project?.workspaceRoot ?? "") === target; + }) + .toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt)); + } + + async selectThread(threadId: ThreadId): Promise { + const session = this.#requireSession(); + this.#activeThreadId = threadId; + this.#activeThread = null; + this.#activeThreadSequence = null; + this.#emitThread(); + await this.#stopThreadSubscription(); + await this.#loadThreadSnapshot(threadId); + this.#startThreadSubscription(session, threadId); + } + + async createThreadForWorktree(input: { + readonly worktreePath: string; + readonly title: string; + readonly runtimeMode?: RuntimeMode; + readonly interactionMode?: ProviderInteractionMode; + readonly modelSelection?: ModelSelection; + }): Promise { + const session = this.#requireSession(); + const createdAt = new Date().toISOString(); + let project = this.projectsForWorktree(input.worktreePath)[0]; + if (project === undefined) { + const projectId = newProjectId(); + const modelSelection = input.modelSelection ?? this.#defaultModelSelection(); + await this.#dispatch({ + type: "project.create", + commandId: newCommandId(), + projectId, + title: input.worktreePath.split(/[\\/]/u).at(-1) ?? "Workspace", + workspaceRoot: input.worktreePath, + defaultModelSelection: modelSelection, + createdAt, + }); + project = { + id: projectId, + title: input.worktreePath.split(/[\\/]/u).at(-1) ?? "Workspace", + workspaceRoot: input.worktreePath, + defaultModelSelection: modelSelection, + scripts: [], + createdAt, + updatedAt: createdAt, + }; + } + const threadId = newThreadId(); + const modelSelection = + input.modelSelection ?? project.defaultModelSelection ?? this.#defaultModelSelection(); + const isProjectRoot = + normalizedPath(project.workspaceRoot) === normalizedPath(input.worktreePath); + await this.#dispatch({ + type: "thread.create", + commandId: newCommandId(), + threadId, + projectId: project.id, + title: input.title, + modelSelection, + runtimeMode: input.runtimeMode ?? DEFAULT_RUNTIME_MODE, + interactionMode: input.interactionMode ?? "default", + branch: null, + worktreePath: isProjectRoot ? null : input.worktreePath, + createdAt, + }); + this.#activeThreadId = threadId; + this.#activeThread = null; + this.#activeThreadSequence = null; + await this.#stopThreadSubscription(); + this.#startThreadSubscription(session, threadId); + return threadId; + } + + async sendPrompt(input: { + readonly threadId: ThreadId; + readonly prompt: string; + readonly runtimeMode?: RuntimeMode; + readonly interactionMode?: ProviderInteractionMode; + readonly sourceProposedPlan?: { readonly threadId: ThreadId; readonly planId: string }; + readonly modelSelection?: ModelSelection; + readonly attachments?: ReadonlyArray; + /** Prefer a client-provided id so the webview can paint a pending queue chip. */ + readonly messageId?: MessageId; + }): Promise { + const thread = this.#activeThread; + const modelSelection = + input.modelSelection ?? thread?.modelSelection ?? this.#defaultModelSelection(); + const interactionMode = + input.interactionMode ?? thread?.interactionMode ?? ("default" as const); + await this.#dispatch({ + type: "thread.turn.start", + commandId: newCommandId(), + threadId: input.threadId, + message: { + messageId: input.messageId ?? newMessageId(), + role: "user", + text: input.prompt, + attachments: input.attachments ?? [], + }, + modelSelection, + titleSeed: input.prompt.trim().slice(0, 80) || "New thread", + runtimeMode: input.runtimeMode ?? thread?.runtimeMode ?? DEFAULT_RUNTIME_MODE, + interactionMode, + sourceHint: { channel: "vscode" }, + ...(input.sourceProposedPlan === undefined + ? {} + : { sourceProposedPlan: input.sourceProposedPlan }), + createdAt: new Date().toISOString(), + } as ClientOrchestrationCommand); + } + + async steerQueuedMessage(messageId: MessageId): Promise { + if (!this.#serverCapabilities.queuedMessages) + throw new Error("Queued follow-ups require the T3 Code fork server."); + const thread = this.#activeThread; + if (thread === null) throw new Error("Select a T3 Code thread before steering its queue."); + await this.#dispatch({ + type: "thread.queue.steer", + commandId: newCommandId(), + threadId: thread.id, + messageId, + createdAt: new Date().toISOString(), + }); + } + + async removeQueuedMessage(messageId: MessageId): Promise { + if (!this.#serverCapabilities.queuedMessages) + throw new Error("Queued follow-ups require the T3 Code fork server."); + const thread = this.#activeThread; + if (thread === null) throw new Error("Select a T3 Code thread before changing its queue."); + await this.#dispatch({ + type: "thread.queue.remove", + commandId: newCommandId(), + threadId: thread.id, + messageId, + createdAt: new Date().toISOString(), + }); + } + + async updateQueuedMessage(messageId: MessageId, text: string): Promise { + if (!this.#serverCapabilities.queuedMessages) + throw new Error("Queued follow-ups require the T3 Code fork server."); + const thread = this.#activeThread; + if (thread === null) throw new Error("Select a T3 Code thread before changing its queue."); + await this.#dispatch({ + type: "thread.queue.update", + commandId: newCommandId(), + threadId: thread.id, + messageId, + text, + createdAt: new Date().toISOString(), + }); + } + + async setInteractionMode(interactionMode: ProviderInteractionMode): Promise { + const thread = this.#activeThread; + if (thread === null) + throw new Error("Select a T3 Code thread before changing interaction mode."); + if (thread.interactionMode === interactionMode) return; + await this.#dispatch({ + type: "thread.interaction-mode.set", + commandId: newCommandId(), + threadId: thread.id, + interactionMode, + createdAt: new Date().toISOString(), + }); + } + + async setModelSelection(modelSelection: ModelSelection): Promise { + const thread = this.#activeThread; + if (thread === null) throw new Error("Select a T3 Code thread before changing models."); + await this.#dispatch({ + type: "thread.meta.update", + commandId: newCommandId(), + threadId: thread.id, + modelSelection, + }); + } + + async archiveThread(threadId: ThreadId): Promise { + let subscription: { dispose(): void } | undefined; + const archived = new Promise((resolve) => { + subscription = this.onShellChanged((shell) => { + if (!shell.threads.some((thread) => thread.id === threadId)) { + subscription?.dispose(); + resolve(); + } + }); + }); + try { + await this.#dispatch({ + type: "thread.archive", + commandId: newCommandId(), + threadId, + }); + } catch (cause) { + subscription?.dispose(); + throw cause; + } + await archived; + if (this.#activeThreadId === threadId) { + await this.#stopThreadSubscription(); + this.#activeThreadId = null; + this.#activeThread = null; + this.#activeThreadSequence = null; + this.#emitThread(); + } + } + + async createAttachmentUrl(attachmentId: string): Promise { + const session = this.#requireSession(); + const httpBaseUrl = this.#httpBaseUrl; + if (httpBaseUrl === null) throw new Error("T3 Code is not connected."); + const result = await this.#runtime.runPromise( + session.client[WS_METHODS.assetsCreateUrl]({ + resource: { _tag: "attachment", attachmentId }, + }), + ); + return new URL(result.relativeUrl, httpBaseUrl).toString(); + } + + async interrupt(): Promise { + const thread = this.#activeThread; + if (thread === null) return; + await this.#dispatch({ + type: "thread.turn.interrupt", + commandId: newCommandId(), + threadId: thread.id, + ...(thread.latestTurn?.turnId === undefined ? {} : { turnId: thread.latestTurn.turnId }), + createdAt: new Date().toISOString(), + }); + } + + async respondToApproval( + requestId: ApprovalRequestId, + decision: ProviderApprovalDecision, + ): Promise { + const thread = this.#activeThread; + if (thread === null) throw new Error("Select a T3 Code thread before responding."); + await this.#dispatch({ + type: "thread.approval.respond", + commandId: newCommandId(), + threadId: thread.id, + requestId, + decision, + createdAt: new Date().toISOString(), + }); + } + + async respondToUserInput( + requestId: ApprovalRequestId, + answers: ProviderUserInputAnswers, + ): Promise { + const thread = this.#activeThread; + if (thread === null) throw new Error("Select a T3 Code thread before responding."); + await this.#dispatch({ + type: "thread.user-input.respond", + commandId: newCommandId(), + threadId: thread.id, + requestId, + answers, + createdAt: new Date().toISOString(), + }); + } + + async dispose(): Promise { + await this.#closeConnection(); + await this.#runtime.dispose(); + } + + #requireSession(): RpcSession { + if (this.#session === null) throw new Error("T3 Code is not connected."); + return this.#session; + } + + #defaultModelSelection(): ModelSelection { + const provider = this.#serverConfig?.providers.find( + (candidate) => candidate.enabled && candidate.installed && candidate.models.length > 0, + ); + return { + instanceId: provider?.instanceId ?? ProviderInstanceId.make("codex"), + model: + provider?.models.find((model) => !model.isCustom)?.slug ?? + provider?.models[0]?.slug ?? + DEFAULT_MODEL, + }; + } + + async #dispatch(command: ClientOrchestrationCommand): Promise { + const session = this.#requireSession(); + await this.#runtime.runPromise( + session.client[ORCHESTRATION_WS_METHODS.dispatchCommand](command), + ); + } + + #startShellSubscription(session: RpcSession): void { + const stream = session.client[ORCHESTRATION_WS_METHODS.subscribeShell]( + this.#shell === null ? {} : { afterSequence: this.#shell.snapshotSequence }, + ).pipe( + Stream.runForEach((item) => + Effect.sync(() => { + if (item.kind === "snapshot") this.#shell = item.snapshot; + else if (item.kind === "synchronized") { + // Status-only marker (parity with EnvironmentShellState.applyItem); no shell mutation. + } else if (this.#shell !== null) this.#shell = applyShellStreamEvent(this.#shell, item); + if (this.#shell !== null) { + for (const resolve of this.#shellWaiters) resolve(this.#shell); + this.#shellWaiters.clear(); + for (const listener of this.#shellListeners) listener(this.#shell); + } + }), + ), + Effect.tapCause((cause) => Effect.sync(() => this.#log(`shell stream failed ${cause}`))), + ); + this.#shellFiber = this.#runtime.runFork(stream); + } + + async #loadShellSnapshot(httpBaseUrl: string, bearerToken?: string): Promise { + const startedAt = Date.now(); + const url = new URL("/api/orchestration/shell", httpBaseUrl); + const headers = + bearerToken === undefined || bearerToken === "" + ? {} + : { authorization: `Bearer ${bearerToken}` }; + const response = await globalThis.fetch(url, { headers }); + if (!response.ok) { + throw new Error(`Could not load T3 Code threads (HTTP ${response.status}).`); + } + const decode = Schema.decodeUnknownSync(Schema.fromJsonString(OrchestrationShellSnapshot)); + this.#shell = decode(await response.text()); + this.#log( + `shell HTTP complete in ${Date.now() - startedAt}ms projects=${this.#shell.projects.length} threads=${this.#shell.threads.length} sequence=${this.#shell.snapshotSequence}`, + ); + for (const resolve of this.#shellWaiters) resolve(this.#shell); + this.#shellWaiters.clear(); + for (const listener of this.#shellListeners) listener(this.#shell); + } + + #startUsageSubscription(session: RpcSession): void { + const stream = session.client[WS_METHODS.subscribeAiUsage]({}).pipe( + Stream.runForEach((snapshot) => + Effect.sync(() => { + this.#aiUsage = snapshot; + for (const listener of this.#usageListeners) listener(snapshot); + }), + ), + ); + this.#usageFiber = this.#runtime.runFork(stream); + } + + #startVcsStatusSubscription(session: RpcSession, cwd: string): void { + const stream = session.client[WS_METHODS.subscribeVcsStatus]({ cwd }).pipe( + Stream.runForEach((event) => + Effect.sync(() => { + this.#vcsStatus = applyGitStatusStreamEvent(this.#vcsStatus, event); + this.#emitVcsStatus(); + }), + ), + Effect.tapCause((cause) => + Effect.sync(() => this.#log(`vcs status stream failed cwd=${cwd} ${cause}`)), + ), + ); + this.#vcsStatusFiber = this.#runtime.runFork(stream); + } + + async #restartVcsStatusSubscription(): Promise { + await this.#stopVcsStatusSubscription(); + const session = this.#session; + const cwd = this.#vcsStatusCwd; + if (session === null || cwd === null) return; + this.#startVcsStatusSubscription(session, cwd); + } + + async #stopVcsStatusSubscription(): Promise { + if (this.#vcsStatusFiber !== null) { + await this.#runtime.runPromise(Fiber.interrupt(this.#vcsStatusFiber)); + this.#vcsStatusFiber = null; + } + // A fresh subscription replays a snapshot, so the accumulated status must not + // carry over — `applyGitStatusStreamEvent` merges partial updates into it. + if (this.#vcsStatus !== null) { + this.#vcsStatus = null; + this.#emitVcsStatus(); + } + } + + #emitVcsStatus(): void { + for (const listener of this.#vcsStatusListeners) listener(this.#vcsStatus); + } + + #startThreadSubscription(session: RpcSession, threadId: ThreadId): void { + const stream = session.client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId, + ...(this.#activeThreadSequence === null ? {} : { afterSequence: this.#activeThreadSequence }), + }).pipe( + Stream.runForEach((item) => + Effect.sync(() => { + if (item.kind === "snapshot") { + this.#activeThread = item.snapshot.thread; + this.#activeThreadSequence = item.snapshot.snapshotSequence; + } else if (item.kind === "synchronized") { + // Status-only marker (parity with EnvironmentThreadState.applyItem); no event to apply. + } else if (this.#activeThread !== null) { + const result = applyThreadDetailEvent(this.#activeThread, item.event); + this.#activeThread = + result.kind === "updated" + ? result.thread + : result.kind === "deleted" + ? null + : this.#activeThread; + this.#activeThreadSequence = item.event.sequence; + } + if (this.#activeThread !== null) { + for (const resolve of this.#threadWaiters) resolve(this.#activeThread); + this.#threadWaiters.clear(); + } + this.#emitThread(); + }), + ), + Effect.tapCause((cause) => + Effect.sync(() => this.#log(`thread stream failed id=${threadId} ${cause}`)), + ), + ); + this.#threadFiber = this.#runtime.runFork(stream); + } + + async #loadThreadSnapshot(threadId: ThreadId): Promise { + const startedAt = Date.now(); + if (this.#httpBaseUrl === null) throw new Error("T3 Code is not connected."); + const url = new URL( + `/api/orchestration/threads/${encodeURIComponent(threadId)}`, + this.#httpBaseUrl, + ); + const headers = + this.#bearerToken === null ? {} : { authorization: `Bearer ${this.#bearerToken}` }; + const response = await globalThis.fetch(url, { headers }); + if (!response.ok) { + throw new Error(`Could not load the T3 Code thread (HTTP ${response.status}).`); + } + const decode = Schema.decodeUnknownSync( + Schema.fromJsonString(OrchestrationThreadDetailSnapshot), + ); + const snapshot = decode(await response.text()); + this.#activeThread = snapshot.thread; + this.#activeThreadSequence = snapshot.snapshotSequence; + this.#log( + `thread HTTP complete in ${Date.now() - startedAt}ms id=${threadId} messages=${snapshot.thread.messages.length} sequence=${snapshot.snapshotSequence}`, + ); + for (const resolve of this.#threadWaiters) resolve(this.#activeThread); + this.#threadWaiters.clear(); + this.#emitThread(); + } + + #emitThread(): void { + for (const listener of this.#listeners) listener(this.#activeThread); + } + + #emitConnection(connected: boolean): void { + for (const listener of this.#connectionListeners) listener(connected); + } + + async #stopThreadSubscription(): Promise { + if (this.#threadFiber === null) return; + await this.#runtime.runPromise(Fiber.interrupt(this.#threadFiber)); + this.#threadFiber = null; + } + + async #closeConnection(): Promise { + await this.#stopThreadSubscription(); + await this.#stopVcsStatusSubscription(); + if (this.#usageFiber !== null) { + await this.#runtime.runPromise(Fiber.interrupt(this.#usageFiber)); + this.#usageFiber = null; + } + this.#aiUsage = null; + for (const listener of this.#usageListeners) listener(null); + if (this.#closedFiber !== null) { + await this.#runtime.runPromise(Fiber.interrupt(this.#closedFiber)); + this.#closedFiber = null; + } + if (this.#shellFiber !== null) { + await this.#runtime.runPromise(Fiber.interrupt(this.#shellFiber)); + this.#shellFiber = null; + } + if (this.#scope !== null) { + await this.#runtime.runPromise(Scope.close(this.#scope, Exit.void)); + this.#scope = null; + } + this.#session = null; + this.#activeThread = null; + this.#activeThreadSequence = null; + this.#shell = null; + this.#serverConfig = null; + this.#serverCapabilities = UPSTREAM_SERVER_CAPABILITIES; + this.#httpBaseUrl = null; + this.#bearerToken = null; + this.#connectionKey = ""; + } +} diff --git a/apps/vscode/src/taskPresentation.test.ts b/apps/vscode/src/taskPresentation.test.ts new file mode 100644 index 000000000000..b19287001993 --- /dev/null +++ b/apps/vscode/src/taskPresentation.test.ts @@ -0,0 +1,54 @@ +import { TurnId, type OrchestrationThreadActivity } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { presentTasks } from "./taskPresentation.ts"; + +function plan( + id: string, + turnId: string, + createdAt: string, + steps: ReadonlyArray>, +): OrchestrationThreadActivity { + return { + id, + kind: "turn.plan.updated", + tone: "info", + summary: "Plan updated", + payload: { plan: steps }, + turnId, + createdAt, + } as OrchestrationThreadActivity; +} + +describe("presentTasks", () => { + it("prefers the latest plan for the active turn", () => { + expect( + presentTasks( + [ + plan("old", "turn-1", "2026-07-11T00:00:00.000Z", [ + { step: "Old task", status: "pending" }, + ]), + plan("current", "turn-2", "2026-07-11T00:00:01.000Z", [ + { step: "Ship tasks", status: "inProgress" }, + { step: "Verify", status: "completed" }, + ]), + ], + TurnId.make("turn-2"), + ), + ).toMatchObject({ + tasks: [ + { step: "Ship tasks", status: "inProgress" }, + { step: "Verify", status: "completed" }, + ], + }); + }); + + it("falls back to the most recent plan across previous turns", () => { + expect( + presentTasks( + [plan("old", "turn-1", "2026-07-11T00:00:00.000Z", [{ step: "Persist" }])], + TurnId.make("turn-2"), + )?.tasks, + ).toEqual([{ step: "Persist", status: "pending" }]); + }); +}); diff --git a/apps/vscode/src/taskPresentation.ts b/apps/vscode/src/taskPresentation.ts new file mode 100644 index 000000000000..bc27dcc0ab4a --- /dev/null +++ b/apps/vscode/src/taskPresentation.ts @@ -0,0 +1,55 @@ +import type { OrchestrationThreadActivity, TurnId } from "@t3tools/contracts"; + +export interface PresentedTask { + readonly step: string; + readonly status: "pending" | "inProgress" | "completed"; +} + +export interface PresentedTasks { + readonly explanation: string | null; + readonly createdAt: string; + readonly tasks: ReadonlyArray; +} + +function planFromActivity(activity: OrchestrationThreadActivity): PresentedTasks | null { + if (activity.kind !== "turn.plan.updated") return null; + const payload = + typeof activity.payload === "object" && activity.payload !== null + ? (activity.payload as Record) + : null; + if (!Array.isArray(payload?.plan)) return null; + const tasks: PresentedTask[] = []; + for (const entry of payload.plan) { + if (typeof entry !== "object" || entry === null) continue; + const task = entry as Record; + if (typeof task.step !== "string" || task.step.trim() === "") continue; + tasks.push({ + step: task.step.trim(), + status: task.status === "completed" || task.status === "inProgress" ? task.status : "pending", + }); + } + if (tasks.length === 0) return null; + return { + explanation: typeof payload.explanation === "string" ? payload.explanation : null, + createdAt: activity.createdAt, + tasks, + }; +} + +export function presentTasks( + activities: ReadonlyArray, + latestTurnId: TurnId | null, +): PresentedTasks | null { + const plans = activities + .filter((activity) => activity.kind === "turn.plan.updated") + .toSorted( + (left, right) => + (left.sequence ?? 0) - (right.sequence ?? 0) || + left.createdAt.localeCompare(right.createdAt), + ); + const preferred = + (latestTurnId === null + ? undefined + : plans.findLast((activity) => activity.turnId === latestTurnId)) ?? plans.at(-1); + return preferred === undefined ? null : planFromActivity(preferred); +} diff --git a/apps/vscode/src/threadStatus.test.ts b/apps/vscode/src/threadStatus.test.ts new file mode 100644 index 000000000000..af9419cfb28e --- /dev/null +++ b/apps/vscode/src/threadStatus.test.ts @@ -0,0 +1,52 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { resolveThreadDisplayStatus } from "./threadStatus.ts"; + +describe("resolveThreadDisplayStatus", () => { + it("shows a live running thread as working", () => { + expect( + resolveThreadDisplayStatus({ + latestTurn: { state: "running" }, + session: { status: "running" }, + }), + ).toEqual({ kind: "working", label: "Working" }); + }); + + it("prioritizes an interrupted session over its stale running turn", () => { + expect( + resolveThreadDisplayStatus({ + latestTurn: { state: "running" }, + session: { status: "interrupted" }, + }), + ).toEqual({ kind: "needs-wake-up", label: "Needs wake up" }); + }); + + it("does not wake-require a zombie interrupted session with a completed turn", () => { + expect( + resolveThreadDisplayStatus({ + latestTurn: { state: "completed", completedAt: "2026-07-01T00:00:00.000Z" }, + session: { status: "interrupted", activeTurnId: null }, + }), + ).toEqual({ kind: "completed", label: "Completed" }); + }); + + it("shows a settled turn as completed", () => { + expect( + resolveThreadDisplayStatus({ + latestTurn: { state: "completed" }, + session: { status: "ready" }, + }), + ).toEqual({ kind: "completed", label: "Completed" }); + }); + + it("shows plan ready over working when a plan is actionable", () => { + expect( + resolveThreadDisplayStatus({ + latestTurn: { state: "running" }, + session: { status: "running" }, + interactionMode: "plan", + hasActionableProposedPlan: true, + }), + ).toEqual({ kind: "plan-ready", label: "Plan Ready" }); + }); +}); diff --git a/apps/vscode/src/threadStatus.ts b/apps/vscode/src/threadStatus.ts new file mode 100644 index 000000000000..8e63239bdaea --- /dev/null +++ b/apps/vscode/src/threadStatus.ts @@ -0,0 +1,71 @@ +import type { OrchestrationLatestTurnState, OrchestrationSessionStatus } from "@t3tools/contracts"; +import { shouldShowPlanReadyStatus } from "@t3tools/shared/proposedPlan"; +import { sessionNeedsWakeUp } from "@t3tools/shared/sessionWake"; + +export type ThreadDisplayStatusKind = + | "working" + | "completed" + | "needs-wake-up" + | "connecting" + | "needs-attention" + | "plan-ready" + | "error" + | "ready"; + +export interface ThreadDisplayStatus { + readonly kind: ThreadDisplayStatusKind; + readonly label: string; +} + +export interface ThreadStatusSource { + readonly latestTurn: null | { + readonly state: OrchestrationLatestTurnState; + readonly completedAt?: string | null; + }; + readonly session: null | { + readonly status: OrchestrationSessionStatus; + readonly activeTurnId?: string | null; + }; + readonly hasPendingApprovals?: boolean; + readonly hasPendingUserInput?: boolean; + readonly interactionMode?: string | null; + readonly hasActionableProposedPlan?: boolean; +} + +export function resolveThreadDisplayStatus(source: ThreadStatusSource): ThreadDisplayStatus { + if (source.hasPendingApprovals || source.hasPendingUserInput) { + return { kind: "needs-attention", label: "Needs attention" }; + } + if ( + shouldShowPlanReadyStatus({ + interactionMode: source.interactionMode, + hasPendingUserInput: Boolean(source.hasPendingUserInput), + hasActionableProposedPlan: Boolean(source.hasActionableProposedPlan), + }) + ) { + return { kind: "plan-ready", label: "Plan Ready" }; + } + if ( + sessionNeedsWakeUp({ + sessionStatus: source.session?.status ?? null, + activeTurnId: source.session?.activeTurnId ?? null, + latestTurnState: source.latestTurn?.state ?? null, + latestTurnCompletedAt: source.latestTurn?.completedAt ?? null, + }) + ) { + return { kind: "needs-wake-up", label: "Needs wake up" }; + } + if (source.session?.status === "starting") { + return { kind: "connecting", label: "Connecting" }; + } + if (source.session?.status === "running" || source.latestTurn?.state === "running") { + return { kind: "working", label: "Working" }; + } + if (source.session?.status === "error" || source.latestTurn?.state === "error") { + return { kind: "error", label: "Error" }; + } + if (source.latestTurn?.state === "completed") { + return { kind: "completed", label: "Completed" }; + } + return { kind: "ready", label: "Ready" }; +} diff --git a/apps/vscode/src/threadWebUrl.test.ts b/apps/vscode/src/threadWebUrl.test.ts new file mode 100644 index 000000000000..d5518db83629 --- /dev/null +++ b/apps/vscode/src/threadWebUrl.test.ts @@ -0,0 +1,20 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { threadWebUrl } from "./threadWebUrl.ts"; + +describe("threadWebUrl", () => { + it("opens a thread through the connected environment web origin", () => { + expect( + threadWebUrl( + "https://t3vm.tail86038f.ts.net/api/orchestration?ignored=yes#old", + "efdbe462-3d2c-43d6-b18e-0b27b8df3836", + ), + ).toBe("https://t3vm.tail86038f.ts.net/?thread=efdbe462-3d2c-43d6-b18e-0b27b8df3836"); + }); + + it("preserves a proxy origin while replacing its route", () => { + expect(threadWebUrl("https://proxy.example.test/t3/", "thread/id")).toBe( + "https://proxy.example.test/?thread=thread%2Fid", + ); + }); +}); diff --git a/apps/vscode/src/threadWebUrl.ts b/apps/vscode/src/threadWebUrl.ts new file mode 100644 index 000000000000..f3feb483d486 --- /dev/null +++ b/apps/vscode/src/threadWebUrl.ts @@ -0,0 +1,8 @@ +export function threadWebUrl(httpBaseUrl: string, threadId: string): string { + const url = new URL(httpBaseUrl); + url.pathname = "/"; + url.search = ""; + url.searchParams.set("thread", threadId); + url.hash = ""; + return url.toString(); +} diff --git a/apps/vscode/src/toolPresentation.test.ts b/apps/vscode/src/toolPresentation.test.ts new file mode 100644 index 000000000000..64003ce93ea6 --- /dev/null +++ b/apps/vscode/src/toolPresentation.test.ts @@ -0,0 +1,116 @@ +import { type OrchestrationThreadActivity, TurnId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { presentToolCalls } from "./toolPresentation.ts"; + +function activity( + input: Omit, "id" | "kind"> & { + readonly id: string; + readonly kind: string; + }, +): OrchestrationThreadActivity { + return { + tone: "tool", + summary: "Tool call", + payload: {}, + turnId: null, + createdAt: "2026-07-10T00:00:00.000Z", + ...input, + } as OrchestrationThreadActivity; +} + +describe("presentToolCalls", () => { + it("collapses lifecycle updates and retains completed command details", () => { + expect( + presentToolCalls([ + activity({ + id: "start", + kind: "tool.updated", + payload: { itemType: "command_execution", data: { toolCallId: "call-1" } }, + }), + activity({ + id: "done", + kind: "tool.completed", + payload: { + itemType: "command_execution", + title: "Ran command", + data: { toolCallId: "call-1", item: { command: ["vp", "check"] } }, + }, + }), + ]), + ).toEqual([ + expect.objectContaining({ + id: "done", + title: "Ran command", + status: "completed", + preview: "vp check", + detail: "vp check", + }), + ]); + }); + + it("preserves MCP input and result JSON for expansion", () => { + const [tool] = presentToolCalls([ + activity({ + id: "mcp", + kind: "tool.completed", + summary: "t3-code · preview_status", + payload: { + itemType: "mcp_tool_call", + data: { item: { tool: "preview_status", arguments: {}, result: "attached" } }, + }, + }), + ]); + expect(tool?.detail).toContain('"tool": "preview_status"'); + expect(tool?.status).toBe("completed"); + }); + + it("omits non-tool activities", () => { + expect(presentToolCalls([activity({ id: "message", kind: "message.created" })])).toEqual([]); + }); + + it("collects and deduplicates nested changed file paths", () => { + const [tool] = presentToolCalls([ + activity({ + id: "files", + kind: "tool.completed", + summary: "File change", + payload: { + itemType: "file_change", + data: { + item: { + changes: [ + { path: "src/one.ts" }, + { filename: "src/two.ts" }, + { newPath: "src/one.ts" }, + ], + }, + }, + }, + }), + ]); + expect(tool?.changedFiles).toEqual(["src/one.ts", "src/two.ts"]); + expect(tool?.preview).toBe("2 changed files"); + }); + + it("settles orphan tool updates when their turn has completed", () => { + const orphan = activity({ + id: "orphan-progress", + kind: "tool.updated", + turnId: TurnId.make("old-turn"), + summary: "Tool updated", + }); + expect( + presentToolCalls([orphan], { + latestTurn: { turnId: "newer-turn", completedAt: null }, + session: { status: "running", activeTurnId: "newer-turn" }, + })[0]?.status, + ).toBe("completed"); + expect( + presentToolCalls([orphan], { + latestTurn: { turnId: "old-turn", completedAt: null }, + session: { status: "running", activeTurnId: "old-turn" }, + })[0]?.status, + ).toBe("running"); + }); +}); diff --git a/apps/vscode/src/toolPresentation.ts b/apps/vscode/src/toolPresentation.ts new file mode 100644 index 000000000000..e8ba1b6884e7 --- /dev/null +++ b/apps/vscode/src/toolPresentation.ts @@ -0,0 +1,198 @@ +import type { OrchestrationThreadActivity } from "@t3tools/contracts"; + +export interface PresentedToolCall { + readonly id: string; + readonly createdAt: string; + readonly title: string; + readonly itemType: string | null; + readonly status: "running" | "completed" | "failed" | "stopped"; + readonly preview: string | null; + readonly detail: string | null; + readonly changedFiles: ReadonlyArray; +} + +export interface ToolPresentationContext { + readonly latestTurn: null | { + readonly turnId: string; + readonly completedAt: string | null; + }; + readonly session: null | { + readonly status: string; + readonly activeTurnId: string | null; + }; +} + +function record(value: unknown): Record | null { + return typeof value === "object" && value !== null && !Array.isArray(value) + ? (value as Record) + : null; +} + +function text(value: unknown): string | null { + return typeof value === "string" && value.trim() !== "" ? value.trim() : null; +} + +function commandText(value: unknown): string | null { + if (typeof value === "string") return text(value); + if (!Array.isArray(value)) return null; + const parts = value.filter((part): part is string => typeof part === "string"); + return parts.length === value.length && parts.length > 0 ? parts.join(" ") : null; +} + +function toolCallId(payload: Record): string | null { + return text(record(payload.data)?.toolCallId) ?? text(payload.toolCallId); +} + +function toolCommand(payload: Record): string | null { + const data = record(payload.data); + const item = record(data?.item); + const input = record(item?.input); + const result = record(item?.result); + return ( + commandText(item?.command) ?? + commandText(input?.command) ?? + commandText(result?.command) ?? + commandText(data?.command) + ); +} + +function rawOutputDetail(payload: Record): string | null { + const rawOutput = record(record(payload.data)?.rawOutput); + if (rawOutput === null) return null; + const totalFiles = typeof rawOutput.totalFiles === "number" ? rawOutput.totalFiles : null; + if (totalFiles !== null) { + return `${totalFiles} file${totalFiles === 1 ? "" : "s"}${rawOutput.truncated === true ? "+" : ""}`; + } + return text(rawOutput.content) ?? text(rawOutput.stdout); +} + +function collectChangedFiles(value: unknown, target: string[], seen: Set, depth = 0): void { + if (depth > 4 || target.length >= 12) return; + if (Array.isArray(value)) { + for (const entry of value) collectChangedFiles(entry, target, seen, depth + 1); + return; + } + const data = record(value); + if (data === null) return; + for (const key of ["path", "filePath", "relativePath", "filename", "newPath", "oldPath"]) { + const path = text(data[key]); + if (path !== null && !seen.has(path)) { + seen.add(path); + target.push(path); + } + } + for (const key of [ + "item", + "result", + "input", + "data", + "changes", + "files", + "edits", + "patch", + "patches", + "operations", + ]) { + if (key in data) collectChangedFiles(data[key], target, seen, depth + 1); + } +} + +function changedFiles(payload: Record): ReadonlyArray { + const files: string[] = []; + collectChangedFiles(payload.data, files, new Set()); + return files; +} + +function expandedDetail(payload: Record, command: string | null): string | null { + const data = record(payload.data); + const item = record(data?.item); + const blocks = [command, text(payload.detail), rawOutputDetail(payload)]; + if (text(payload.itemType) === "mcp_tool_call" && item !== null) { + blocks.push(JSON.stringify(item, null, 2)); + } + const unique = [...new Set(blocks.filter((block): block is string => block !== null))]; + return unique.length > 0 ? unique.join("\n\n") : null; +} + +function lifecycleStatus( + activity: OrchestrationThreadActivity, + payload: Record, +): PresentedToolCall["status"] { + const status = text(payload.status)?.toLowerCase(); + if (status === "failed" || status === "declined") return "failed"; + if (status === "stopped") return "stopped"; + if (activity.kind === "tool.completed" || status === "completed") return "completed"; + return "running"; +} + +function present( + activity: OrchestrationThreadActivity, + context?: ToolPresentationContext, +): PresentedToolCall | null { + if (activity.kind !== "tool.updated" && activity.kind !== "tool.completed") return null; + const payload = record(activity.payload) ?? {}; + const command = toolCommand(payload); + const title = text(payload.title) ?? activity.summary.replace(/\s+complete(?:d)?$/iu, "").trim(); + const detail = expandedDetail(payload, command); + const files = changedFiles(payload); + const rawPreview = + command ?? + text(payload.detail) ?? + rawOutputDetail(payload) ?? + (files.length > 0 ? `${files.length} changed file${files.length === 1 ? "" : "s"}` : null); + const preview = rawPreview === title ? null : rawPreview; + const lifecycle = lifecycleStatus(activity, payload); + const turnIsSettled = + lifecycle === "running" && + activity.turnId !== null && + context?.latestTurn !== null && + context?.latestTurn !== undefined && + (activity.turnId !== context.latestTurn.turnId || + (context.latestTurn.completedAt !== null && + !( + context.session?.status === "running" && context.session.activeTurnId === activity.turnId + ))); + return { + id: activity.id, + createdAt: activity.createdAt, + title, + itemType: text(payload.itemType), + status: turnIsSettled ? "completed" : lifecycle, + preview, + detail, + changedFiles: files, + }; +} + +export function presentToolCalls( + activities: ReadonlyArray, + context?: ToolPresentationContext, +): ReadonlyArray { + const presented: Array = []; + for (const activity of [...activities].toSorted((left, right) => { + if (left.sequence !== undefined && right.sequence !== undefined) { + return left.sequence - right.sequence; + } + return left.createdAt.localeCompare(right.createdAt); + })) { + const tool = present(activity, context); + if (tool === null) continue; + const payload = record(activity.payload) ?? {}; + const id = toolCallId(payload); + const collapseKey = id === null ? `${tool.itemType ?? ""}\u001f${tool.title}` : `id:${id}`; + const previous = presented.at(-1); + if (previous?.collapseKey === collapseKey && previous.status === "running") { + presented[presented.length - 1] = { + ...previous, + ...tool, + preview: tool.preview ?? previous.preview, + detail: tool.detail ?? previous.detail, + changedFiles: [...new Set([...previous.changedFiles, ...tool.changedFiles])], + collapseKey, + }; + } else { + presented.push({ ...tool, collapseKey }); + } + } + return presented.map(({ collapseKey: _collapseKey, ...tool }) => tool); +} diff --git a/apps/vscode/src/usagePresentation.test.ts b/apps/vscode/src/usagePresentation.test.ts new file mode 100644 index 000000000000..372b9fbac388 --- /dev/null +++ b/apps/vscode/src/usagePresentation.test.ts @@ -0,0 +1,81 @@ +import type { AiUsageSnapshot, OrchestrationThreadActivity } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + compareModelUsage, + compactUsageSummary, + deriveContextWindowUsage, + usageForModel, +} from "./usagePresentation.ts"; + +describe("usage presentation", () => { + it("derives the latest context window percentage", () => { + const activities = [ + { + kind: "context-window.updated", + payload: { usedTokens: 50_000, maxTokens: 200_000, totalProcessedTokens: 80_000 }, + }, + ] as OrchestrationThreadActivity[]; + expect(deriveContextWindowUsage(activities)).toMatchObject({ + usedTokens: 50_000, + maxTokens: 200_000, + usedPercentage: 25, + totalProcessedTokens: 80_000, + }); + }); + + it("maps models to their provider limits", () => { + const snapshot = { + available: true, + items: [ + { + provider: "codex", + ok: true, + windows: [ + { id: "5h", label: "5h", percent: 20 }, + { id: "weekly", label: "Weekly", percent: 65 }, + ], + }, + ], + } as AiUsageSnapshot; + const usage = usageForModel(snapshot, "codex", "gpt-5"); + expect(compactUsageSummary(usage)).toBe("5h 20% · Weekly 65%"); + }); + + it("detects when models under one driver use different plans", () => { + const snapshot = { + available: true, + items: [ + { provider: "opencode", ok: true, windows: [{ id: "weekly", label: "Go", percent: 20 }] }, + { provider: "zai", ok: true, windows: [{ id: "weekly", label: "z.ai", percent: 70 }] }, + ], + } as AiUsageSnapshot; + expect( + compareModelUsage(snapshot, [ + { driver: "opencode", model: "opencode-go/kimi-k2.5" }, + { driver: "opencode", model: "zai-coding-plan/glm-5" }, + ]), + ).toEqual({ + summaries: ["Go 20%", "z.ai 70%"], + commonSummary: null, + varies: true, + }); + }); + + it("collapses matching model limits into one provider summary", () => { + const snapshot = { + available: true, + items: [{ provider: "codex", ok: true, windows: [{ id: "5h", label: "5h", percent: 30 }] }], + } as AiUsageSnapshot; + expect( + compareModelUsage(snapshot, [ + { driver: "codex", model: "gpt-5.6" }, + { driver: "codex", model: "gpt-5.5" }, + ]), + ).toEqual({ + summaries: ["5h 30%", "5h 30%"], + commonSummary: "5h 30%", + varies: false, + }); + }); +}); diff --git a/apps/vscode/src/usagePresentation.ts b/apps/vscode/src/usagePresentation.ts new file mode 100644 index 000000000000..430090f9ca32 --- /dev/null +++ b/apps/vscode/src/usagePresentation.ts @@ -0,0 +1,105 @@ +import type { + AiUsageProviderStatus, + AiUsageSnapshot, + AiUsageWindow, + OrchestrationThreadActivity, +} from "@t3tools/contracts"; + +export interface ContextWindowUsage { + readonly usedTokens: number; + readonly maxTokens: number | null; + readonly usedPercentage: number | null; + readonly totalProcessedTokens: number | null; + readonly compactsAutomatically: boolean; +} + +function finiteNumber(value: unknown): number | null { + return typeof value === "number" && Number.isFinite(value) ? value : null; +} + +export function deriveContextWindowUsage( + activities: ReadonlyArray, +): ContextWindowUsage | null { + for (let index = activities.length - 1; index >= 0; index -= 1) { + const activity = activities[index]; + if (activity?.kind !== "context-window.updated") continue; + const payload = + typeof activity.payload === "object" && activity.payload !== null + ? (activity.payload as Record) + : null; + const usedTokens = finiteNumber(payload?.usedTokens); + if (usedTokens === null || usedTokens < 0) continue; + const maxTokensValue = finiteNumber(payload?.maxTokens); + const maxTokens = maxTokensValue !== null && maxTokensValue > 0 ? maxTokensValue : null; + return { + usedTokens, + maxTokens, + usedPercentage: maxTokens === null ? null : Math.min(100, (usedTokens / maxTokens) * 100), + totalProcessedTokens: finiteNumber(payload?.totalProcessedTokens), + compactsAutomatically: payload?.compactsAutomatically === true, + }; + } + return null; +} + +export function usageProviderForModel(driver: string, model: string): string | null { + if (driver === "codex") return "codex"; + if (driver === "claudeAgent") return "claude"; + if (driver === "cursor") return "cursor"; + if (driver === "grok") return "grok"; + if (driver === "opencode") return model.startsWith("zai-coding-plan/") ? "zai" : "opencode"; + return null; +} + +export function usageForModel( + snapshot: AiUsageSnapshot | null, + driver: string, + model: string, +): AiUsageProviderStatus | null { + if (snapshot?.available !== true) return null; + const provider = usageProviderForModel(driver, model); + return snapshot.items.find((item) => item.provider === provider) ?? null; +} + +export function formatUsageWindow(window: AiUsageWindow): string { + if (typeof window.percent === "number") return `${window.label} ${Math.round(window.percent)}%`; + if (typeof window.used === "number") { + return `${window.label} ${window.unit === "$" ? `$${window.used.toFixed(2)}` : window.used}`; + } + return window.label; +} + +export function compactUsageSummary(item: AiUsageProviderStatus | null): string { + if (item === null) return ""; + return item.windows + .filter((window) => typeof window.percent === "number" || typeof window.used === "number") + .slice(0, 3) + .map(formatUsageWindow) + .join(" · "); +} + +export interface ModelUsageTarget { + readonly driver: string; + readonly model: string; +} + +export interface ComparedModelUsage { + readonly summaries: ReadonlyArray; + readonly commonSummary: string | null; + readonly varies: boolean; +} + +export function compareModelUsage( + snapshot: AiUsageSnapshot | null, + models: ReadonlyArray, +): ComparedModelUsage { + const summaries = models.map((model) => + compactUsageSummary(usageForModel(snapshot, model.driver, model.model)), + ); + const distinct = new Set(summaries); + return { + summaries, + commonSummary: distinct.size === 1 ? (summaries[0] ?? null) : null, + varies: distinct.size > 1, + }; +} diff --git a/apps/vscode/src/userInputPresentation.ts b/apps/vscode/src/userInputPresentation.ts new file mode 100644 index 000000000000..580ec3a9be7b --- /dev/null +++ b/apps/vscode/src/userInputPresentation.ts @@ -0,0 +1,4 @@ +export { + deriveResolvedUserInputTranscripts as presentResolvedUserInputs, + type ResolvedUserInputTranscript as PresentedResolvedUserInput, +} from "@t3tools/shared/userInputTranscript"; diff --git a/apps/vscode/src/webview.ts b/apps/vscode/src/webview.ts new file mode 100644 index 000000000000..1ed6fe05ccb1 --- /dev/null +++ b/apps/vscode/src/webview.ts @@ -0,0 +1,2360 @@ +/* oxlint-disable unicorn/require-post-message-target-origin -- VS Code's postMessage API has no targetOrigin argument. */ +// @effect-diagnostics globalDate:off globalTimers:off +import DOMPurify from "dompurify"; +import { marked } from "marked"; +import type { + AiUsageSnapshot, + AiUsageWindow, + ServerHostResourceSnapshot, +} from "@t3tools/contracts"; +import { + formatHostResourceBytes, + formatHostResourcePercent, + getHostResourceMetrics, + getHostResourceRatioPressure, +} from "@t3tools/client-runtime/state/hostResourcePresentation"; +import { + EMPTY_COMPOSER_INPUT_HISTORY, + navigateComposerInputHistory, + pushComposerInputHistory, + recallComposerInputHistory, + resolveComposerInputHistoryKeyAction, + seedComposerInputHistoryFromConversation, + type ComposerInputHistoryState, +} from "@t3tools/shared/composerInputHistory"; +import type { ChangeRequestIndicator } from "@t3tools/shared/sourceControl"; +import { sendEntersSteeringQueue } from "@t3tools/shared/chatList"; + +import { conversationRenderRevision } from "./conversationRevision.ts"; +import { splitEditorContext } from "./editorContext.ts"; +import { compareModelUsage, usageForModel } from "./usagePresentation.ts"; +import { renderProviderIcon } from "./providerIcon.ts"; + +interface VsCodeApi { + readonly postMessage: (message: unknown) => void; +} + +declare function acquireVsCodeApi(): VsCodeApi; + +interface ViewThread { + readonly id: string; + readonly title: string; + readonly model: string; + readonly status: ThreadDisplayStatus; +} + +interface ThreadDisplayStatus { + readonly kind: + | "working" + | "completed" + | "needs-wake-up" + | "connecting" + | "needs-attention" + | "plan-ready" + | "error" + | "ready"; + readonly label: string; +} + +interface ViewProposedPlan { + readonly id: string; + readonly planMarkdown: string; + readonly createdAt: string; + readonly implementedAt: string | null; +} + +interface ViewActiveProposedPlan { + readonly id: string; + readonly planMarkdown: string; + readonly title: string; + readonly createdAt: string; +} + +interface ViewQueuedMessage { + readonly messageId: string; + readonly text: string; + readonly attachmentCount: number; + readonly queuedAt: string; + /** Local-only: not yet acknowledged by the server as a queue entry. */ + readonly pending?: boolean; +} + +interface ViewMessage { + readonly id: string; + readonly role: "user" | "assistant" | "system"; + readonly text: string; + readonly streaming: boolean; + readonly createdAt: string; + readonly attachments: ReadonlyArray<{ + readonly id: string; + readonly name: string; + readonly mimeType: string; + readonly previewUrl: string | null; + }>; +} + +interface ViewToolCall { + readonly id: string; + readonly createdAt: string; + readonly title: string; + readonly itemType: string | null; + readonly status: "running" | "completed" | "failed" | "stopped"; + readonly preview: string | null; + readonly detail: string | null; + readonly changedFiles: ReadonlyArray; +} + +interface ViewResolvedUserInput { + readonly activityId: string; + readonly createdAt: string; + readonly answers: ReadonlyArray<{ + readonly header: string; + readonly question: string; + readonly answer: string; + }>; +} + +interface ViewPendingApproval { + readonly kind: "approval"; + readonly requestId: string; + readonly requestKind: "command" | "file-read" | "file-change"; + readonly detail: string | null; +} + +interface ViewPendingUserInput { + readonly kind: "user-input"; + readonly requestId: string; + readonly questions: ReadonlyArray<{ + readonly id: string; + readonly header: string; + readonly question: string; + readonly multiSelect?: boolean; + readonly options: ReadonlyArray<{ readonly label: string; readonly description: string }>; + }>; +} + +interface ViewState { + readonly busy: boolean; + readonly error: string | null; + readonly connected: boolean; + readonly supportsQueuedMessages: boolean; + readonly environmentLabel: string; + readonly changeRequest: ChangeRequestIndicator | null; + readonly threads: ReadonlyArray; + readonly activeThread: null | { + readonly id: string; + readonly instanceId: string; + readonly model: string; + readonly options?: ReadonlyArray<{ readonly id: string; readonly value: string | boolean }>; + readonly interactionMode: "default" | "plan"; + readonly status: ThreadDisplayStatus; + readonly turnStartedAt: string | null; + readonly contextWindow: null | { + readonly usedTokens: number; + readonly maxTokens: number | null; + readonly usedPercentage: number | null; + readonly totalProcessedTokens: number | null; + readonly compactsAutomatically: boolean; + }; + readonly messages: ReadonlyArray; + readonly toolCalls: ReadonlyArray; + readonly resolvedUserInputs: ReadonlyArray; + readonly pendingInteractions: ReadonlyArray; + readonly showPlanFollowUp: boolean; + readonly activeProposedPlan: ViewActiveProposedPlan | null; + readonly queuedMessages: ReadonlyArray; + /** Provider session status for queue-by-default prediction (running/starting/…). */ + readonly sessionStatus: string | null; + readonly hasPendingTurnStart: boolean; + readonly proposedPlans: ReadonlyArray; + readonly tasks: null | { + readonly explanation: string | null; + readonly createdAt: string; + readonly tasks: ReadonlyArray<{ + readonly step: string; + readonly status: "pending" | "inProgress" | "completed"; + }>; + }; + }; + readonly models: ReadonlyArray<{ + readonly instanceId: string; + readonly model: string; + readonly driver: string; + readonly providerLabel: string; + readonly modelLabel: string; + readonly optionDescriptors: ReadonlyArray< + | { + readonly id: string; + readonly label: string; + readonly type: "select"; + readonly currentValue?: string; + readonly options: ReadonlyArray<{ + readonly id: string; + readonly label: string; + readonly isDefault?: boolean; + }>; + } + | { + readonly id: string; + readonly label: string; + readonly type: "boolean"; + readonly currentValue?: boolean; + } + >; + }>; + readonly aiUsage: AiUsageSnapshot | null; + readonly favoriteProviderIds: ReadonlyArray; + readonly favoriteModelKeys: ReadonlyArray; + readonly contextEnabled: boolean; + readonly editorContext: null | { + readonly path: string; + readonly startLine: number; + readonly endLine: number; + readonly kind: "selection" | "cursor-line" | "reference"; + }; +} + +const vscode = acquireVsCodeApi(); +const threads = requiredElement("threads"); +const messages = requiredElement("messages"); +const newActivity = requiredElement("new-activity"); +const newActivityDot = requiredElement("new-activity-dot"); +const newActivityLabel = requiredElement("new-activity-label"); +const threadActions = requiredElement("thread-actions"); +const archiveThread = requiredElement("archive-thread"); +const visitT3 = requiredElement("visit-t3"); +const status = requiredElement("status"); +const queuedMessages = requiredElement("queued-messages"); +const prompt = requiredElement("prompt"); +const slashCommands = requiredElement("slash-commands"); +const send = requiredElement("send"); +const pendingAttachments = requiredElement("pending-attachments"); +const pendingInteractions = requiredElement("pending-interactions"); +const stashControl = requiredElement("stash-control"); +const stashNow = requiredElement("stash-now"); +const stashPopup = requiredElement("stash-popup"); +const stashCount = requiredElement("stash-count"); +const planReady = requiredElement("plan-ready"); +const interactionModeSelect = requiredElement("interaction-mode"); +const contextButton = requiredElement("context"); +const contextLabel = requiredElement("context-label"); +const contextWindowMeter = requiredElement("context-window"); +const contextWindowLabel = requiredElement("context-window-label"); +const changeRequest = requiredElement("change-request"); +const changeRequestLabel = requiredElement("change-request-label"); +const hostResourcesControl = requiredElement("host-resources-control"); +const hostResourcesToggle = requiredElement("host-resources-toggle"); +const hostResourcesDetails = requiredElement("host-resources-details"); +const provider = requiredElement("provider"); +const providerIcon = requiredElement("provider-icon"); +const favoriteProvider = requiredElement("favorite-provider"); +const model = requiredElement("model"); +const favoriteModel = requiredElement("favorite-model"); +const modelOptions = requiredElement("model-options"); +const usageDetails = requiredElement("usage-details"); +const tasksDetails = requiredElement("tasks-details"); +const tasksLabel = requiredElement("tasks-label"); +let currentState: ViewState | null = null; +let promptFocusToRestore: { readonly start: number; readonly end: number } | null = null; +let composerInteractionMode: "default" | "plan" = "default"; +let draftSelection: null | { + instanceId: string; + model: string; + options: Array<{ id: string; value: string | boolean }>; +} = null; +interface PendingImage { + readonly key: string; + readonly type: "image"; + readonly name: string; + readonly mimeType: string; + readonly sizeBytes: number; + readonly dataUrl: string; +} +let pendingImages: PendingImage[] = []; +let usageExpanded = false; +let tasksExpanded = false; +let hasUnreadActivity = false; +let renderedConversationRevision: string | null = null; +let followEndAfterSubmit = false; +let selectedSlashCommand = 0; +/** Prompt history keyed by active thread id (or draft key). Not shared across threads. */ +const inputHistoryByScopeKey = new Map(); +let inputHistoryScopeKey = "__none__"; +let inputHistory: ComposerInputHistoryState = EMPTY_COMPOSER_INPUT_HISTORY; +let editingQueuedMessage: { readonly messageId: string; readonly previousDraft: string } | null = + null; +/** Queued ids currently being steered (chip hidden, optimistic timeline bubble). */ +const steeringQueuedMessageIds = new Set(); +/** Optimistic user rows for in-flight steers, keyed by message id. */ +const optimisticSteeredMessages = new Map(); +/** Local chips for mid-turn sends until the server lists them as queued. */ +const pendingQueuedMessages = new Map(); +/** Last steer attempt — used to roll back optimistic UI when the host rejects it. */ +let pendingSteerMessageId: string | null = null; +interface PromptStashEntry { + readonly id: string; + readonly createdAt: string; + readonly prompt: string; + readonly images: ReadonlyArray>; + readonly droppedImageNames: ReadonlyArray; + readonly providerInstanceId: string | null; + readonly modelSelection: null | { + readonly instanceId: string; + readonly model: string; + readonly options?: ReadonlyArray<{ readonly id: string; readonly value: string | boolean }>; + }; + readonly interactionMode: "default" | "plan"; +} +let promptStash: ReadonlyArray = []; +let pendingStash: { readonly prompt: string; readonly imageKeys: ReadonlyArray } | null = + null; + +function restoreDraftAfterQueuedEdit(): void { + if (editingQueuedMessage === null) return; + prompt.value = editingQueuedMessage.previousDraft; + editingQueuedMessage = null; + inputHistory = { + entries: inputHistory.entries, + browsingIndex: null, + stashedDraft: "", + }; + persistInputHistory(inputHistoryScopeKey, inputHistory); + renderComposerAction(); +} + +/** + * Match web/mobile: dequeue first so the server cannot drain the old queue + * entry while the user is editing, then recall text into the composer. + * Resubmit is a normal send (may re-queue). + */ +function editQueuedMessage(messageId: string, text: string): void { + const previousDraft = editingQueuedMessage?.previousDraft ?? prompt.value; + editingQueuedMessage = { messageId, previousDraft }; + pendingQueuedMessages.delete(messageId); + post({ type: "removeQueuedMessage", messageId }); + inputHistory = recallComposerInputHistory(inputHistory, text, previousDraft); + persistInputHistory(inputHistoryScopeKey, inputHistory); + prompt.value = text; + prompt.focus(); + prompt.setSelectionRange(text.length, text.length); + renderComposerAction(); +} + +function randomClientMessageId(): string { + const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16)); + bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40; + bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80; + const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(""); + return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`; +} + +function settleQueueOverlays(state: ViewState): void { + const serverQueuedIds = new Set( + (state.activeThread?.queuedMessages ?? []).map((message) => message.messageId), + ); + const serverMessageIds = new Set( + (state.activeThread?.messages ?? []).map((message) => message.id), + ); + + for (const messageId of Array.from(pendingQueuedMessages.keys())) { + if (serverQueuedIds.has(messageId) || serverMessageIds.has(messageId) || state.error) { + pendingQueuedMessages.delete(messageId); + } + } + + for (const messageId of Array.from(steeringQueuedMessageIds)) { + const stillQueued = serverQueuedIds.has(messageId); + const persisted = serverMessageIds.has(messageId); + if (persisted || !stillQueued) { + steeringQueuedMessageIds.delete(messageId); + optimisticSteeredMessages.delete(messageId); + if (pendingSteerMessageId === messageId) pendingSteerMessageId = null; + continue; + } + // Steer rejected: host set error and the message is still queued. + if (!state.busy && state.error && pendingSteerMessageId === messageId) { + steeringQueuedMessageIds.delete(messageId); + optimisticSteeredMessages.delete(messageId); + pendingSteerMessageId = null; + } + } +} + +function displayQueuedMessages(state: ViewState): ReadonlyArray { + const server = (state.activeThread?.queuedMessages ?? []).filter( + (message) => !steeringQueuedMessageIds.has(message.messageId), + ); + const pending = [...pendingQueuedMessages.values()].filter( + (message) => + !server.some((entry) => entry.messageId === message.messageId) && + !steeringQueuedMessageIds.has(message.messageId), + ); + return [...pending, ...server]; +} + +function displayTimelineMessages(state: ViewState): ReadonlyArray { + const server = state.activeThread?.messages ?? []; + const serverIds = new Set(server.map((message) => message.id)); + const optimistic = [...optimisticSteeredMessages.values()].filter( + (message) => !serverIds.has(message.id), + ); + if (optimistic.length === 0) return server; + return [...server, ...optimistic].toSorted((left, right) => + left.createdAt.localeCompare(right.createdAt), + ); +} + +function willSendEnterSteeringQueue(state: ViewState | null): boolean { + if (state?.activeThread === null || state?.activeThread === undefined) return false; + if (!state.supportsQueuedMessages) return false; + return sendEntersSteeringQueue({ + hasBootstrap: false, + sessionStatus: state.activeThread.sessionStatus, + hasPendingTurnStart: state.activeThread.hasPendingTurnStart, + }); +} + +function inputHistoryKeyForState(state: ViewState | null): string { + if (state?.activeThread?.id) { + return `thread:${state.activeThread.id}`; + } + if (draftSelection !== null) { + return `draft:${draftSelection.instanceId}:${draftSelection.model}`; + } + return "__none__"; +} + +function persistInputHistory(scopeKey: string, history: ComposerInputHistoryState): void { + if ( + history.entries.length === 0 && + history.browsingIndex === null && + history.stashedDraft.length === 0 + ) { + inputHistoryByScopeKey.delete(scopeKey); + return; + } + inputHistoryByScopeKey.set(scopeKey, history); +} + +function switchInputHistoryScope(nextKey: string): void { + if (nextKey === inputHistoryScopeKey) return; + if (inputHistory.browsingIndex !== null) { + // Restore temporary draft for the thread we're leaving so it is never lost. + prompt.value = inputHistory.stashedDraft; + inputHistory = { + entries: inputHistory.entries, + browsingIndex: null, + stashedDraft: "", + }; + } + persistInputHistory(inputHistoryScopeKey, inputHistory); + inputHistoryScopeKey = nextKey; + inputHistory = inputHistoryByScopeKey.get(nextKey) ?? EMPTY_COMPOSER_INPUT_HISTORY; +} + +const pendingAnswers = new Map>(); +const submittedAnswers = new Map< + string, + Readonly>> +>(); +const submittedApprovals = new Map(); + +const COMMANDS = [ + { name: "/new", description: "Start a new synchronized thread" }, + { name: "/threads", description: "Choose a worktree thread" }, + { name: "/model", description: "Choose the active model" }, + { name: "/plan", description: "Switch to plan mode" }, + { name: "/default", description: "Switch to build mode" }, + { name: "/context", description: "Include or exclude editor context" }, + { name: "/stop", description: "Stop the active turn" }, +] as const; + +marked.setOptions({ + gfm: true, + breaks: false, +}); + +function requiredElement(id: string): A { + const element = document.getElementById(id); + if (element === null) throw new Error(`Missing webview element #${id}.`); + return element as A; +} + +function post(message: unknown): void { + vscode.postMessage(message); +} + +function stashProviderInstanceId(): string | null { + return currentState === null ? null : (currentSelection(currentState)?.instanceId ?? null); +} + +function requestPromptStash(): void { + post({ type: "listPromptStash", providerInstanceId: stashProviderInstanceId() }); +} + +function renderPromptStash(): void { + stashCount.textContent = String(promptStash.length); + stashPopup.replaceChildren(); + if (promptStash.length === 0) { + const empty = document.createElement("div"); + empty.className = "stash-empty"; + empty.textContent = "No stashed prompts for this provider."; + stashPopup.append(empty); + return; + } + for (const entry of promptStash) { + const row = document.createElement("div"); + row.className = "stash-entry"; + const restore = document.createElement("button"); + restore.className = "stash-restore"; + restore.title = "Restore and remove from stash"; + const preview = document.createElement("span"); + preview.className = "stash-preview"; + preview.textContent = entry.prompt.trim() || `${entry.images.length} image(s)`; + const meta = document.createElement("span"); + meta.className = "stash-meta"; + const dropped = + entry.droppedImageNames.length === 0 + ? "" + : ` · ${entry.droppedImageNames.length} image(s) omitted`; + meta.textContent = `${new Date(entry.createdAt).toLocaleString()}${dropped}`; + restore.append(preview, meta); + restore.addEventListener("click", () => post({ type: "restorePromptStash", id: entry.id })); + const remove = document.createElement("button"); + remove.className = "stash-remove"; + remove.textContent = "×"; + remove.title = "Delete stashed prompt"; + remove.addEventListener("click", () => + post({ + type: "removePromptStash", + id: entry.id, + providerInstanceId: stashProviderInstanceId(), + }), + ); + row.append(restore, remove); + stashPopup.append(row); + } +} + +function stashCurrentPrompt(): void { + if (editingQueuedMessage !== null || !hasComposerInput() || currentState === null) return; + const selection = currentSelection(currentState); + const images = uploadImages(); + pendingStash = { prompt: prompt.value, imageKeys: pendingImages.map((image) => image.key) }; + post({ + type: "stashPrompt", + prompt: prompt.value, + images, + providerInstanceId: selection?.instanceId ?? null, + modelSelection: selection, + interactionMode: composerInteractionMode, + }); +} + +function emptyMessage(text: string): HTMLElement { + const element = document.createElement("div"); + element.className = "empty"; + element.textContent = text; + return element; +} + +function formatTokens(value: number | null): string { + if (value === null) return "?"; + if (value < 1_000) return `${Math.round(value)}`; + if (value < 1_000_000) return `${Math.round(value / 1_000)}k`; + return `${(value / 1_000_000).toFixed(1).replace(/\.0$/u, "")}m`; +} + +function formatReset(resetsAt: number | null | undefined): string { + if (typeof resetsAt !== "number") return ""; + const remainingMinutes = Math.max(0, Math.round((resetsAt * 1_000 - Date.now()) / 60_000)); + if (remainingMinutes === 0) return "resetting"; + const days = Math.floor(remainingMinutes / 1_440); + const hours = Math.floor((remainingMinutes % 1_440) / 60); + const minutes = remainingMinutes % 60; + if (days > 0) return `resets in ${days}d ${hours}h`; + if (hours > 0) return `resets in ${hours}h ${minutes}m`; + return `resets in ${minutes}m`; +} + +function usageWindowValue(window: AiUsageWindow): string { + if (typeof window.percent === "number") return `${Math.round(window.percent)}%`; + if (typeof window.used === "number") { + return window.unit === "$" ? `$${window.used.toFixed(2)}` : `${window.used}`; + } + return "—"; +} + +function modelFavoriteKey(instanceId: string, modelSlug: string): string { + return `${instanceId}:${modelSlug}`; +} + +function favoritesFirst(items: ReadonlyArray, isFavorite: (item: A) => boolean): A[] { + return items + .map((item, index) => ({ item, index, favorite: isFavorite(item) })) + .toSorted( + (left, right) => Number(right.favorite) - Number(left.favorite) || left.index - right.index, + ) + .map(({ item }) => item); +} + +function formatElapsed(startedAt: string, nowMs: number): string | null { + const startMs = Date.parse(startedAt); + if (!Number.isFinite(startMs)) return null; + const totalSeconds = Math.max(0, Math.floor((nowMs - startMs) / 1_000)); + const hours = Math.floor(totalSeconds / 3_600); + const minutes = Math.floor((totalSeconds % 3_600) / 60); + const seconds = totalSeconds % 60; + if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`; + if (minutes > 0) return `${minutes}m ${seconds}s`; + return `${seconds}s`; +} + +function renderMarkdown(text: string): HTMLElement { + const content = document.createElement("div"); + content.className = "content markdown-body"; + const parsed = marked.parse(text, { async: false }); + content.innerHTML = DOMPurify.sanitize(parsed, { + USE_PROFILES: { html: true }, + ADD_ATTR: ["target", "rel"], + }); + + for (const anchor of content.querySelectorAll("a[href]")) { + anchor.rel = "noreferrer noopener"; + anchor.addEventListener("click", (event) => { + event.preventDefault(); + post({ type: "openLink", href: anchor.getAttribute("href") ?? "" }); + }); + } + + for (const code of content.querySelectorAll("code:not(pre code)")) { + const href = code.textContent?.trim() ?? ""; + if (!/^https?:\/\/\S+$/iu.test(href)) continue; + const anchor = document.createElement("a"); + anchor.href = href; + anchor.rel = "noreferrer noopener"; + anchor.className = "inline-code-link"; + anchor.addEventListener("click", (event) => { + event.preventDefault(); + post({ type: "openLink", href }); + }); + code.before(anchor); + anchor.append(code); + } + + for (const pre of content.querySelectorAll("pre")) { + const code = pre.querySelector("code"); + if (code === null) continue; + const wrapper = document.createElement("div"); + wrapper.className = "code-block"; + const header = document.createElement("div"); + header.className = "code-header"; + const language = [...code.classList] + .find((name) => name.startsWith("language-")) + ?.slice("language-".length); + const label = document.createElement("span"); + label.textContent = language ?? "code"; + const copy = document.createElement("button"); + copy.className = "copy-code"; + copy.textContent = "Copy"; + copy.title = "Copy code"; + copy.addEventListener("click", () => { + post({ type: "copyText", text: code.textContent ?? "" }); + copy.textContent = "Copied"; + globalThis.setTimeout(() => { + copy.textContent = "Copy"; + }, 1_200); + }); + header.append(label, copy); + pre.before(wrapper); + wrapper.append(header, pre); + } + + for (const table of content.querySelectorAll("table")) { + const wrapper = document.createElement("div"); + wrapper.className = "table-scroll"; + table.before(wrapper); + wrapper.append(table); + } + return content; +} + +function renderMessage(message: ViewMessage): HTMLElement { + const wrapper = document.createElement("article"); + wrapper.className = `message ${message.role}`; + wrapper.setAttribute("aria-label", `${message.role} message`); + const parsedContext = splitEditorContext(message.text); + const attachmentOnlyText = parsedContext.text.startsWith( + "[User attached one or more images without additional text.", + ); + const content = renderMarkdown( + attachmentOnlyText && message.attachments.length > 0 ? "" : parsedContext.text, + ); + if (message.streaming) content.classList.add("streaming"); + wrapper.append(content); + if (parsedContext.references.length > 0) { + const references = document.createElement("div"); + references.className = "context-references"; + for (const reference of parsedContext.references) { + const chip = document.createElement("button"); + chip.className = "context-reference"; + chip.textContent = `▱ ${reference.path} · ${reference.detail}`; + chip.title = `Open ${reference.path}`; + chip.addEventListener("click", () => + post({ type: "openEditorContext", path: reference.path, detail: reference.detail }), + ); + references.append(chip); + } + wrapper.append(references); + } + if (message.attachments.length > 0) { + const attachments = document.createElement("div"); + attachments.className = "attachments"; + for (const attachment of message.attachments) { + const link = document.createElement("a"); + link.className = "attachment"; + link.title = attachment.name; + if (attachment.previewUrl !== null) { + link.href = attachment.previewUrl; + link.addEventListener("click", (event) => { + event.preventDefault(); + post({ type: "openLink", href: attachment.previewUrl }); + }); + const image = document.createElement("img"); + image.src = attachment.previewUrl; + image.alt = attachment.name; + image.loading = "lazy"; + link.append(image); + } + const name = document.createElement("span"); + name.className = "attachment-name"; + name.textContent = + attachment.previewUrl === null ? `Loading ${attachment.name}…` : attachment.name; + link.append(name); + attachments.append(link); + } + wrapper.append(attachments); + } + return wrapper; +} + +function toolIcon(itemType: string | null): string { + if (itemType === "command_execution") return ">_"; + if (itemType === "file_change") return "±"; + if (itemType === "web_search") return "⌕"; + if (itemType === "image_view") return "◉"; + return "⌘"; +} + +function renderToolCall(tool: ViewToolCall): HTMLElement { + const wrapper = document.createElement("details"); + wrapper.className = `tool-call ${tool.status}`; + wrapper.open = false; + const summary = document.createElement("summary"); + const icon = document.createElement("span"); + icon.className = "tool-call-icon"; + icon.textContent = toolIcon(tool.itemType); + const title = document.createElement("span"); + title.className = "tool-call-title"; + title.textContent = tool.title; + const preview = document.createElement("span"); + preview.className = "tool-call-preview"; + preview.textContent = tool.preview === null ? "" : ` · ${tool.preview.replace(/\s+/gu, " ")}`; + const state = document.createElement("span"); + state.className = "tool-call-state"; + state.textContent = + tool.status === "completed" + ? "✓" + : tool.status === "running" + ? "●" + : tool.status === "stopped" + ? "■" + : "×"; + summary.append(icon, title, preview, state); + wrapper.append(summary); + if (tool.detail !== null) { + const detail = document.createElement("pre"); + detail.className = "tool-call-detail"; + detail.textContent = tool.detail; + wrapper.append(detail); + } + if (tool.changedFiles.length > 0) { + const files = document.createElement("div"); + files.className = "tool-changed-files"; + for (const path of tool.changedFiles) { + const button = document.createElement("button"); + button.className = "tool-changed-file"; + button.title = `Open ${path}`; + button.textContent = path; + button.addEventListener("click", () => + post({ type: "openEditorContext", path, detail: "changed file" }), + ); + files.append(button); + } + wrapper.append(files); + } + if (tool.detail === null && tool.changedFiles.length === 0) { + wrapper.classList.add("not-expandable"); + summary.addEventListener("click", (event) => event.preventDefault()); + } + return wrapper; +} + +function renderToolCallGroup(tools: ReadonlyArray): HTMLElement { + if (tools.length === 1) return renderToolCall(tools[0]!); + const group = document.createElement("details"); + group.className = "tool-call-group"; + // Tool output is intentionally opt-in. Live status updates rebuild the + // timeline, so never infer expansion from running state or viewport entry. + group.open = false; + const summary = document.createElement("summary"); + const running = tools.filter((tool) => tool.status === "running").length; + const failed = tools.filter((tool) => tool.status === "failed").length; + const state = running > 0 ? `${running} running` : failed > 0 ? `${failed} failed` : "Completed"; + summary.textContent = `${tools.length} tool calls · ${state}`; + const body = document.createElement("div"); + body.className = "tool-call-group-body"; + body.append(...tools.map(renderToolCall)); + group.append(summary, body); + return group; +} + +function renderResolvedUserInput(input: ViewResolvedUserInput): HTMLElement { + const wrapper = document.createElement("section"); + wrapper.className = "message user user-input-response"; + wrapper.setAttribute("aria-label", "Your answers"); + + for (const entry of input.answers) { + const answer = document.createElement("div"); + answer.className = "user-input-response-item"; + const question = document.createElement("div"); + question.className = "user-input-response-question"; + question.textContent = entry.question; + const value = document.createElement("div"); + value.className = "user-input-response-answer"; + value.textContent = entry.answer; + answer.append(question, value); + wrapper.append(answer); + } + return wrapper; +} + +function approvalLabel(kind: ViewPendingApproval["requestKind"]): string { + if (kind === "command") return "Command approval"; + if (kind === "file-read") return "File-read approval"; + return "File-change approval"; +} + +function renderApproval(interaction: ViewPendingApproval): HTMLElement { + const card = document.createElement("section"); + card.className = "interaction-card approval-card"; + const heading = document.createElement("div"); + heading.className = "interaction-heading"; + heading.textContent = approvalLabel(interaction.requestKind); + card.append(heading); + const submitted = submittedApprovals.get(interaction.requestId); + if (submitted !== undefined) { + heading.textContent = "Approval response submitted"; + const detail = document.createElement("div"); + detail.className = "interaction-detail"; + detail.textContent = submitted; + card.append(detail); + return card; + } + if (interaction.detail !== null) { + const detail = document.createElement("div"); + detail.className = "interaction-detail"; + detail.textContent = interaction.detail; + card.append(detail); + } + const actions = document.createElement("div"); + actions.className = "interaction-actions"; + for (const [label, decision, className] of [ + ["Deny", "decline", ""], + ["Allow for session", "acceptForSession", ""], + ["Allow", "accept", "allow"], + ] as const) { + const button = document.createElement("button"); + button.textContent = label; + button.className = className; + button.addEventListener("click", () => { + submittedApprovals.set(interaction.requestId, label); + if (currentState !== null) renderPendingInteractions(currentState); + post({ type: "approvalResponse", requestId: interaction.requestId, decision }); + }); + actions.append(button); + } + card.append(actions); + return card; +} + +function renderUserInput(interaction: ViewPendingUserInput): HTMLElement { + const card = document.createElement("section"); + card.className = "interaction-card user-input-card"; + const heading = document.createElement("div"); + heading.className = "interaction-heading"; + heading.textContent = "Input requested"; + card.append(heading); + const submitted = submittedAnswers.get(interaction.requestId); + if (submitted !== undefined) { + heading.textContent = "Input submitted"; + for (const question of interaction.questions) { + const answer = submitted[question.id]; + const row = document.createElement("div"); + row.className = "interaction-detail"; + row.textContent = `${question.header}: ${Array.isArray(answer) ? answer.join(", ") : String(answer ?? "")}`; + card.append(row); + } + return card; + } + const answers = pendingAnswers.get(interaction.requestId) ?? {}; + pendingAnswers.set(interaction.requestId, answers); + for (const question of interaction.questions) { + const group = document.createElement("fieldset"); + group.className = "interaction-question-group"; + const legend = document.createElement("legend"); + legend.textContent = question.header; + const questionText = document.createElement("div"); + questionText.className = "interaction-question"; + questionText.textContent = question.question; + group.append(legend, questionText); + for (const option of question.options) { + const label = document.createElement("label"); + label.className = "interaction-option"; + const input = document.createElement("input"); + input.type = question.multiSelect === true ? "checkbox" : "radio"; + input.name = `${interaction.requestId}:${question.id}`; + const current = answers[question.id]; + input.checked = Array.isArray(current) + ? current.includes(option.label) + : current === option.label; + input.addEventListener("change", () => { + if (question.multiSelect === true) { + const selected = Array.isArray(answers[question.id]) + ? [...(answers[question.id] as string[])] + : []; + answers[question.id] = input.checked + ? [...new Set([...selected, option.label])] + : selected.filter((value) => value !== option.label); + } else if (input.checked) { + answers[question.id] = option.label; + } + }); + const copy = document.createElement("span"); + copy.textContent = option.label; + const description = document.createElement("small"); + description.textContent = option.description; + copy.append(description); + label.append(input, copy); + group.append(label); + } + const custom = document.createElement("input"); + custom.className = "interaction-custom"; + custom.placeholder = "Other…"; + custom.value = + typeof answers[question.id] === "string" && + !question.options.some((option) => option.label === answers[question.id]) + ? (answers[question.id] as string) + : ""; + custom.addEventListener("input", () => { + if (custom.value.trim() !== "") answers[question.id] = custom.value.trim(); + else delete answers[question.id]; + }); + group.append(custom); + card.append(group); + } + const actions = document.createElement("div"); + actions.className = "interaction-actions"; + const submit = document.createElement("button"); + submit.className = "allow"; + submit.textContent = "Submit"; + submit.addEventListener("click", () => { + const complete = interaction.questions.every((question) => { + const answer = answers[question.id]; + return typeof answer === "string" ? answer.trim() !== "" : (answer?.length ?? 0) > 0; + }); + if (!complete) return; + submittedAnswers.set(interaction.requestId, { ...answers }); + if (currentState !== null) renderPendingInteractions(currentState); + post({ type: "userInputResponse", requestId: interaction.requestId, answers }); + }); + actions.append(submit); + card.append(actions); + return card; +} + +function renderPendingInteractions(state: ViewState): void { + const activeIds = new Set( + (state.activeThread?.pendingInteractions ?? []).map((interaction) => interaction.requestId), + ); + for (const requestId of submittedAnswers.keys()) { + if (!activeIds.has(requestId)) submittedAnswers.delete(requestId); + } + for (const requestId of submittedApprovals.keys()) { + if (!activeIds.has(requestId)) submittedApprovals.delete(requestId); + } + pendingInteractions.replaceChildren( + ...(state.activeThread?.pendingInteractions ?? []).map((interaction) => + interaction.kind === "approval" ? renderApproval(interaction) : renderUserInput(interaction), + ), + ); +} + +function renderTasks(state: ViewState): void { + const presented = state.activeThread?.tasks ?? null; + tasksDetails.replaceChildren(); + if (presented === null) { + tasksLabel.textContent = "Tasks"; + const empty = document.createElement("div"); + empty.className = "tasks-empty"; + empty.textContent = "No task list for this thread yet."; + tasksDetails.append(empty); + return; + } + const completed = presented.tasks.filter((task) => task.status === "completed").length; + tasksLabel.textContent = `Tasks ${completed}/${presented.tasks.length}`; + if (presented.explanation !== null) { + const explanation = document.createElement("div"); + explanation.className = "tasks-explanation"; + explanation.textContent = presented.explanation; + tasksDetails.append(explanation); + } + const list = document.createElement("ol"); + list.className = "tasks-list"; + for (const task of presented.tasks) { + const item = document.createElement("li"); + item.className = `task-item ${task.status}`; + const icon = document.createElement("span"); + icon.className = "task-icon"; + icon.textContent = task.status === "completed" ? "✓" : task.status === "inProgress" ? "◔" : "·"; + const text = document.createElement("span"); + text.textContent = task.step; + item.append(icon, text); + list.append(item); + } + tasksDetails.append(list); +} + +function isMessagesAtEnd(): boolean { + return messages.scrollHeight - messages.scrollTop - messages.clientHeight <= 1; +} + +function activityRevision(thread: ViewState["activeThread"]): string { + if (thread === null) return ""; + const lastMessage = thread.messages.at(-1); + return JSON.stringify({ + messageCount: thread.messages.length, + lastMessage: lastMessage + ? { id: lastMessage.id, text: lastMessage.text, streaming: lastMessage.streaming } + : null, + toolCalls: thread.toolCalls.map(({ id, status, preview, detail, changedFiles }) => ({ + id, + status, + preview, + detail, + changedFiles, + })), + resolvedUserInputCount: thread.resolvedUserInputs.length, + lastResolvedUserInput: thread.resolvedUserInputs.at(-1) ?? null, + proposedPlanCount: thread.proposedPlans.length, + lastProposedPlan: thread.proposedPlans.at(-1) ?? null, + queuedMessages: thread.queuedMessages, + }); +} + +function conversationRevision(state: ViewState): string { + return conversationRenderRevision({ + draft: draftSelection !== null, + thread: + state.activeThread === null + ? null + : { + id: state.activeThread.id, + // Include optimistic steers so Send now redraws the timeline. + messages: displayTimelineMessages(state), + toolCalls: state.activeThread.toolCalls, + resolvedUserInputs: state.activeThread.resolvedUserInputs, + proposedPlans: state.activeThread.proposedPlans, + }, + }); +} + +function syncNewActivityButton(): void { + const atEnd = isMessagesAtEnd(); + if (atEnd) hasUnreadActivity = false; + newActivity.hidden = atEnd; + newActivityDot.hidden = !hasUnreadActivity; + newActivityLabel.textContent = hasUnreadActivity ? "New activity" : "Scroll to latest"; + newActivity.setAttribute( + "aria-label", + hasUnreadActivity ? "New activity. Scroll to latest" : "Scroll to latest", + ); +} + +function render(next: ViewState): void { + const previous = currentState; + const previousThreadId = previous?.activeThread?.id ?? null; + const nextThreadId = next.activeThread?.id ?? null; + const threadChanged = previousThreadId !== nextThreadId; + if (threadChanged) { + steeringQueuedMessageIds.clear(); + optimisticSteeredMessages.clear(); + pendingQueuedMessages.clear(); + pendingSteerMessageId = null; + } + settleQueueOverlays(next); + const nextConversationRevision = conversationRevision(next); + const conversationChanged = renderedConversationRevision !== nextConversationRevision; + renderedConversationRevision = nextConversationRevision; + const shouldFollowEnd = followEndAfterSubmit || threadChanged || isMessagesAtEnd(); + followEndAfterSubmit = false; + const previousScrollTop = messages.scrollTop; + if ( + !threadChanged && + !shouldFollowEnd && + activityRevision(previous?.activeThread ?? null) !== activityRevision(next.activeThread) + ) { + hasUnreadActivity = true; + } + if (threadChanged) hasUnreadActivity = false; + currentState = next; + threads.replaceChildren(); + if (draftSelection !== null) { + const draft = document.createElement("option"); + draft.textContent = "New thread"; + draft.value = "__draft__"; + draft.selected = true; + threads.append(draft); + for (const thread of next.threads) { + const option = document.createElement("option"); + option.value = thread.id; + option.textContent = `${thread.title} · ${thread.status.label}`; + threads.append(option); + } + } else if (next.threads.length === 0) { + const option = document.createElement("option"); + option.textContent = "No threads for this worktree"; + option.value = ""; + threads.append(option); + } else { + for (const thread of next.threads) { + const option = document.createElement("option"); + option.value = thread.id; + option.textContent = `${thread.title} · ${thread.status.label}`; + option.selected = thread.id === next.activeThread?.id; + threads.append(option); + } + } + threads.disabled = next.busy; + if (next.activeThread !== null) { + composerInteractionMode = next.activeThread.interactionMode; + } + switchInputHistoryScope(inputHistoryKeyForState(next)); + renderActiveStatus(next); + renderPlanReady(next); + renderPendingInteractions(next); + renderTasks(next); + renderComposerAction(); + + if (conversationChanged) { + messages.replaceChildren(); + if (draftSelection !== null) { + messages.append(emptyMessage("Choose a provider and model, then send your first message.")); + } else if ( + next.activeThread === null || + (displayTimelineMessages(next).length === 0 && + next.activeThread.toolCalls.length === 0 && + next.activeThread.resolvedUserInputs.length === 0 && + next.activeThread.proposedPlans.length === 0) + ) { + messages.append( + emptyMessage( + next.activeThread === null + ? "Create or select a thread for this worktree." + : "Start a conversation in this synchronized thread.", + ), + ); + } else { + const timeline = [ + ...displayTimelineMessages(next).map((message) => ({ + kind: "message" as const, + createdAt: message.createdAt, + order: 0, + element: renderMessage(message), + })), + ...next.activeThread.toolCalls.map((tool) => ({ + kind: "tool" as const, + createdAt: tool.createdAt, + order: 1, + tool, + })), + ...next.activeThread.resolvedUserInputs.map((input) => ({ + kind: "input" as const, + createdAt: input.createdAt, + order: 2, + element: renderResolvedUserInput(input), + })), + ...next.activeThread.proposedPlans.map((plan) => ({ + kind: "plan" as const, + createdAt: plan.createdAt, + order: 1.5, + element: renderProposedPlan(plan), + })), + ].toSorted( + (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order, + ); + const elements: HTMLElement[] = []; + for (let index = 0; index < timeline.length; index += 1) { + const item = timeline[index]!; + if (item.kind !== "tool") { + elements.push(item.element); + continue; + } + const tools = [item.tool]; + while (timeline[index + 1]?.kind === "tool") { + index += 1; + tools.push( + (timeline[index] as Extract<(typeof timeline)[number], { kind: "tool" }>).tool, + ); + } + elements.push(renderToolCallGroup(tools)); + } + messages.append(...elements); + } + messages.scrollTop = shouldFollowEnd ? messages.scrollHeight : previousScrollTop; + } + syncNewActivityButton(); + + const editorContext = next.editorContext; + contextButton.classList.toggle("excluded", !next.contextEnabled); + contextButton.title = next.contextEnabled + ? "Exclude active editor context" + : "Include active editor context"; + contextButton.setAttribute("aria-pressed", String(next.contextEnabled)); + const contextDescription = + editorContext === null + ? "No active editor" + : editorContext.kind === "selection" + ? `${editorContext.endLine - editorContext.startLine + 1} lines selected` + : `${editorContext.path}:${editorContext.startLine}`; + contextLabel.textContent = next.contextEnabled + ? contextDescription + : `Excluded · ${contextDescription}`; + renderContextWindow(next); + renderChangeRequest(next); + const selection = currentSelection(next); + provider.replaceChildren(); + model.replaceChildren(); + if (selection === null) { + const providerOption = document.createElement("option"); + providerOption.textContent = next.environmentLabel; + providerOption.value = ""; + provider.append(providerOption); + const modelOption = document.createElement("option"); + modelOption.textContent = "Select a thread"; + modelOption.value = ""; + model.append(modelOption); + } else { + const providers = new Map(); + for (const candidate of next.models) { + if (!providers.has(candidate.instanceId)) providers.set(candidate.instanceId, candidate); + } + const favoriteProviderIds = new Set(next.favoriteProviderIds); + for (const [instanceId, candidate] of favoritesFirst([...providers.entries()], ([instanceId]) => + favoriteProviderIds.has(instanceId), + )) { + const option = document.createElement("option"); + option.value = instanceId; + const instanceModels = next.models.filter((model) => model.instanceId === instanceId); + const comparedUsage = compareModelUsage(next.aiUsage, instanceModels); + const usage = + draftSelection === null + ? "" + : comparedUsage.varies + ? "Limits vary by model" + : (comparedUsage.commonSummary ?? ""); + option.textContent = `${candidate.providerLabel}${usage === "" ? "" : ` · ${usage}`}`; + option.selected = instanceId === selection.instanceId; + provider.append(option); + } + const favoriteModelKeys = new Set(next.favoriteModelKeys); + const selectedProviderModels = favoritesFirst( + next.models.filter((candidate) => candidate.instanceId === selection.instanceId), + (candidate) => favoriteModelKeys.has(modelFavoriteKey(candidate.instanceId, candidate.model)), + ); + const comparedUsage = compareModelUsage(next.aiUsage, selectedProviderModels); + for (const [index, candidate] of selectedProviderModels.entries()) { + const option = document.createElement("option"); + option.value = candidate.model; + const modelUsage = comparedUsage.varies + ? (comparedUsage.summaries[index] ?? "Usage unavailable") + : ""; + option.textContent = `${candidate.modelLabel}${modelUsage === "" ? "" : ` · ${modelUsage}`}`; + option.selected = candidate.model === selection.model; + model.append(option); + } + } + renderModelOptions(next); + renderUsageDetails(next); + renderProviderIdentity(next); + renderFavoriteControls(next); + provider.disabled = selection === null || draftSelection === null || next.busy; + model.disabled = selection === null || next.busy; + send.disabled = next.busy; + archiveThread.disabled = + next.busy || next.activeThread === null || next.activeThread.status.kind === "working"; + visitT3.disabled = !next.connected || next.activeThread === null; + syncPromptDisabled(next.busy); + renderComposerAction(); + renderQueuedMessages(next); +} + +function renderQueuedMessages(state: ViewState): void { + settleQueueOverlays(state); + queuedMessages.replaceChildren(); + for (const message of displayQueuedMessages(state)) { + const row = document.createElement("div"); + row.className = message.pending ? "queued-message queued-message-pending" : "queued-message"; + row.title = message.text; + + const icon = document.createElement("span"); + icon.className = "queued-message-icon"; + icon.textContent = "↳"; + + const text = document.createElement("span"); + text.className = "queued-message-text"; + text.textContent = + message.text.trim() || + `${message.attachmentCount} attachment${message.attachmentCount === 1 ? "" : "s"}`; + + const steer = document.createElement("button"); + steer.type = "button"; + steer.textContent = "Send now"; + steer.title = "Send now, interrupting the current step"; + steer.ariaLabel = "Send queued message now"; + // Pending local chips wait for server ack; in-flight steers are already + // out of this list. Don't blanket-disable on global busy (web/mobile). + steer.disabled = message.pending === true || steeringQueuedMessageIds.has(message.messageId); + steer.addEventListener("click", () => { + if (message.pending || steeringQueuedMessageIds.has(message.messageId)) return; + const steeredAt = new Date().toISOString(); + steeringQueuedMessageIds.add(message.messageId); + pendingSteerMessageId = message.messageId; + optimisticSteeredMessages.set(message.messageId, { + id: message.messageId, + role: "user", + text: message.text, + streaming: false, + createdAt: steeredAt, + attachments: [], + }); + post({ type: "steerQueuedMessage", messageId: message.messageId }); + // Force conversation redraw so the optimistic bubble appears. + if (currentState) { + renderedConversationRevision = null; + render(currentState); + } + }); + + const edit = document.createElement("button"); + edit.type = "button"; + edit.textContent = "Edit"; + edit.title = "Remove from queue and edit in composer"; + edit.ariaLabel = "Edit queued message"; + edit.disabled = message.pending === true; + edit.addEventListener("click", () => editQueuedMessage(message.messageId, message.text)); + + row.append(icon, text, steer, edit); + queuedMessages.append(row); + } +} + +/** + * Disabling a focused element blurs it, and the browser never gives that focus + * back. Every `#run` on the extension side publishes `busy: true` and then + * `busy: false` a moment later, so without this a background action silently + * drops the caret mid-sentence and keystrokes go nowhere — a disabled textarea + * looks identical to an enabled one. + */ +function syncPromptDisabled(busy: boolean): void { + if (prompt.disabled === busy) return; + if (busy) { + promptFocusToRestore = + document.activeElement === prompt + ? { start: prompt.selectionStart, end: prompt.selectionEnd } + : null; + prompt.disabled = true; + return; + } + prompt.disabled = false; + if (promptFocusToRestore === null) return; + const { start, end } = promptFocusToRestore; + promptFocusToRestore = null; + prompt.focus(); + prompt.setSelectionRange(start, end); +} + +messages.addEventListener("scroll", syncNewActivityButton, { passive: true }); +newActivity.addEventListener("click", () => { + hasUnreadActivity = false; + messages.scrollTo({ top: messages.scrollHeight, behavior: "smooth" }); + syncNewActivityButton(); +}); + +function renderFavoriteControls(state: ViewState): void { + const selection = currentSelection(state); + favoriteProvider.disabled = selection === null; + favoriteModel.disabled = selection === null; + const providerActive = + selection !== null && state.favoriteProviderIds.includes(selection.instanceId); + const modelActive = + selection !== null && + state.favoriteModelKeys.includes(modelFavoriteKey(selection.instanceId, selection.model)); + for (const [button, active, noun] of [ + [favoriteProvider, providerActive, "provider"], + [favoriteModel, modelActive, "model"], + ] as const) { + button.textContent = active ? "★" : "☆"; + button.classList.toggle("active", active); + button.title = `${active ? "Remove" : "Add"} ${noun} ${active ? "from" : "to"} favorites`; + button.setAttribute("aria-label", button.title); + } +} + +function renderActiveStatus(state: ViewState): void { + const activeStatus = draftSelection === null ? state.activeThread?.status : undefined; + status.className = state.error === null ? (activeStatus?.kind ?? "") : "error"; + if (state.error !== null) { + status.textContent = state.error; + return; + } + if (state.busy) { + status.textContent = "Synchronizing…"; + return; + } + if (activeStatus === undefined) { + status.textContent = ""; + return; + } + if (activeStatus.kind === "working") { + const elapsed = state.activeThread?.turnStartedAt + ? formatElapsed(state.activeThread.turnStartedAt, Date.now()) + : null; + status.textContent = elapsed === null ? "Working…" : `Working for ${elapsed}`; + return; + } + if (activeStatus.kind === "plan-ready") { + status.textContent = "Plan Ready"; + return; + } + status.textContent = activeStatus.kind === "connecting" ? "Connecting…" : activeStatus.label; +} + +function renderProviderIdentity(state: ViewState): void { + const candidate = selectedModelCandidate(state); + if (candidate === undefined) { + providerIcon.replaceChildren(); + return; + } + renderProviderIcon(providerIcon, candidate.driver, candidate.providerLabel); + providerIcon.title = candidate.providerLabel; +} + +function renderContextWindow(state: ViewState): void { + const usage = draftSelection === null ? state.activeThread?.contextWindow : null; + if (usage == null) { + contextWindowMeter.hidden = true; + return; + } + contextWindowMeter.hidden = false; + const percent = Math.max(0, Math.min(100, usage.usedPercentage ?? 0)); + contextWindowMeter.style.setProperty("--context-percent", `${percent * 3.6}deg`); + contextWindowMeter.classList.toggle("critical", percent >= 90); + contextWindowLabel.textContent = + usage.usedPercentage === null ? formatTokens(usage.usedTokens) : `${Math.round(percent)}%`; + const details = [ + `Context: ${formatTokens(usage.usedTokens)}${usage.maxTokens === null ? "" : ` / ${formatTokens(usage.maxTokens)}`}`, + ]; + if (usage.totalProcessedTokens !== null) { + details.push(`Total processed: ${formatTokens(usage.totalProcessedTokens)}`); + } + if (usage.compactsAutomatically) details.push("Automatic compaction enabled"); + contextWindowMeter.title = details.join("\n"); + contextWindowMeter.setAttribute("aria-label", details.join(". ")); +} + +function renderChangeRequest(state: ViewState): void { + const indicator = state.changeRequest; + changeRequest.hidden = indicator === null; + if (indicator === null) return; + changeRequest.className = indicator.state; + changeRequest.title = `${indicator.tooltip}\nClick to open`; + changeRequest.setAttribute("aria-label", changeRequest.title); + changeRequestLabel.textContent = `#${indicator.number}`; +} + +function hostResourceMetricElement( + metric: ReturnType[number], +): HTMLElement { + const ratio = metric.ratio === null ? 0 : Math.min(1, Math.max(0, metric.ratio)); + const element = document.createElement("span"); + element.className = `host-metric ${getHostResourceRatioPressure(ratio)}`; + element.setAttribute("aria-label", metric.description); + const meter = document.createElement("span"); + meter.className = "host-metric-meter"; + const fill = document.createElement("span"); + fill.className = "host-metric-fill"; + fill.style.height = `${ratio * 100}%`; + meter.append(fill); + const label = document.createElement("span"); + label.textContent = metric.label; + const value = document.createElement("span"); + value.textContent = metric.value; + element.append(meter, label, value); + return element; +} + +function renderHostResources(snapshot: ServerHostResourceSnapshot | null): void { + hostResourcesToggle.hidden = snapshot === null || snapshot.status === "unavailable"; + if (snapshot === null || snapshot.status === "unavailable") return; + hostResourcesToggle.replaceChildren( + ...getHostResourceMetrics(snapshot).map(hostResourceMetricElement), + ); + hostResourcesToggle.title = "Host resources — hover for details"; + hostResourcesToggle.setAttribute("aria-label", hostResourcesToggle.title); + const loadAverage = snapshot.loadAverage; + const rows: ReadonlyArray = [ + ["Host", snapshot.hostname ?? currentState?.environmentLabel ?? "Host"], + [ + "CPU", + `${formatHostResourcePercent(snapshot.cpuPercent)} across ${snapshot.logicalCores ?? "—"} logical cores`, + ], + [ + "Memory", + `${formatHostResourceBytes(snapshot.memoryUsedBytes)} / ${formatHostResourceBytes(snapshot.memoryTotalBytes)} used`, + ], + [ + "Load", + loadAverage + ? `${loadAverage.m1.toFixed(2)} / ${loadAverage.m5.toFixed(2)} / ${loadAverage.m15.toFixed(2)}` + : "—", + ], + ["Updated", new Date(snapshot.checkedAt).toLocaleTimeString()], + ]; + hostResourcesDetails.replaceChildren( + ...rows.flatMap(([label, value]) => { + const labelElement = document.createElement("span"); + labelElement.className = "host-resources-detail-label"; + labelElement.textContent = label; + const valueElement = document.createElement("span"); + valueElement.className = "host-resources-detail-value"; + valueElement.textContent = value; + return [labelElement, valueElement]; + }), + ); +} + +function renderUsageDetails(state: ViewState): void { + usageDetails.replaceChildren(); + const usageToggle = requiredElement("usage-toggle"); + const usageLabel = requiredElement("usage-label"); + usageToggle.style.setProperty("--usage-primary", "0deg"); + usageToggle.style.setProperty("--usage-secondary", "0deg"); + usageToggle.className = ""; + usageToggle.hidden = true; + usageLabel.textContent = "—"; + usageToggle.title = "Provider usage unavailable"; + usageToggle.setAttribute("aria-label", usageToggle.title); + const candidate = selectedModelCandidate(state); + if (candidate === undefined) return; + const usage = usageForModel(state.aiUsage, candidate.driver, candidate.model); + if (usage === null) return; + usageToggle.hidden = false; + usageToggle.title = "Provider usage — hover for details; click to pin"; + usageToggle.setAttribute("aria-label", usageToggle.title); + if (!usage.ok) { + const unavailable = document.createElement("div"); + unavailable.className = "usage-unavailable"; + unavailable.textContent = usage.error ?? "Usage unavailable"; + usageDetails.append(unavailable); + return; + } + const percentages = usage.windows + .map((window) => window.percent) + .filter((percent): percent is number => typeof percent === "number"); + const primary = percentages[0] ?? 0; + const secondary = percentages[1] ?? primary; + const worst = percentages.length > 0 ? Math.max(...percentages) : null; + usageToggle.style.setProperty( + "--usage-primary", + `${Math.max(0, Math.min(100, primary)) * 3.6}deg`, + ); + usageToggle.style.setProperty( + "--usage-secondary", + `${Math.max(0, Math.min(100, secondary)) * 3.6}deg`, + ); + usageToggle.classList.toggle("warning", worst !== null && worst >= 80 && worst < 100); + usageToggle.classList.toggle("critical", worst !== null && worst >= 100); + usageLabel.textContent = worst === null ? "—" : `${Math.round(worst)}%`; + for (const window of usage.windows) { + const row = document.createElement("div"); + row.className = "usage-window"; + const heading = document.createElement("div"); + heading.className = "usage-window-heading"; + const label = document.createElement("span"); + label.textContent = window.label; + const value = document.createElement("span"); + value.textContent = usageWindowValue(window); + heading.append(label, value); + row.append(heading); + if (typeof window.percent === "number") { + const track = document.createElement("div"); + track.className = "usage-track"; + const fill = document.createElement("div"); + fill.className = `usage-fill${window.percent >= 100 ? " critical" : window.percent >= 80 ? " warning" : ""}`; + fill.style.width = `${Math.max(0, Math.min(100, window.percent))}%`; + track.append(fill); + row.append(track); + } + const reset = formatReset(window.resets_at); + if (reset !== "") { + const resetLabel = document.createElement("div"); + resetLabel.className = "usage-reset"; + resetLabel.textContent = reset; + row.append(resetLabel); + } + usageDetails.append(row); + } + if (usage.stale) { + const stale = document.createElement("div"); + stale.className = "usage-unavailable"; + stale.textContent = "Showing last known usage"; + usageDetails.append(stale); + } +} + +function isRunning(): boolean { + return draftSelection === null && currentState?.activeThread?.status.kind === "working"; +} + +function hasComposerInput(): boolean { + return editingQueuedMessage !== null || prompt.value.trim() !== "" || pendingImages.length > 0; +} + +function showPlanFollowUp(): boolean { + return draftSelection === null && currentState?.activeThread?.showPlanFollowUp === true; +} + +function renderComposerAction(): void { + const planFollowUp = showPlanFollowUp(); + const stopping = isRunning() && !hasComposerInput() && !planFollowUp; + stashNow.disabled = editingQueuedMessage !== null || !hasComposerInput(); + send.disabled = false; + if (stopping) { + send.textContent = "Stop"; + send.title = "Stop active turn"; + } else if (planFollowUp) { + send.textContent = prompt.value.trim().length > 0 ? "Refine" : "Implement"; + send.title = + prompt.value.trim().length > 0 ? "Send plan feedback" : "Implement the proposed plan"; + } else { + const unsupportedFollowUp = + isRunning() && hasComposerInput() && !currentState?.supportsQueuedMessages; + send.textContent = isRunning() && hasComposerInput() ? "Queue" : "Send"; + send.title = unsupportedFollowUp + ? "The connected upstream server does not support queued follow-ups" + : isRunning() && hasComposerInput() + ? "Queue message after the active turn" + : "Send message"; + send.disabled = unsupportedFollowUp; + } + send.classList.toggle("stop-action", stopping); + prompt.placeholder = planFollowUp + ? "Add feedback to refine the plan, or leave blank to implement" + : "Ask T3 Code…"; + interactionModeSelect.value = composerInteractionMode; +} + +function renderPlanReady(state: ViewState): void { + planReady.replaceChildren(); + if (!state.activeThread?.showPlanFollowUp || state.activeThread.activeProposedPlan === null) { + return; + } + const badge = document.createElement("span"); + badge.className = "plan-ready-badge"; + badge.textContent = "Plan Ready"; + const title = document.createElement("span"); + title.className = "plan-ready-title"; + title.textContent = state.activeThread.activeProposedPlan.title; + planReady.append(badge, title); +} + +function stripPlanDisplay(planMarkdown: string): string { + const lines = planMarkdown.trimEnd().split(/\r?\n/); + const sourceLines = lines[0] && /^\s{0,3}#{1,6}\s+/.test(lines[0]) ? lines.slice(1) : [...lines]; + while (sourceLines[0]?.trim().length === 0) sourceLines.shift(); + const firstHeadingMatch = sourceLines[0]?.match(/^\s{0,3}#{1,6}\s+(.+)$/); + if (firstHeadingMatch?.[1]?.trim().toLowerCase() === "summary") { + sourceLines.shift(); + while (sourceLines[0]?.trim().length === 0) sourceLines.shift(); + } + return sourceLines.join("\n"); +} + +function renderProposedPlan(plan: ViewProposedPlan): HTMLElement { + const card = document.createElement("div"); + card.className = "plan-card"; + const header = document.createElement("div"); + header.className = "plan-card-header"; + const badge = document.createElement("span"); + badge.className = "plan-card-badge"; + badge.textContent = "Plan"; + const title = document.createElement("span"); + title.className = "plan-card-title"; + title.textContent = + plan.planMarkdown.match(/^\s{0,3}#{1,6}\s+(.+)$/m)?.[1]?.trim() ?? "Proposed plan"; + header.append(badge, title); + card.append(header, renderMarkdown(stripPlanDisplay(plan.planMarkdown))); + return card; +} + +function setComposerInteractionMode(mode: "default" | "plan", persist: boolean): void { + composerInteractionMode = mode; + interactionModeSelect.value = mode; + if (persist && draftSelection === null && currentState?.activeThread !== null) { + post({ type: "setInteractionMode", interactionMode: mode }); + } + renderComposerAction(); +} + +function uploadImages(): Array<{ + type: "image"; + name: string; + mimeType: string; + sizeBytes: number; + dataUrl: string; +}> { + return pendingImages.map(({ type, name, mimeType, sizeBytes, dataUrl }) => ({ + type, + name, + mimeType, + sizeBytes, + dataUrl, + })); +} + +function clearPendingImages(): void { + pendingImages = []; + renderPendingImages(); +} + +function renderPendingImages(): void { + pendingAttachments.replaceChildren(); + for (const image of pendingImages) { + const chip = document.createElement("div"); + chip.className = "pending-attachment"; + const thumbnail = document.createElement("img"); + thumbnail.src = image.dataUrl; + thumbnail.alt = image.name; + const label = document.createElement("span"); + label.textContent = image.name; + const remove = document.createElement("button"); + remove.textContent = "×"; + remove.title = `Remove ${image.name}`; + remove.addEventListener("click", () => { + pendingImages = pendingImages.filter((candidate) => candidate.key !== image.key); + renderPendingImages(); + }); + chip.append(thumbnail, label, remove); + pendingAttachments.append(chip); + } + renderComposerAction(); +} + +function fileDataUrl(file: File): Promise { + return new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.addEventListener("load", () => + typeof reader.result === "string" + ? resolve(reader.result) + : reject(new Error("Invalid image")), + ); + reader.addEventListener("error", () => + reject(reader.error ?? new Error("Could not read image")), + ); + reader.readAsDataURL(file); + }); +} + +async function addClipboardImages(files: ReadonlyArray): Promise { + for (const [index, file] of files.entries()) { + if (!file.type.startsWith("image/")) continue; + pendingImages.push({ + key: `${file.name}:${file.size}:${globalThis.performance.now()}:${index}`, + type: "image", + name: file.name || `pasted-image-${pendingImages.length + 1}.png`, + mimeType: file.type || "image/png", + sizeBytes: file.size, + dataUrl: await fileDataUrl(file), + }); + } + renderPendingImages(); +} + +function currentSelection(state: ViewState) { + if (draftSelection !== null) return draftSelection; + const thread = state.activeThread; + if (thread === null) return null; + return { + instanceId: thread.instanceId, + model: thread.model, + options: [...(thread.options ?? [])], + }; +} + +function selectedModelCandidate(state: ViewState) { + const selection = currentSelection(state); + if (selection === null) return undefined; + return state.models.find( + (candidate) => + candidate.instanceId === selection.instanceId && candidate.model === selection.model, + ); +} + +function selectedOptions(state: ViewState): Array<{ id: string; value: string | boolean }> { + return [...(currentSelection(state)?.options ?? [])]; +} + +function sendModelSelection( + state: ViewState, + options: Array<{ id: string; value: string | boolean }>, +): void { + const selection = currentSelection(state); + if (selection === null) return; + if (draftSelection !== null) { + draftSelection = { ...draftSelection, options }; + renderModelOptions(state); + return; + } + post({ + type: "selectModel", + instanceId: selection.instanceId, + model: selection.model, + options, + }); +} + +function renderModelOptions(state: ViewState): void { + modelOptions.replaceChildren(); + const candidate = selectedModelCandidate(state); + if (candidate === undefined || candidate.optionDescriptors.length === 0) return; + const values = new Map(selectedOptions(state).map((option) => [option.id, option.value])); + for (const descriptor of candidate.optionDescriptors) { + const label = document.createElement("label"); + label.className = "model-option"; + const title = document.createElement("span"); + const optionIdentity = `${descriptor.id} ${descriptor.label}`.toLowerCase(); + const compactIcon = + optionIdentity.includes("service") || optionIdentity.includes("tier") ? "ϟ" : null; + const omitVisibleLabel = optionIdentity.includes("reason"); + title.textContent = compactIcon ?? (omitVisibleLabel ? "" : descriptor.label); + title.hidden = omitVisibleLabel; + title.className = compactIcon === null ? "" : "model-option-icon"; + title.title = descriptor.label; + label.append(title); + if (descriptor.type === "select") { + const select = document.createElement("select"); + select.setAttribute("aria-label", descriptor.label); + select.title = descriptor.label; + for (const choice of descriptor.options) { + const option = document.createElement("option"); + option.value = choice.id; + option.textContent = choice.label; + option.selected = + choice.id === + (values.get(descriptor.id) ?? + descriptor.currentValue ?? + descriptor.options.find((entry) => entry.isDefault)?.id); + select.append(option); + } + select.addEventListener("change", () => { + const options = selectedOptions(state).filter((option) => option.id !== descriptor.id); + options.push({ id: descriptor.id, value: select.value }); + sendModelSelection(state, options); + }); + label.append(select); + } else { + const checkbox = document.createElement("input"); + checkbox.type = "checkbox"; + checkbox.setAttribute("aria-label", descriptor.label); + checkbox.checked = Boolean(values.get(descriptor.id) ?? descriptor.currentValue ?? false); + checkbox.addEventListener("change", () => { + const options = selectedOptions(state).filter((option) => option.id !== descriptor.id); + options.push({ id: descriptor.id, value: checkbox.checked }); + sendModelSelection(state, options); + }); + label.prepend(checkbox); + } + modelOptions.append(label); + } +} + +function submit(): void { + if (editingQueuedMessage !== null) { + // Edit already dequeued; empty cancel restores the previous draft, non-empty + // falls through to a normal send (same as web/mobile). + const text = prompt.value.trim(); + if (text.length === 0) { + restoreDraftAfterQueuedEdit(); + return; + } + editingQueuedMessage = null; + } + const slash = prompt.value.trim(); + if (slash.startsWith("/") && executeSlashCommand(slash)) return; + const planFollowUp = showPlanFollowUp(); + if (isRunning() && hasComposerInput() && !currentState?.supportsQueuedMessages) return; + if (!hasComposerInput() && !planFollowUp) return; + if (isRunning() && !hasComposerInput() && !planFollowUp) { + post({ type: "stop" }); + return; + } + const images = uploadImages(); + const queuesFollowUp = willSendEnterSteeringQueue(currentState) && draftSelection === null; + // Queue-bound sends stay as chips — keep the reader's position (web/mobile). + if (!queuesFollowUp) { + followEndAfterSubmit = true; + hasUnreadActivity = false; + messages.scrollTop = messages.scrollHeight; + syncNewActivityButton(); + } + if (prompt.value.trim().length > 0) { + inputHistory = pushComposerInputHistory(inputHistory, prompt.value); + persistInputHistory(inputHistoryScopeKey, inputHistory); + } + if (draftSelection !== null) { + post({ + type: "sendNewThread", + text: prompt.value, + instanceId: draftSelection.instanceId, + model: draftSelection.model, + options: draftSelection.options, + images, + interactionMode: composerInteractionMode, + }); + return; + } + const messageId = randomClientMessageId(); + if (queuesFollowUp) { + pendingQueuedMessages.set(messageId, { + messageId, + text: prompt.value, + attachmentCount: images.length, + queuedAt: new Date().toISOString(), + pending: true, + }); + if (currentState) renderQueuedMessages(currentState); + } + post({ + type: "send", + text: prompt.value, + images, + interactionMode: composerInteractionMode, + messageId, + }); +} + +function beginNewThread(): void { + if (currentState === null) return; + const active = currentSelection(currentState); + const fallback = currentState.models[0]; + if (active === null && fallback === undefined) return; + draftSelection = active ?? { + instanceId: fallback!.instanceId, + model: fallback!.model, + options: [], + }; + prompt.value = ""; + slashCommands.hidden = true; + render(currentState); + prompt.focus(); +} + +function executeSlashCommand(value: string): boolean { + const command = COMMANDS.find((candidate) => candidate.name === value.toLowerCase()); + if (command === undefined) return false; + prompt.value = ""; + slashCommands.hidden = true; + switch (command.name) { + case "/new": + beginNewThread(); + break; + case "/threads": + threads.focus(); + threads.click(); + break; + case "/model": + model.focus(); + model.click(); + break; + case "/plan": + setComposerInteractionMode("plan", true); + break; + case "/default": + setComposerInteractionMode("default", true); + break; + case "/context": + post({ type: "toggleContext" }); + break; + case "/stop": + post({ type: "stop" }); + break; + } + renderComposerAction(); + return true; +} + +function matchingSlashCommands(): ReadonlyArray<(typeof COMMANDS)[number]> { + const query = prompt.value.trim().toLowerCase(); + if (!query.startsWith("/") || query.includes(" ")) return []; + return COMMANDS.filter((command) => command.name.startsWith(query)); +} + +function renderSlashCommands(): void { + const matching = matchingSlashCommands(); + selectedSlashCommand = Math.min(selectedSlashCommand, Math.max(0, matching.length - 1)); + slashCommands.replaceChildren(); + slashCommands.hidden = matching.length === 0; + for (const [index, command] of matching.entries()) { + const button = document.createElement("button"); + button.className = `slash-command${index === selectedSlashCommand ? " selected" : ""}`; + button.type = "button"; + const name = document.createElement("span"); + name.className = "slash-command-name"; + name.textContent = command.name; + const description = document.createElement("span"); + description.className = "slash-command-description"; + description.textContent = command.description; + button.append(name, description); + button.addEventListener("mousedown", (event) => event.preventDefault()); + button.addEventListener("click", () => executeSlashCommand(command.name)); + slashCommands.append(button); + } +} + +/** + * Anchors a fixed-position popover above its toggle, right-aligned and clamped to + * the viewport. Composer popovers are fixed rather than absolute so they escape + * the composer's overflow. + */ +function positionPopover(toggle: HTMLElement, panel: HTMLElement, maxWidth: number): void { + const viewportPadding = 8; + const width = Math.min(maxWidth, Math.max(0, globalThis.innerWidth - viewportPadding * 2)); + const toggleBounds = toggle.getBoundingClientRect(); + const left = Math.min( + Math.max(viewportPadding, toggleBounds.right - width), + Math.max(viewportPadding, globalThis.innerWidth - width - viewportPadding), + ); + panel.style.width = `${width}px`; + panel.style.left = `${left}px`; + panel.style.bottom = `${Math.max(viewportPadding, globalThis.innerHeight - toggleBounds.top + 7)}px`; +} + +function positionUsageDetails(): void { + positionPopover(requiredElement("usage-toggle"), usageDetails, 270); +} + +function positionTasksDetails(): void { + positionPopover(requiredElement("tasks-toggle"), tasksDetails, 320); +} + +function positionHostResourcesDetails(): void { + positionPopover(hostResourcesToggle, hostResourcesDetails, 260); +} + +window.addEventListener("message", (event: MessageEvent) => { + if (typeof event.data !== "object" || event.data === null || !("type" in event.data)) return; + if (event.data.type === "state" && "state" in event.data) render(event.data.state as ViewState); + if (event.data.type === "hostResources" && "snapshot" in event.data) { + renderHostResources(event.data.snapshot as ServerHostResourceSnapshot | null); + } + if (event.data.type === "promptStash" && "entries" in event.data) { + promptStash = event.data.entries as ReadonlyArray; + renderPromptStash(); + if ("stashed" in event.data && event.data.stashed === true && pendingStash !== null) { + if (prompt.value === pendingStash.prompt) prompt.value = ""; + const stashedKeys = new Set(pendingStash.imageKeys); + pendingImages = pendingImages.filter((image) => !stashedKeys.has(image.key)); + pendingStash = null; + renderPendingImages(); + renderComposerAction(); + } + } + if (event.data.type === "restorePromptStash" && "entry" in event.data) { + const entry = event.data.entry as PromptStashEntry; + prompt.value = entry.prompt; + pendingImages = entry.images.map((image, index) => ({ + ...image, + key: `stash:${entry.id}:${index}`, + })); + setComposerInteractionMode(entry.interactionMode, false); + if (entry.modelSelection !== null && currentState !== null) { + const options = [...(entry.modelSelection.options ?? [])]; + if (draftSelection !== null) { + draftSelection = { ...entry.modelSelection, options }; + render(currentState); + } else { + post({ + type: "selectModel", + instanceId: entry.modelSelection.instanceId, + model: entry.modelSelection.model, + options, + }); + } + } + renderPendingImages(); + renderComposerAction(); + stashControl.open = false; + prompt.focus(); + prompt.setSelectionRange(prompt.value.length, prompt.value.length); + } + if (event.data.type === "sent") { + prompt.value = ""; + clearPendingImages(); + prompt.focus(); + } + if (event.data.type === "sentNewThread") { + draftSelection = null; + prompt.value = ""; + clearPendingImages(); + prompt.focus(); + } + if (event.data.type === "focusComposer") prompt.focus(); +}); +threads.addEventListener("change", () => { + if (threads.value !== "" && threads.value !== "__draft__") { + draftSelection = null; + post({ type: "selectThread", threadId: threads.value }); + } +}); +interactionModeSelect.addEventListener("change", () => { + const mode = interactionModeSelect.value === "plan" ? "plan" : "default"; + setComposerInteractionMode(mode, draftSelection === null); +}); +prompt.addEventListener("input", () => { + renderComposerAction(); +}); +provider.addEventListener("change", () => { + if (draftSelection === null || currentState === null || provider.value === "") return; + const firstModel = currentState.models.find( + (candidate) => candidate.instanceId === provider.value, + ); + if (firstModel === undefined) return; + draftSelection = { instanceId: firstModel.instanceId, model: firstModel.model, options: [] }; + render(currentState); + requestPromptStash(); +}); +stashControl.addEventListener("toggle", () => { + if (stashControl.open) requestPromptStash(); +}); +stashNow.addEventListener("click", stashCurrentPrompt); +model.addEventListener("change", () => { + if (model.value === "" || currentState === null) return; + const selection = currentSelection(currentState); + if (selection === null) return; + if (draftSelection !== null) { + draftSelection = { instanceId: selection.instanceId, model: model.value, options: [] }; + render(currentState); + return; + } + post({ type: "selectModel", instanceId: selection.instanceId, model: model.value, options: [] }); +}); +favoriteProvider.addEventListener("click", () => { + if (currentState === null) return; + const selection = currentSelection(currentState); + if (selection !== null) + post({ type: "toggleProviderFavorite", instanceId: selection.instanceId }); +}); +favoriteModel.addEventListener("click", () => { + if (currentState === null) return; + const selection = currentSelection(currentState); + if (selection !== null) { + post({ + type: "toggleModelFavorite", + modelKey: modelFavoriteKey(selection.instanceId, selection.model), + }); + } +}); +requiredElement("usage-toggle").addEventListener("click", () => { + positionUsageDetails(); + usageExpanded = !usageExpanded; + requiredElement("usage-control").classList.toggle("pinned", usageExpanded); + if (usageExpanded) { + tasksExpanded = false; + requiredElement("tasks-control").classList.remove("pinned"); + } +}); +requiredElement("usage-control").addEventListener("pointerenter", positionUsageDetails); +requiredElement("tasks-toggle").addEventListener("click", () => { + positionTasksDetails(); + tasksExpanded = !tasksExpanded; + requiredElement("tasks-control").classList.toggle("pinned", tasksExpanded); + if (tasksExpanded) { + usageExpanded = false; + requiredElement("usage-control").classList.remove("pinned"); + } +}); +requiredElement("tasks-control").addEventListener("pointerenter", positionTasksDetails); +changeRequest.addEventListener("click", () => { + const url = currentState?.changeRequest?.url; + if (url !== undefined) post({ type: "openLink", href: url }); +}); +// Hovering the gauge steps the host-metrics poll up to a live cadence, matching +// the web client; leaving drops it back to the idle heartbeat. +hostResourcesControl.addEventListener("pointerenter", () => { + positionHostResourcesDetails(); + post({ type: "hostResourceLive", live: true }); +}); +hostResourcesControl.addEventListener("pointerleave", () => { + post({ type: "hostResourceLive", live: false }); +}); +function closeComposerPopovers(): void { + usageExpanded = false; + tasksExpanded = false; + for (const id of ["usage-control", "tasks-control"]) { + const control = requiredElement(id); + control.classList.remove("pinned"); + if (control.contains(document.activeElement)) (document.activeElement as HTMLElement).blur(); + } +} +document.addEventListener("pointerdown", (event) => { + const target = event.target; + if (!(target instanceof Node)) return; + if ( + requiredElement("usage-control").contains(target) || + requiredElement("tasks-control").contains(target) + ) + return; + closeComposerPopovers(); +}); +document.addEventListener("keydown", (event) => { + if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "s") { + event.preventDefault(); + if (hasComposerInput()) stashCurrentPrompt(); + else { + stashControl.open = true; + requestPromptStash(); + } + return; + } + if (event.key === "Escape" && (usageExpanded || tasksExpanded)) { + closeComposerPopovers(); + event.preventDefault(); + } +}); +globalThis.addEventListener("resize", () => { + positionUsageDetails(); + positionTasksDetails(); +}); +requiredElement("new").addEventListener("click", beginNewThread); +requiredElement("refresh").addEventListener("click", () => post({ type: "refresh" })); +visitT3.addEventListener("click", () => { + threadActions.open = false; + post({ type: "visitT3" }); +}); +archiveThread.addEventListener("click", () => { + threadActions.open = false; + post({ type: "archiveThread" }); +}); +contextButton.addEventListener("click", () => post({ type: "toggleContext" })); +send.addEventListener("click", () => { + if (isRunning() && !hasComposerInput()) post({ type: "stop" }); + else submit(); +}); +prompt.addEventListener("input", () => { + selectedSlashCommand = 0; + renderSlashCommands(); + renderComposerAction(); +}); +prompt.addEventListener("paste", (event) => { + const images = [...(event.clipboardData?.files ?? [])].filter((file) => + file.type.startsWith("image/"), + ); + if (images.length === 0) return; + event.preventDefault(); + void addClipboardImages(images); +}); +prompt.addEventListener("keydown", (event) => { + const matching = matchingSlashCommands(); + if (matching.length > 0 && (event.key === "ArrowDown" || event.key === "ArrowUp")) { + event.preventDefault(); + selectedSlashCommand = + (selectedSlashCommand + (event.key === "ArrowDown" ? 1 : -1) + matching.length) % + matching.length; + renderSlashCommands(); + return; + } + if (event.key === "Escape" && !slashCommands.hidden) { + event.preventDefault(); + slashCommands.hidden = true; + return; + } + if (event.key === "ArrowUp" || event.key === "ArrowDown") { + const direction = event.key === "ArrowUp" ? "up" : "down"; + const selectionStart = prompt.selectionStart; + const selectionEnd = prompt.selectionEnd; + const conversationUserTexts = + currentState?.activeThread?.messages + .filter((message) => message.role === "user") + .map((message) => message.text) ?? []; + const historyForNavigation = seedComposerInputHistoryFromConversation( + inputHistory, + conversationUserTexts, + ); + const keyAction = resolveComposerInputHistoryKeyAction({ + direction, + browsing: historyForNavigation.browsingIndex !== null, + text: prompt.value, + cursor: selectionStart, + selectionEnd, + }); + if (keyAction.action === "move-caret") { + event.preventDefault(); + prompt.setSelectionRange(keyAction.cursor, keyAction.cursor); + return; + } + if (keyAction.action === "history") { + const navigation = navigateComposerInputHistory( + historyForNavigation, + direction, + prompt.value, + ); + if (navigation.handled) { + event.preventDefault(); + inputHistory = navigation.state; + persistInputHistory(inputHistoryScopeKey, inputHistory); + prompt.value = navigation.value; + if (editingQueuedMessage !== null && navigation.state.browsingIndex === null) { + editingQueuedMessage = null; + } + const cursor = navigation.value.length; + prompt.setSelectionRange(cursor, cursor); + renderComposerAction(); + return; + } + } + } + if (event.key === "Enter" && !event.shiftKey) { + event.preventDefault(); + if (matching.length > 0) { + executeSlashCommand(matching[selectedSlashCommand]!.name); + return; + } + submit(); + } +}); +post({ type: "ready" }); + +globalThis.setInterval(() => { + if (currentState !== null) renderActiveStatus(currentState); +}, 1_000); diff --git a/apps/vscode/tsconfig.json b/apps/vscode/tsconfig.json new file mode 100644 index 000000000000..b4e09f80a0f8 --- /dev/null +++ b/apps/vscode/tsconfig.json @@ -0,0 +1,8 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "rootDir": "src", + "types": ["vscode", "node"] + }, + "include": ["src"] +} diff --git a/apps/web/package.json b/apps/web/package.json index 16579e730f1b..b84e6592e9a9 100644 --- a/apps/web/package.json +++ b/apps/web/package.json @@ -9,7 +9,7 @@ "build": "vp build", "preview": "vp preview", "typecheck": "tsc --noEmit", - "test": "vp test run --passWithNoTests --project unit" + "test": "vp test run --passWithNoTests --project unit --project unit-isolated" }, "dependencies": { "@base-ui/react": "^1.4.1", diff --git a/apps/web/src/AppRoot.tsx b/apps/web/src/AppRoot.tsx index 857125c9fdaf..6069d785e8a1 100644 --- a/apps/web/src/AppRoot.tsx +++ b/apps/web/src/AppRoot.tsx @@ -3,6 +3,7 @@ import { RouterProvider } from "@tanstack/react-router"; import { ElectronBrowserHost } from "./browser/ElectronBrowserHost"; import { PreviewAutomationHosts } from "./components/preview/PreviewAutomationHosts"; import { QuitHoldOverlay } from "./components/QuitHoldOverlay"; +import { WebUpdateBanner } from "./components/WebUpdateBanner"; import { AppAtomRegistryProvider } from "./rpc/atomRegistry"; import type { AppRouter } from "./router"; @@ -17,6 +18,7 @@ export function AppRoot({ router }: { readonly router: AppRouter }) { + ); diff --git a/apps/web/src/aiUsageState.test.ts b/apps/web/src/aiUsageState.test.ts new file mode 100644 index 000000000000..0c180e91eda5 --- /dev/null +++ b/apps/web/src/aiUsageState.test.ts @@ -0,0 +1,386 @@ +import type { + AiUsageProviderStatus, + AiUsageSnapshot, + ProviderDriverKind, +} from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + formatPaceNote, + formatResetsIn, + formatWindowValue, + isEnforcedUsageWindow, + mapDriverToUsageProvider, + resolveDriverUsage, + resolveDriverUsages, + usageDotFillClass, + usageDotRingColor, + usageMarkerForItem, + usageProviderLabel, + usageProvidersForDriver, + usageRank, + worstUsagePercent, +} from "./aiUsageState"; + +const driver = (value: string) => value as ProviderDriverKind; + +function status(overrides: Partial): AiUsageProviderStatus { + return { provider: "codex", ok: true, windows: [], ...overrides }; +} + +describe("mapDriverToUsageProvider", () => { + it("maps known drivers to daemon provider slugs", () => { + expect(mapDriverToUsageProvider(driver("claudeAgent"), null)).toBe("claude"); + expect(mapDriverToUsageProvider(driver("codex"), null)).toBe("codex"); + expect(mapDriverToUsageProvider(driver("cursor"), null)).toBe("cursor"); + expect(mapDriverToUsageProvider(driver("grok"), null)).toBe("grok"); + expect(mapDriverToUsageProvider(driver("opencode"), "gpt-oss")).toBe("opencode"); + }); + + it("routes zai coding-plan models under opencode to zai, else opencode-go", () => { + expect(mapDriverToUsageProvider(driver("opencode"), "zai-coding-plan/glm-5.2")).toBe("zai"); + expect(mapDriverToUsageProvider(driver("opencode"), undefined)).toBe("opencode"); + expect(mapDriverToUsageProvider(driver("opencode"), "gpt-oss")).toBe("opencode"); + }); + + it("returns null for drivers with no usage feed", () => { + expect(mapDriverToUsageProvider(null, null)).toBeNull(); + expect(mapDriverToUsageProvider(driver("some-fork-driver"), null)).toBeNull(); + }); +}); + +describe("usageMarkerForItem", () => { + it("fills critical when any window is maxed", () => { + expect( + usageMarkerForItem(status({ windows: [{ id: "5h", label: "5h", percent: 100 }] })).fill, + ).toBe("critical"); + // A maxed weekly is a hard block even when the 5-hour bucket is fresh. + expect( + usageMarkerForItem( + status({ + windows: [ + { id: "5h", label: "5h", percent: 0 }, + { id: "weekly", label: "Weekly", percent: 100 }, + ], + }), + ).fill, + ).toBe("critical"); + }); + + it("fills warn when the immediate window crosses the threshold", () => { + expect( + usageMarkerForItem(status({ windows: [{ id: "5h", label: "5h", percent: 82 }] })).fill, + ).toBe("warn"); + }); + + it("does NOT fill from a weekly pace overshoot when the 5-hour window is fresh", () => { + const marker = usageMarkerForItem( + status({ + windows: [ + { id: "5h", label: "5-hour", percent: 0 }, + { + id: "weekly", + label: "Weekly", + percent: 68, + pace: { lasts_to_reset: false, delta_percent: 36 }, + }, + ], + }), + ); + expect(marker.fill).toBe("none"); + expect(marker.outlookAtRisk).toBe(true); + }); + + it("flags a filling weekly window as an outlook risk without escalating fill", () => { + const marker = usageMarkerForItem( + status({ + windows: [ + { id: "5h", label: "5h", percent: 32 }, + { id: "weekly", label: "Weekly", percent: 84 }, + ], + }), + ); + expect(marker.fill).toBe("none"); + expect(marker.outlookAtRisk).toBe(true); + }); + + it("is quiet when comfortably under and on pace", () => { + expect( + usageMarkerForItem( + status({ + windows: [ + { + id: "5h", + label: "5h", + percent: 20, + pace: { lasts_to_reset: true, delta_percent: -5 }, + }, + ], + }), + ), + ).toEqual({ fill: "none", outlookAtRisk: false }); + }); + + it("does not go critical from a drained extra-usage pool (real claude/max feed)", () => { + // The daemon reports the extra-usage buffer as a `monthly` window; it is + // only drawn from once 5h/weekly run out, so 100% there is not a limit. + const marker = usageMarkerForItem( + status({ + provider: "claude", + windows: [ + { id: "5h", label: "5-hour", percent: 18 }, + { id: "weekly", label: "Weekly", percent: 78 }, + { id: "monthly", label: "Extra usage (off)", percent: 100, used: 47.89, unit: "€" }, + ], + }), + ); + expect(marker.fill).toBe("none"); + // Weekly at 78% is still just an outlook concern, not a block. + expect(marker.outlookAtRisk).toBe(true); + }); + + it("ignores daemon-flagged informational pools for fill and outlook", () => { + const marker = usageMarkerForItem( + status({ + provider: "grok", + windows: [ + { id: "weekly", label: "Weekly SuperGrok Heavy", percent: 12 }, + { + id: "monthly", + label: "Monthly (legacy $)", + percent: 100, + unit: "$", + informational: true, + pace: { lasts_to_reset: false, delta_percent: 1 }, + }, + ], + }), + ); + expect(marker).toEqual({ fill: "none", outlookAtRisk: false }); + }); + + it("still goes critical when a real plan window is maxed alongside extras", () => { + expect( + usageMarkerForItem( + status({ + windows: [ + { id: "5h", label: "5-hour", percent: 100 }, + { id: "monthly", label: "Extra usage (off)", percent: 100 }, + ], + }), + ).fill, + ).toBe("critical"); + }); + + it("keeps enforcing money-denominated plan windows", () => { + // opencode-go / cursor bill in $ or requests — those monthly windows are + // the plan, not a buffer behind it. + expect( + usageMarkerForItem( + status({ + provider: "cursor", + windows: [{ id: "monthly", label: "Monthly (billing cycle)", percent: 100, unit: "req" }], + }), + ).fill, + ).toBe("critical"); + }); + + it("is quiet when the provider is not ok", () => { + expect( + usageMarkerForItem(status({ ok: false, windows: [{ id: "5h", label: "5h", percent: 100 }] })), + ).toEqual({ fill: "none", outlookAtRisk: false }); + }); +}); + +describe("worstUsagePercent", () => { + it("returns the max across windows, ignoring non-numeric", () => { + expect( + worstUsagePercent( + status({ + windows: [ + { id: "5h", label: "5h", percent: 32 }, + { id: "weekly", label: "Weekly", percent: 84 }, + { id: "extra", label: "Extra", percent: null }, + ], + }), + ), + ).toBe(84); + }); + + it("skips spend pools so a drained extras buffer is not the worst window", () => { + expect( + worstUsagePercent( + status({ + windows: [ + { id: "5h", label: "5-hour", percent: 18 }, + { id: "monthly", label: "Extra usage (off)", percent: 100 }, + ], + }), + ), + ).toBe(18); + }); +}); + +describe("isEnforcedUsageWindow", () => { + it("treats extra-usage / credit / on-demand buffers and off windows as context", () => { + for (const label of [ + "Extra usage (off)", + "Extra usage", + "Credits", + "On-demand ($)", + "Pay as you go", + "Weekly (off)", + ]) { + expect(isEnforcedUsageWindow({ id: "monthly", label })).toBe(false); + } + expect( + isEnforcedUsageWindow({ id: "monthly", label: "Monthly (legacy $)", informational: true }), + ).toBe(false); + }); + + it("treats real plan windows as enforced", () => { + for (const label of ["5-hour", "Weekly", "Monthly ($)", "Monthly (billing cycle)"]) { + expect(isEnforcedUsageWindow({ id: "weekly", label })).toBe(true); + } + }); +}); + +describe("resolveDriverUsage + usageRank", () => { + const snapshot: AiUsageSnapshot = { + generated_at: null, + worst_percent: 100, + available: true, + items: [ + status({ provider: "claude", windows: [{ id: "weekly", label: "Weekly", percent: 84 }] }), + status({ provider: "codex", windows: [{ id: "5h", label: "5h", percent: 100 }] }), + ], + }; + + it("resolves the item + marker for a mapped driver", () => { + const usage = resolveDriverUsage(snapshot, driver("codex"), null); + expect(usage?.provider).toBe("codex"); + expect(usage?.marker.fill).toBe("critical"); + }); + + it("returns null for unmapped drivers", () => { + expect(resolveDriverUsage(snapshot, driver("some-unknown"), null)).toBeNull(); + }); + + it("ranks by the daemon's item order, trailing unknowns", () => { + expect(usageRank(snapshot, driver("claudeAgent"), null)).toBe(0); + expect(usageRank(snapshot, driver("codex"), null)).toBe(1); + expect(usageRank(snapshot, driver("some-unknown"), null)).toBe(Number.POSITIVE_INFINITY); + }); + + it("returns null / infinity when the snapshot is unavailable", () => { + const down: AiUsageSnapshot = { + generated_at: null, + worst_percent: null, + available: false, + items: [], + }; + expect(resolveDriverUsage(down, driver("codex"), null)).toBeNull(); + expect(usageRank(down, driver("codex"), null)).toBe(Number.POSITIVE_INFINITY); + }); +}); + +describe("opencode hosts opencode-go + z.ai", () => { + const snapshot: AiUsageSnapshot = { + generated_at: null, + worst_percent: 100, + available: true, + items: [ + status({ + provider: "opencode", + windows: [{ id: "weekly", label: "Weekly ($)", percent: 10 }], + }), + status({ provider: "zai", windows: [{ id: "5h", label: "5-hour", percent: 100 }] }), + ], + }; + + it("lists both providers for the opencode driver", () => { + expect(usageProvidersForDriver(driver("opencode"))).toEqual(["opencode", "zai"]); + expect(usageProvidersForDriver(driver("codex"))).toEqual(["codex"]); + expect(usageProvidersForDriver(driver("grok"))).toEqual(["grok"]); + }); + + it("resolves both hosted providers present in the snapshot", () => { + const usages = resolveDriverUsages(snapshot, driver("opencode")); + expect(usages.map((u) => u.provider)).toEqual(["opencode", "zai"]); + expect(usages[1]?.marker.fill).toBe("critical"); + }); + + it("single-resolve honours the active model: z.ai overrides go", () => { + expect( + resolveDriverUsage(snapshot, driver("opencode"), "zai-coding-plan/glm-5.2")?.provider, + ).toBe("zai"); + expect(resolveDriverUsage(snapshot, driver("opencode"), "gpt-oss")?.provider).toBe("opencode"); + }); + + it("labels providers for display", () => { + expect(usageProviderLabel("zai")).toBe("z.ai"); + expect(usageProviderLabel("opencode")).toBe("OpenCode"); + expect(usageProviderLabel("grok")).toBe("Grok"); + expect(usageProviderLabel("codex")).toBe("Codex"); + }); +}); + +describe("usageDotFillClass + usageDotRingColor", () => { + it("maps fill to background tokens", () => { + expect(usageDotFillClass({ fill: "critical", outlookAtRisk: false })).toBe("bg-destructive"); + expect(usageDotFillClass({ fill: "warn", outlookAtRisk: false })).toBe("bg-warning"); + expect(usageDotFillClass({ fill: "none", outlookAtRisk: false })).toBeUndefined(); + }); + + it("uses a neutral dot + ring when only the outlook is at risk", () => { + const marker = { fill: "none", outlookAtRisk: true } as const; + expect(usageDotFillClass(marker)).toBe("bg-muted-foreground/70"); + expect(usageDotRingColor(marker)).toBe("var(--warning)"); + }); + + it("has no ring when the outlook is fine", () => { + expect(usageDotRingColor({ fill: "warn", outlookAtRisk: false })).toBeUndefined(); + }); +}); + +describe("formatting", () => { + it("formats reset-in from epoch seconds", () => { + const now = 1_000_000_000_000; // ms + const nowSec = now / 1000; + expect(formatResetsIn(nowSec + 3600 * 2 + 60 * 5, now)).toBe("2h 5m"); + expect(formatResetsIn(nowSec + 60 * 45, now)).toBe("45m"); + expect(formatResetsIn(nowSec - 10, now)).toBe("resetting"); + expect(formatResetsIn(null, now)).toBeNull(); + }); + + it("formats window values by unit", () => { + expect(formatWindowValue({ id: "5h", label: "5h", percent: 84 })).toBe("84%"); + expect(formatWindowValue({ id: "od", label: "On-demand", used: 3.5, unit: "$" })).toBe("$3.50"); + expect(formatWindowValue({ id: "t", label: "Tokens", used: 1200, unit: "tok" })).toBe( + "1200 tok", + ); + expect(formatWindowValue({ id: "x", label: "x" })).toBe("—"); + }); + + it("formats a runs-out pace note", () => { + expect( + formatPaceNote({ + id: "weekly", + label: "Weekly", + percent: 68, + pace: { lasts_to_reset: false, eta_seconds: 7200, delta_percent: 37 }, + }), + ).toBe("runs out in 2h 0m · +37% vs pace"); + }); + + it("returns null for an on-pace window", () => { + expect( + formatPaceNote({ + id: "5h", + label: "5h", + percent: 20, + pace: { lasts_to_reset: true, delta_percent: 2 }, + }), + ).toBeNull(); + }); +}); diff --git a/apps/web/src/aiUsageState.ts b/apps/web/src/aiUsageState.ts new file mode 100644 index 000000000000..5eedb5382342 --- /dev/null +++ b/apps/web/src/aiUsageState.ts @@ -0,0 +1,32 @@ +/** + * Re-exports the shared pure logic so that existing web imports continue to + * work without changes. The implementation lives in @t3tools/client-runtime so + * it is available to web + mobile (and other clients). + * + * See packages/client-runtime/src/state/aiUsagePresentation.ts for the real + * code and documentation. + */ + +export { + findUsageItem, + formatPaceNote, + formatResetsIn, + formatWindowValue, + hasUsageMarker, + isEnforcedUsageWindow, + mapDriverToUsageProvider, + resolveDriverUsage, + resolveDriverUsages, + type DriverUsage, + type UsageFill, + type UsageMarker, + USAGE_OUTLOOK_PERCENT, + USAGE_WARN_PERCENT, + usageDotFillClass, + usageDotRingColor, + usageMarkerForItem, + usageProviderLabel, + usageProvidersForDriver, + usageRank, + worstUsagePercent, +} from "@t3tools/client-runtime/state/aiUsagePresentation"; diff --git a/apps/web/src/browser/browserSurfaceStore.test.ts b/apps/web/src/browser/browserSurfaceStore.test.ts index 456377a4d641..99b900973df3 100644 --- a/apps/web/src/browser/browserSurfaceStore.test.ts +++ b/apps/web/src/browser/browserSurfaceStore.test.ts @@ -150,18 +150,16 @@ describe("browserSurfaceStore", () => { }); }); - it("hides a surface when its current lease is released", () => { + it("removes a surface entry when its current lease is released", () => { const tabId = "released-browser-surface"; const lease = acquireBrowserSurface(tabId); lease.present({ x: 10, y: 20, width: 900, height: 640 }, true); lease.release(); + // A stale present() from the released lease must not resurrect the entry. lease.present({ x: 0, y: 0, width: 1, height: 1 }, true); - expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toMatchObject({ - visible: false, - owner: null, - }); + expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toBeUndefined(); }); it("keeps the requested layer with the active surface lease", () => { @@ -190,11 +188,6 @@ describe("browserSurfaceStore", () => { fittedLease.release(); - expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toMatchObject({ - fittedSourceContent: null, - fitSourceContent: false, - owner: null, - visible: false, - }); + expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toBeUndefined(); }); }); diff --git a/apps/web/src/browser/browserSurfaceStore.ts b/apps/web/src/browser/browserSurfaceStore.ts index a49154ed8def..5808be0b46ec 100644 --- a/apps/web/src/browser/browserSurfaceStore.ts +++ b/apps/web/src/browser/browserSurfaceStore.ts @@ -188,19 +188,14 @@ export const useBrowserSurfaceStore = create()((set) = set((state) => { const current = state.byTabId[tabId]; if (current?.owner !== owner) return state; - return { - byTabId: { - ...state.byTabId, - [tabId]: { - ...current, - visible: false, - fittedSourceContent: null, - fitSourceContent: false, - updatedAt: Date.now(), - owner: null, - }, - }, - }; + // Delete the entry entirely instead of leaving a released tombstone + // ({ visible: false, owner: null }). Readers only consider `visible` + // entries, so removal is behavior-preserving, and it stops byTabId from + // accumulating one dead entry per preview tab ever opened. A later + // re-claim of the same tabId starts fresh, which is correct since release + // means the surface was torn down. + const { [tabId]: _released, ...byTabId } = state.byTabId; + return { byTabId }; }), })); diff --git a/apps/web/src/browser/browserTargetResolver.test.ts b/apps/web/src/browser/browserTargetResolver.test.ts index c2b3432402ed..02eee09787cb 100644 --- a/apps/web/src/browser/browserTargetResolver.test.ts +++ b/apps/web/src/browser/browserTargetResolver.test.ts @@ -1,9 +1,19 @@ -import { EnvironmentId } from "@t3tools/contracts"; +import { EnvironmentId, PreviewPortUnreachableError } from "@t3tools/contracts"; +import * as Cause from "effect/Cause"; import { beforeEach, describe, expect, it, vi } from "vite-plus/test"; const readPreparedConnection = vi.fn(); +const runAtomCommand = vi.fn(); vi.mock("~/state/session", () => ({ readPreparedConnection })); +vi.mock("@t3tools/client-runtime/state/runtime", async (importOriginal) => ({ + ...(await importOriginal>()), + runAtomCommand, +})); +// The resolver reaches the environment through the app-wide registry; the +// command itself is stubbed above, so the registry only needs to exist. +vi.mock("~/rpc/atomRegistry", () => ({ appAtomRegistry: {} })); +vi.mock("~/state/preview", () => ({ previewEnvironment: { resolvePort: { label: "test" } } })); describe("browser target resolver", () => { beforeEach(() => readPreparedConnection.mockReset()); @@ -168,6 +178,19 @@ describe("browser target resolver", () => { ).toBe("http://localhost:5173/app?x=1#top"); }); + it("maps loopback conversation URLs onto the thread environment host", async () => { + readPreparedConnection.mockReturnValue({ + httpBaseUrl: "http://remote.example.ts.net:3773", + }); + const { resolveDiscoveredServerUrl } = await import("./browserTargetResolver"); + expect( + resolveDiscoveredServerUrl( + EnvironmentId.make("environment-smart"), + "http://127.0.0.1:8765/t3code-fork-synara-comparison.html?view=all#matrix", + ), + ).toBe("http://remote.example.ts.net:8765/t3code-fork-synara-comparison.html?view=all#matrix"); + }); + it("normalizes public URLs without treating them as environment ports", async () => { const { resolveDiscoveredServerUrl } = await import("./browserTargetResolver"); expect(resolveDiscoveredServerUrl(EnvironmentId.make("environment-1"), "example.com/app")).toBe( @@ -348,3 +371,98 @@ describe("browser target resolver", () => { expect(publicHosts.filter((host) => !isPublicFaviconHost(host))).toEqual([]); }); }); + +describe("navigable url resolution", () => { + beforeEach(() => { + readPreparedConnection.mockReset(); + runAtomCommand.mockReset(); + }); + + const succeedWith = (origin: string) => + runAtomCommand.mockResolvedValue({ + _tag: "Success", + value: { origin, strategy: "tailnet-serve", createdExposure: true }, + }); + + it("asks the environment for a reachable origin instead of reusing the port", async () => { + readPreparedConnection.mockReturnValue({ httpBaseUrl: "https://smart.tail.ts.net/" }); + succeedWith("https://smart.tail.ts.net:46545"); + const { resolveNavigableUrl } = await import("./browserTargetResolver"); + + const url = await resolveNavigableUrl(EnvironmentId.make("environment-1"), { + kind: "url", + url: "http://localhost:6545/dashboard?mode=test#results", + }); + + // The serve port and scheme both differ from the requested ones — the exact + // pair the old host-swap guess could not produce. + expect(url).toBe("https://smart.tail.ts.net:46545/dashboard?mode=test#results"); + expect(runAtomCommand.mock.calls[0]?.[2]).toEqual({ + environmentId: "environment-1", + input: { port: 6545, clientBaseUrl: "https://smart.tail.ts.net/" }, + }); + }); + + it("resolves a link already rewritten to the environment host", async () => { + readPreparedConnection.mockReturnValue({ httpBaseUrl: "https://smart.tail.ts.net/" }); + succeedWith("https://smart.tail.ts.net:46545"); + const { resolveNavigableUrl } = await import("./browserTargetResolver"); + + // Chat renders hrefs against the environment host for readability, so the + // click path receives this spelling rather than the localhost one. + expect( + await resolveNavigableUrl(EnvironmentId.make("environment-1"), { + kind: "url", + url: "http://smart.tail.ts.net:6545/", + }), + ).toBe("https://smart.tail.ts.net:46545/"); + }); + + it("never asks about a port a same-machine client already reaches", async () => { + readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://localhost:3773" }); + const { resolveNavigableUrl } = await import("./browserTargetResolver"); + + expect( + await resolveNavigableUrl(EnvironmentId.make("environment-1"), { + kind: "url", + url: "http://localhost:6545/", + }), + ).toBe("http://localhost:6545/"); + expect(runAtomCommand).not.toHaveBeenCalled(); + }); + + it("leaves an unrelated external URL alone", async () => { + readPreparedConnection.mockReturnValue({ httpBaseUrl: "https://smart.tail.ts.net/" }); + const { resolveNavigableUrl } = await import("./browserTargetResolver"); + + expect( + await resolveNavigableUrl(EnvironmentId.make("environment-1"), { + kind: "url", + url: "https://example.com/docs", + }), + ).toBe("https://example.com/docs"); + expect(runAtomCommand).not.toHaveBeenCalled(); + }); + + it("raises the environment's explanation rather than navigating somewhere broken", async () => { + readPreparedConnection.mockReturnValue({ httpBaseUrl: "https://smart.tail.ts.net/" }); + runAtomCommand.mockResolvedValue({ + _tag: "Failure", + cause: Cause.fail( + new PreviewPortUnreachableError({ + port: 6545, + reason: "not-listening", + remedy: "Start the dev server first, then open the port again.", + }), + ), + }); + const { resolveNavigableUrl } = await import("./browserTargetResolver"); + + await expect( + resolveNavigableUrl(EnvironmentId.make("environment-1"), { + kind: "url", + url: "http://localhost:6545/", + }), + ).rejects.toThrow("Start the dev server first"); + }); +}); diff --git a/apps/web/src/browser/browserTargetResolver.ts b/apps/web/src/browser/browserTargetResolver.ts index 4acb1e2b487f..1fda12c2e0db 100644 --- a/apps/web/src/browser/browserTargetResolver.ts +++ b/apps/web/src/browser/browserTargetResolver.ts @@ -3,9 +3,18 @@ import type { EnvironmentId, PreviewUrlResolution, } from "@t3tools/contracts"; +import { PreviewPortUnreachableError } from "@t3tools/contracts"; +import { runAtomCommand, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime"; import { isLoopbackHost, normalizePreviewUrl } from "@t3tools/shared/preview"; -import { isLocalLoopbackHost, isPrivateNetworkHost } from "@t3tools/shared/hostClassification"; +import { Schema } from "effect"; +import { + isLocalLoopbackHost, + isPrivateNetworkHost, + normalizeHostname, +} from "@t3tools/shared/hostClassification"; +import { appAtomRegistry } from "~/rpc/atomRegistry"; +import { previewEnvironment } from "~/state/preview"; import { readPreparedConnection } from "~/state/session"; export { @@ -60,6 +69,12 @@ const resolveEnvironmentPortTarget = ( }; }; +/** + * Best-effort resolution used for *labels* — the port list, a link rendered in + * chat. It names the environment host so a remote reader can tell which machine + * a port lives on, but it cannot know whether that port is published there, so + * nothing may navigate to its result. Use `resolveNavigableUrl` for that. + */ export function resolveBrowserNavigationTarget( environmentId: EnvironmentId, target: BrowserNavigationTarget, @@ -96,3 +111,78 @@ export function resolveDiscoveredServerUrl(environmentId: EnvironmentId, rawUrl: return rawUrl; } } + +/** + * Resolution for anything that is about to be *opened*. + * + * A port on the environment host is reachable from this client only if + * something publishes it there, and only the environment knows what that is — + * whether a tailnet route already exists, on which port, over which scheme. So + * this asks, rather than rewriting the hostname and hoping the port answers on + * the other side. When the environment cannot make it reachable it says why, + * and that surfaces as a real error instead of a browser error page that reads + * like the app is broken. + */ +export async function resolveNavigableUrl( + environmentId: EnvironmentId, + target: BrowserNavigationTarget, +): Promise { + const label = resolveBrowserNavigationTarget(environmentId, target); + const requested = new URL(label.requestedUrl); + const environmentUrl = readEnvironmentUrl(environmentId); + // Already reachable as written: an external URL, or a local client whose + // loopback is the same loopback the port is on. A URL the label pass already + // pointed at the environment host is not — it names the right machine on a + // port nothing promised to publish there, so it still needs resolving. + const loopbackNeedsEnvironment = + isLoopbackHost(requested.hostname) && + (requested.hostname === "0.0.0.0" || !isLocalLoopbackHost(environmentUrl.hostname)); + if ( + label.resolutionKind === "direct" && + !loopbackNeedsEnvironment && + !namesAnEnvironmentPort(requested, environmentUrl) + ) { + return label.resolvedUrl; + } + + const port = Number(requested.port || (requested.protocol === "https:" ? 443 : 80)); + const result = await runAtomCommand( + appAtomRegistry, + previewEnvironment.resolvePort, + { environmentId, input: { port, clientBaseUrl: environmentUrl.toString() } }, + { label: "resolve preview port", reportFailure: false, reportDefect: false }, + ); + if (result._tag === "Failure") { + throw new Error(previewPortFailureMessage(squashAtomCommandFailure(result), port)); + } + + return new URL( + requested.pathname + requested.search + requested.hash, + result.value.origin, + ).toString(); +} + +/** + * True when a URL points at the environment's own host but a different port — + * a dev server beside the T3 server, not the T3 server itself. Chat links reach + * here already rewritten this way by the label pass, so recognizing the shape + * keeps one resolution path for both spellings of the same port. + */ +const namesAnEnvironmentPort = (candidate: URL, environmentUrl: URL): boolean => + normalizeHostname(candidate.hostname) === normalizeHostname(environmentUrl.hostname) && + !isLocalLoopbackHost(candidate.hostname) && + effectivePort(candidate) !== effectivePort(environmentUrl); + +const effectivePort = (url: URL): number => + Number(url.port || (url.protocol === "https:" ? 443 : 80)); + +const isPortUnreachable = Schema.is(PreviewPortUnreachableError); + +/** + * Keeps the environment's own explanation — it names the reason and the next + * action, which a browser error page cannot. + */ +const previewPortFailureMessage = (error: unknown, port: number): string => + isPortUnreachable(error) + ? error.message + : `Port ${port} could not be resolved to an address this client can reach: ${String(error)}`; diff --git a/apps/web/src/components/BranchToolbar.logic.test.ts b/apps/web/src/components/BranchToolbar.logic.test.ts index ff4bb76bf12a..7a40404b29cc 100644 --- a/apps/web/src/components/BranchToolbar.logic.test.ts +++ b/apps/web/src/components/BranchToolbar.logic.test.ts @@ -214,6 +214,19 @@ describe("resolveBranchTriggerLabel", () => { ).toBe("From main"); }); + it("shows the bare branch name when reusing the selected worktree base branch", () => { + expect( + resolveBranchTriggerLabel({ + activeWorktreePath: null, + effectiveEnvMode: "worktree", + resolvedActiveBranch: "main", + resolvedActiveBranchIsRemote: false, + startFromOrigin: true, + reuseBaseBranch: true, + }), + ).toBe("main"); + }); + it("does not duplicate the origin prefix for an explicit remote ref", () => { expect( resolveBranchTriggerLabel({ diff --git a/apps/web/src/components/BranchToolbar.logic.ts b/apps/web/src/components/BranchToolbar.logic.ts index 0577f5e8dd1f..7854920230b8 100644 --- a/apps/web/src/components/BranchToolbar.logic.ts +++ b/apps/web/src/components/BranchToolbar.logic.ts @@ -16,6 +16,7 @@ export interface EnvironmentOption { export const EnvMode = Schema.Literals(["local", "worktree"]); export type EnvMode = typeof EnvMode.Type; +export type WorkspaceTarget = EnvMode | "current-worktree"; const GENERIC_LOCAL_ENVIRONMENT_LABELS = new Set(["local", "local environment"]); @@ -90,6 +91,16 @@ export function resolveCurrentWorkspaceLabel(activeWorktreePath: string | null): return activeWorktreePath ? "Current worktree" : resolveEnvModeLabel("local"); } +export function resolveWorkspaceTarget(input: { + effectiveEnvMode: EnvMode; + activeWorktreePath: string | null; +}): WorkspaceTarget { + if (input.effectiveEnvMode === "worktree") { + return "worktree"; + } + return input.activeWorktreePath ? "current-worktree" : "local"; +} + export function resolveLockedWorkspaceLabel(activeWorktreePath: string | null): string { return activeWorktreePath ? "Worktree" : "Local checkout"; } @@ -190,6 +201,7 @@ export function resolveBranchTriggerLabel(input: { resolvedActiveBranch: string | null; resolvedActiveBranchIsRemote: boolean | null; startFromOrigin: boolean; + reuseBaseBranch?: boolean; }): string { const { activeWorktreePath, @@ -197,11 +209,17 @@ export function resolveBranchTriggerLabel(input: { resolvedActiveBranch, resolvedActiveBranchIsRemote, startFromOrigin, + reuseBaseBranch = false, } = input; if (!resolvedActiveBranch) { return "Select ref"; } + // Reused base branch is checked out as-is (Tim #15); otherwise "From X" for + // new worktree branches, with optional origin/ prefix (upstream #4680). if (effectiveEnvMode === "worktree" && !activeWorktreePath) { + if (reuseBaseBranch) { + return resolvedActiveBranch; + } const baseRef = startFromOrigin && resolvedActiveBranchIsRemote === false ? `origin/${resolvedActiveBranch}` diff --git a/apps/web/src/components/BranchToolbar.tsx b/apps/web/src/components/BranchToolbar.tsx index 3e3f834658ea..cb4379077e26 100644 --- a/apps/web/src/components/BranchToolbar.tsx +++ b/apps/web/src/components/BranchToolbar.tsx @@ -16,11 +16,13 @@ import { useProject, useThreadShell, useThreadShellsForProjectRefs } from "../st import { type EnvMode, type EnvironmentOption, + type WorkspaceTarget, resolveContextStripLabelsCompact, resolveCurrentWorkspaceLabel, resolveEnvModeLabel, resolveEffectiveEnvMode, resolveLockedWorkspaceLabel, + resolveWorkspaceTarget, resolvePreviousWorktreeLabel, resolvePreviousWorktreeSeed, shouldShowEnvironmentIndicator, @@ -51,12 +53,14 @@ interface BranchToolbarProps { threadId: ThreadId; showGitControls: boolean; draftId?: DraftId; - onEnvModeChange: (mode: EnvMode) => void; + onWorkspaceTargetChange: (target: WorkspaceTarget) => void; effectiveEnvModeOverride?: EnvMode; activeThreadBranchOverride?: string | null; onActiveThreadBranchOverrideChange?: (branch: string | null) => void; startFromOrigin: boolean; onStartFromOriginChange: (startFromOrigin: boolean) => void; + reuseBaseBranch: boolean; + onReuseBaseBranchChange: (reuseBaseBranch: boolean) => void; autoEnvironmentLabel?: string | undefined; onAutoEnvironment?: (() => void) | undefined; envLocked: boolean; @@ -78,9 +82,9 @@ interface MobileRunContextSelectorProps { showEnvironmentPicker: boolean; showEnvironmentIndicator: boolean; onEnvironmentChange: ((environmentId: EnvironmentId) => void) | undefined; - effectiveEnvMode: EnvMode; + workspaceTarget: WorkspaceTarget; activeWorktreePath: string | null; - onEnvModeChange: (mode: EnvMode) => void; + onWorkspaceTargetChange: (target: WorkspaceTarget) => void; previousWorktreeLabel: string | null; onUsePreviousWorktree: () => void; } @@ -95,9 +99,9 @@ const MobileRunContextSelector = memo(function MobileRunContextSelector({ showEnvironmentPicker, showEnvironmentIndicator, onEnvironmentChange, - effectiveEnvMode, + workspaceTarget, activeWorktreePath, - onEnvModeChange, + onWorkspaceTargetChange, previousWorktreeLabel, onUsePreviousWorktree, }: MobileRunContextSelectorProps) { @@ -106,16 +110,18 @@ const MobileRunContextSelector = memo(function MobileRunContextSelector({ [availableEnvironments, environmentId], ); const WorkspaceIcon = - effectiveEnvMode === "worktree" + workspaceTarget === "worktree" ? FolderGit2Icon - : activeWorktreePath + : workspaceTarget === "current-worktree" ? FolderGitIcon : FolderIcon; const workspaceLabel = envModeLocked ? resolveLockedWorkspaceLabel(activeWorktreePath) - : effectiveEnvMode === "worktree" + : workspaceTarget === "worktree" ? resolveEnvModeLabel("worktree") - : resolveCurrentWorkspaceLabel(activeWorktreePath); + : workspaceTarget === "current-worktree" + ? resolveCurrentWorkspaceLabel(activeWorktreePath) + : resolveEnvModeLabel("local"); const isLocked = envLocked || envModeLocked; const icon = showEnvironmentIndicator ? ( // Button's base styles apply `-mx-0.5` to descendant SVGs, which eats 4px @@ -222,27 +228,31 @@ const MobileRunContextSelector = memo(function MobileRunContextSelector({ Workspace { if (value === "previous-worktree") { onUsePreviousWorktree(); return; } - onEnvModeChange(value as EnvMode); + onWorkspaceTargetChange(value as WorkspaceTarget); }} > - {activeWorktreePath ? ( - - ) : ( - - )} - - {resolveCurrentWorkspaceLabel(activeWorktreePath)} - + + {resolveEnvModeLabel("local")} + {activeWorktreePath ? ( + + + + + {resolveCurrentWorkspaceLabel(activeWorktreePath)} + + + + ) : null} @@ -442,12 +452,14 @@ export const BranchToolbar = memo(function BranchToolbar({ threadId, showGitControls, draftId, - onEnvModeChange, + onWorkspaceTargetChange, effectiveEnvModeOverride, activeThreadBranchOverride, onActiveThreadBranchOverrideChange, startFromOrigin, onStartFromOriginChange, + reuseBaseBranch, + onReuseBaseBranchChange, autoEnvironmentLabel, onAutoEnvironment, envLocked, @@ -482,6 +494,7 @@ export const BranchToolbar = memo(function BranchToolbar({ hasServerThread: serverThread !== null, draftThreadEnvMode: draftThread?.envMode, }); + const workspaceTarget = resolveWorkspaceTarget({ effectiveEnvMode, activeWorktreePath }); const envModeLocked = envLocked || (serverThread !== null && activeWorktreePath !== null); // "Previous worktree" hops a draft into the most recently active worktree @@ -556,9 +569,9 @@ export const BranchToolbar = memo(function BranchToolbar({ showEnvironmentPicker={showEnvironmentPicker} showEnvironmentIndicator={showEnvironmentIndicator} onEnvironmentChange={onEnvironmentChange} - effectiveEnvMode={effectiveEnvMode} + workspaceTarget={workspaceTarget} activeWorktreePath={activeWorktreePath} - onEnvModeChange={onEnvModeChange} + onWorkspaceTargetChange={onWorkspaceTargetChange} previousWorktreeLabel={previousWorktreeLabel} onUsePreviousWorktree={onUsePreviousWorktree} /> @@ -594,9 +607,9 @@ export const BranchToolbar = memo(function BranchToolbar({ {showGitControls ? ( @@ -628,6 +641,8 @@ export const BranchToolbar = memo(function BranchToolbar({ {...(onActiveThreadBranchOverrideChange ? { onActiveThreadBranchOverrideChange } : {})} startFromOrigin={startFromOrigin} onStartFromOriginChange={onStartFromOriginChange} + reuseBaseBranch={reuseBaseBranch} + onReuseBaseBranchChange={onReuseBaseBranchChange} {...(onCheckoutPullRequestRequest ? { onCheckoutPullRequestRequest } : {})} {...(onComposerFocusRequest ? { onComposerFocusRequest } : {})} /> diff --git a/apps/web/src/components/BranchToolbarBranchSelector.tsx b/apps/web/src/components/BranchToolbarBranchSelector.tsx index 4bb5f0aefd89..6117c72fd271 100644 --- a/apps/web/src/components/BranchToolbarBranchSelector.tsx +++ b/apps/web/src/components/BranchToolbarBranchSelector.tsx @@ -9,7 +9,7 @@ import { } from "@t3tools/client-runtime/state/runtime"; import type { ContextMenuItem, EnvironmentId, VcsRef, ThreadId } from "@t3tools/contracts"; import { LegendList, type LegendListRef } from "@legendapp/list/react"; -import { ChevronDownIcon, GitBranchIcon, SearchIcon } from "lucide-react"; +import { ChevronDownIcon, GitBranchIcon, RefreshCwIcon, SearchIcon } from "lucide-react"; import { useCallback, useDeferredValue, @@ -83,6 +83,8 @@ interface BranchToolbarBranchSelectorProps { onActiveThreadBranchOverrideChange?: (refName: string | null) => void; startFromOrigin: boolean; onStartFromOriginChange: (startFromOrigin: boolean) => void; + reuseBaseBranch: boolean; + onReuseBaseBranchChange: (reuseBaseBranch: boolean) => void; onCheckoutPullRequestRequest?: (reference: string) => void; onComposerFocusRequest?: () => void; } @@ -102,10 +104,13 @@ export function BranchToolbarBranchSelector({ onActiveThreadBranchOverrideChange, startFromOrigin, onStartFromOriginChange, + reuseBaseBranch, + onReuseBaseBranchChange, onCheckoutPullRequestRequest, onComposerFocusRequest, }: BranchToolbarBranchSelectorProps) { const startFromOriginSwitchId = useId(); + const reuseBaseBranchSwitchId = useId(); const stopThreadSession = useAtomCommand(threadEnvironment.stopSession, "thread session stop"); const updateThreadMetadata = useAtomCommand( threadEnvironment.updateMetadata, @@ -618,6 +623,7 @@ export function BranchToolbarBranchSelector({ resolvedActiveBranch, resolvedActiveBranchIsRemote, startFromOrigin, + reuseBaseBranch, }); // Branch status is the fallback when this thread has no linked pull requests. @@ -857,32 +863,64 @@ export function BranchToolbarBranchSelector({ {isSelectingWorktreeBase ? ( - - - - - onStartFromOriginChange(Boolean(checked))} - /> - - } - /> - - Creates the worktree from the latest matching branch on origin instead of your local - branch. - - +
+ + + + + onReuseBaseBranchChange(Boolean(checked))} + /> + + } + /> + + Checks out the selected branch in the worktree instead of creating a new branch + from it. + + + + + + + onStartFromOriginChange(Boolean(checked))} + /> + + } + /> + + Creates the worktree from the latest matching branch on origin instead of your + local branch. + + +
) : null} {branchStatusText ? {branchStatusText} : null} diff --git a/apps/web/src/components/BranchToolbarEnvModeSelector.tsx b/apps/web/src/components/BranchToolbarEnvModeSelector.tsx index 4685dbf1ecd1..615dd501d47b 100644 --- a/apps/web/src/components/BranchToolbarEnvModeSelector.tsx +++ b/apps/web/src/components/BranchToolbarEnvModeSelector.tsx @@ -5,7 +5,7 @@ import { resolveCurrentWorkspaceLabel, resolveEnvModeLabel, resolveLockedWorkspaceLabel, - type EnvMode, + type WorkspaceTarget, } from "./BranchToolbar.logic"; import { composerFloatingLayerProps } from "./chat/composerEventScope"; import { @@ -22,32 +22,38 @@ const PREVIOUS_WORKTREE_SELECT_VALUE = "previous-worktree"; interface BranchToolbarEnvModeSelectorProps { envLocked: boolean; - effectiveEnvMode: EnvMode; + workspaceTarget: WorkspaceTarget; activeWorktreePath: string | null; - onEnvModeChange: (mode: EnvMode) => void; + onWorkspaceTargetChange: (target: WorkspaceTarget) => void; previousWorktreeLabel?: string | null; onUsePreviousWorktree?: () => void; } export const BranchToolbarEnvModeSelector = memo(function BranchToolbarEnvModeSelector({ envLocked, - effectiveEnvMode, + workspaceTarget, activeWorktreePath, - onEnvModeChange, + onWorkspaceTargetChange, previousWorktreeLabel, onUsePreviousWorktree, }: BranchToolbarEnvModeSelectorProps) { const showPreviousWorktree = Boolean(previousWorktreeLabel && onUsePreviousWorktree); - const envModeItems = useMemo( - () => [ - { value: "local", label: resolveCurrentWorkspaceLabel(activeWorktreePath) }, - { value: "worktree", label: resolveEnvModeLabel("worktree") }, - ...(showPreviousWorktree && previousWorktreeLabel - ? [{ value: PREVIOUS_WORKTREE_SELECT_VALUE, label: previousWorktreeLabel }] - : []), - ], - [activeWorktreePath, previousWorktreeLabel, showPreviousWorktree], - ); + const envModeItems = useMemo(() => { + const items: Array<{ value: string; label: string }> = [ + { value: "local", label: resolveEnvModeLabel("local") }, + ]; + if (activeWorktreePath) { + items.push({ + value: "current-worktree", + label: resolveCurrentWorkspaceLabel(activeWorktreePath), + }); + } + items.push({ value: "worktree", label: resolveEnvModeLabel("worktree") }); + if (showPreviousWorktree && previousWorktreeLabel) { + items.push({ value: PREVIOUS_WORKTREE_SELECT_VALUE, label: previousWorktreeLabel }); + } + return items; + }, [activeWorktreePath, previousWorktreeLabel, showPreviousWorktree]); if (envLocked) { return ( @@ -78,13 +84,13 @@ export const BranchToolbarEnvModeSelector = memo(function BranchToolbarEnvModeSe return ( setRenamingTitle(event.target.value)} + onClick={(event) => event.stopPropagation()} + onDoubleClick={(event) => event.stopPropagation()} + onKeyDown={(event) => { + event.stopPropagation(); + if (event.key === "Enter") { + event.preventDefault(); + void commitRename(); + } else if (event.key === "Escape") { + setIsRenaming(false); + } + }} + onBlur={() => void commitRename()} + /> + ) : ( + <> + + {thread.title} + + + + )} + {hasDraft ? : null} + + + {project.displayName} + {environment?.label ? ( + <> + + · + + + {isRemoteThread ? ( + + ) : null} + {environment.label} + + + ) : null} + + + + + {settledTimeLabel} + + {supportsSettlement ? ( + + ) : null} + + {props.jumpLabel ? ( + + {props.jumpLabel} + + ) : null} + + + ); + } + + return ( + setConfirmingArchive(false)} + > + } + size="sm" + isActive={props.isActive} + data-testid={`recent-thread-${thread.id}`} + className={`${resolveThreadRowClassName({ + isActive: props.isActive, + isSelected, + })} relative isolate`} + onClick={handleRowClick} + onDoubleClick={handleRowDoubleClick} + onContextMenu={handleContextMenu} + onKeyDown={(event) => { + if (event.key !== "Enter" && event.key !== " ") return; + event.preventDefault(); + props.navigateToThread(threadRef); + }} + > +
+ + + } + > + {resolveSidebarProjectBadgeLabel(project.displayName)} + + {project.displayName} + +
+
+ {threadStatus ? : null} + {isRenaming ? ( + setRenamingTitle(event.target.value)} + onClick={(event) => event.stopPropagation()} + onDoubleClick={(event) => event.stopPropagation()} + onKeyDown={(event) => { + event.stopPropagation(); + if (event.key === "Enter") { + event.preventDefault(); + void commitRename(); + } else if (event.key === "Escape") { + setIsRenaming(false); + } + }} + onBlur={() => void commitRename()} + /> + ) : ( + <> + {thread.title} + + + )} + {hasDraft ? : null} + {prStatus && pr ? ( + + event.stopPropagation()} + onClick={(event) => handleRecentPrClick(event, prStatus.url)} + /> + } + > + #{pr.number} + + + + + + ) : null} +
+ {/* Cross-project recency rows: project · server, matching mobile + + Sidebar V2's environment context (icon when remote). */} + + {project.displayName} + {environment?.label ? ( + <> + + · + + + {isRemoteThread ? ( + + ) : null} + {environment.label} + + + ) : null} + +
+
+
+ + handleContextMenu(event)} + /> + } + > + + + Thread actions + + {isPinned ? ( + + { + event.preventDefault(); + event.stopPropagation(); + toggleThreadPinned(threadKey); + }} + /> + } + > + + + Unpin thread + + ) : null} + {discoveredPorts.length > 0 ? ( + + + } + > + + + Open localhost:{discoveredPorts[0]?.port} + + ) : null} + {props.jumpLabel ? ( + + + } + > + {props.jumpLabel} + + {props.jumpLabel} + + ) : null} + + {terminalStatus ? ( + + + } + > + + + {terminalStatus.label} + + ) : null} + {showProviderMarker ? ( + + + } + > + {showProviderIcon ? : null} + {usageDotClass ? ( + + ) : null} + + + {threadUsage ? ( +
+ {threadModelPresentation.tooltip} + +
+ ) : ( + threadModelPresentation.tooltip + )} + + + ) : null} +
+ {/* Trailing remote cue kept for parity with project-thread rows; + subtitle already names the server when the label is available. */} + {isRemoteThread && !isDesktopLocalThread && !environment?.label ? ( + + + } + > + + + Remote + + ) : null} + + {formatRelativeTimeLabel( + thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt, + )} + + {!isThreadRunning ? ( + confirmingArchive ? ( + + ) : ( + + { + event.preventDefault(); + event.stopPropagation(); + if (confirmThreadArchive) setConfirmingArchive(true); + else attemptArchive(); + }} + /> + } + > + + + Archive thread + + ) + ) : null} +
+
+ + + ); +}); + +const SidebarRecentThreads = memo(function SidebarRecentThreads(props: { + recentThreads: readonly SidebarRecentThread[]; + openPullRequestsInRightPanel: boolean; + /** + * When true, partition by recency. Section headers render only when more + * than one non-empty bucket is present (Last Hour / Earlier Today / …). + */ + groupByRecency: boolean; + /** + * When true, settled threads leave the main list and sit in a collapsible + * shelf at the bottom (same idea as Sidebar V2 — out of the way, never gone). + */ + hideSettledThreads: boolean; + routeThreadKey: string | null; + navigateToThread: (threadRef: ScopedThreadRef) => void; + handleNewThread: ReturnType; + archiveThread: ReturnType["archiveThread"]; + deleteThread: ReturnType["deleteThread"]; + settleThread: ReturnType["settleThread"]; + unsettleThread: ReturnType["unsettleThread"]; + settledThreadKeys: ReadonlySet; + threadJumpLabelByKey: ReadonlyMap; + threadByKey: ReadonlyMap; +}) { + const [settledShelfExpanded, setSettledShelfExpanded] = useLocalStorage( + SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY, + DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED, + ListHideSettledSchema, + ); + const [settledRecencyHeadersEnabled] = useLocalStorage( + SIDEBAR_V2_SETTLED_RECENCY_HEADERS_STORAGE_KEY, + DEFAULT_SIDEBAR_V2_SETTLED_RECENCY_HEADERS, + ListHideSettledSchema, + ); + const [settledVisibleCount, setSettledVisibleCount] = useState(SETTLED_TAIL_INITIAL_COUNT); + const nowMinute = useNowMinute(); + + const { activeEntries, settledEntries } = useMemo(() => { + if (!props.hideSettledThreads) { + return { + activeEntries: props.recentThreads, + settledEntries: [] as SidebarRecentThread[], + }; + } + const active: SidebarRecentThread[] = []; + const settled: SidebarRecentThread[] = []; + for (const entry of props.recentThreads) { + const threadKey = scopedThreadKey( + scopeThreadRef(entry.thread.environmentId, entry.thread.id), + ); + if (props.settledThreadKeys.has(threadKey)) { + settled.push(entry); + } else { + active.push(entry); + } + } + // Settled is history: order by when work ended, matching V2 shelf sort. + if (settled.length <= 1) { + return { activeEntries: active, settledEntries: settled }; + } + const sortedThreads = sortSettledThreadsForSidebar(settled.map((entry) => entry.thread)); + const entryByKey = new Map( + settled.map((entry) => [ + scopedThreadKey(scopeThreadRef(entry.thread.environmentId, entry.thread.id)), + entry, + ]), + ); + return { + activeEntries: active, + settledEntries: sortedThreads.flatMap((thread) => { + const entry = entryByKey.get( + scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), + ); + return entry ? [entry] : []; + }), + }; + }, [props.hideSettledThreads, props.recentThreads, props.settledThreadKeys]); + + // When hide-settled turns off or the settled tail empties, drop a deep page + // so the next shelf open starts from the initial window again. + const settledPagingActive = props.hideSettledThreads && settledEntries.length > 0; + const lastSettledPagingActiveRef = useRef(settledPagingActive); + if (lastSettledPagingActiveRef.current !== settledPagingActive) { + lastSettledPagingActiveRef.current = settledPagingActive; + if (!settledPagingActive && settledVisibleCount !== SETTLED_TAIL_INITIAL_COUNT) { + setSettledVisibleCount(SETTLED_TAIL_INITIAL_COUNT); + } + } + + const pagedSettledEntries = useMemo(() => { + if (settledEntries.length <= settledVisibleCount) return settledEntries; + const visible = settledEntries.slice(0, settledVisibleCount); + // Open thread must stay reachable under "Show more". + if (props.routeThreadKey !== null) { + const routeEntry = settledEntries + .slice(settledVisibleCount) + .find( + (entry) => + scopedThreadKey(scopeThreadRef(entry.thread.environmentId, entry.thread.id)) === + props.routeThreadKey, + ); + if (routeEntry !== undefined) visible.push(routeEntry); + } + return visible; + }, [props.routeThreadKey, settledEntries, settledVisibleCount]); + + const renderedSettledEntries = useMemo(() => { + if (!props.hideSettledThreads || settledEntries.length === 0) return []; + if (settledShelfExpanded) return pagedSettledEntries; + if (props.routeThreadKey === null) return []; + const routeEntry = pagedSettledEntries.find( + (entry) => + scopedThreadKey(scopeThreadRef(entry.thread.environmentId, entry.thread.id)) === + props.routeThreadKey, + ); + return routeEntry === undefined ? [] : [routeEntry]; + }, [ + pagedSettledEntries, + props.hideSettledThreads, + props.routeThreadKey, + settledEntries.length, + settledShelfExpanded, + ]); + + const hiddenSettledCount = settledEntries.length - pagedSettledEntries.length; + const showMoreSettled = useCallback( + () => setSettledVisibleCount((count) => count + SETTLED_TAIL_PAGE_COUNT), + [], + ); + const toggleSettledShelf = useCallback( + () => setSettledShelfExpanded((value) => !value), + [setSettledShelfExpanded], + ); + + // Date headers under Settled (Last Hour / Earlier Today / …) — same helper + // and rules as Sidebar V2. Single-bucket pages omit headers; View menu can + // disable headers without changing settle-time sort order. + const settledRecencyLayout = useMemo(() => { + void nowMinute; + const layout = groupSettledThreadsByRecencyForSidebarV2( + renderedSettledEntries.map((entry) => entry.thread), + new Date(), + ); + if (!settledRecencyHeadersEnabled) { + return { groups: layout.groups, showHeaders: false }; + } + return layout; + }, [nowMinute, renderedSettledEntries, settledRecencyHeadersEnabled]); + + const settledEntryByThreadKey = useMemo( + () => + new Map( + renderedSettledEntries.map((entry) => [ + scopedThreadKey(scopeThreadRef(entry.thread.environmentId, entry.thread.id)), + entry, + ]), + ), + [renderedSettledEntries], + ); + + // Multi-select range walks rendered rows only (collapsed shelf is out). + const orderedRecentThreadKeys = useMemo( + () => + [...activeEntries, ...renderedSettledEntries].map(({ thread }) => + scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), + ), + [activeEntries, renderedSettledEntries], + ); + + if (props.recentThreads.length === 0) { + return ( + +
No threads
+ + ); + } + + const renderThreadRow = (entry: SidebarRecentThread) => { + const threadKey = scopedThreadKey(scopeThreadRef(entry.thread.environmentId, entry.thread.id)); + return ( + + ); + }; + + const renderSettledRows = () => { + if (renderedSettledEntries.length === 0) { + return null; + } + if (settledRecencyLayout.showHeaders) { + return ( + <> + {settledRecencyLayout.groups.map((group) => ( +
+
+ {group.label} +
+ + {group.threads.flatMap((thread) => { + const entry = settledEntryByThreadKey.get( + scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), + ); + return entry ? [renderThreadRow(entry)] : []; + })} + +
+ ))} + + ); + } + return ( + + {renderedSettledEntries.map(renderThreadRow)} + + ); + }; + + const renderActiveList = () => { + if (activeEntries.length === 0) { + return null; + } + + if (!props.groupByRecency) { + return ( + + + {activeEntries.map(renderThreadRow)} + + + ); + } + + const recencyGroups = groupSortedThreadsByRecency(activeEntries.map((entry) => entry.thread)); + const showSectionHeaders = shouldShowRecencySectionHeaders(recencyGroups); + const entryByThreadKey = new Map( + activeEntries.map((entry) => [ + scopedThreadKey(scopeThreadRef(entry.thread.environmentId, entry.thread.id)), + entry, + ]), + ); + + // Single non-empty bucket: skip headers (e.g. everything is "Last Hour"). + if (!showSectionHeaders) { + return ( + + + {activeEntries.map(renderThreadRow)} + + + ); + } + + return ( + <> + {recencyGroups.map((group) => ( + +
+ {group.label} +
+ + {group.threads.flatMap((thread) => { + const entry = entryByThreadKey.get( + scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), + ); + return entry ? [renderThreadRow(entry)] : []; + })} + + + ))} + + ); + }; + + const renderSettledShelf = () => { + if (!props.hideSettledThreads || settledEntries.length === 0) { + return null; + } + return ( + + + {renderSettledRows()} + {settledShelfExpanded && hiddenSettledCount > 0 ? ( + + ) : null} + + ); + }; + + return ( + <> + {renderActiveList()} + {renderSettledShelf()} + + ); +}); + +const SidebarProjectsContent = memo(function SidebarProjectsContent( + props: SidebarProjectsContentProps, +) { + const { + showArm64IntelBuildWarning, + arm64IntelBuildWarningDescription, + desktopUpdateButtonAction, + desktopUpdateButtonDisabled, + desktopUpdateActionPending, + handleDesktopUpdateButtonClick, + projectSortOrder, + threadSortOrder, + threadPreviewCount, + updateSettings, + openAddProject, + isManualProjectSorting, + projectDnDSensors, + projectCollisionDetection, + handleProjectDragStart, + handleProjectDragEnd, + handleProjectDragCancel, + handleNewThread, + archiveThread, + deleteThread, + settleThread, + unsettleThread, + sortedProjects, + recentThreads, + threadByKey, + navigateToThread, + expandedThreadListsByProject, + activeRouteProjectKey, + routeThreadKey, + openPullRequestsInRightPanel, + newThreadShortcutLabel, + commandPaletteShortcutLabel, + listMode, + onListModeChange, + threadGrouping, + onThreadGroupingChange, + environmentFilterOptions, + selectedEnvironmentIds, + onSelectedEnvironmentIdsChange, + projectFilterOptions, + selectedProjectFilterKey, + onSelectedProjectFilterKeyChange, + ownershipFilter, + onOwnershipFilterChange, + ownershipRelation, + onOwnershipRelationChange, + claimPersonIdByEnvironment, + hideSettledThreads, + onHideSettledThreadsChange, + settledThreadKeys, + threadJumpLabelByKey, + attachThreadListAutoAnimateRef, + expandThreadListForProject, + collapseThreadListForProject, + dragInProgressRef, + suppressProjectClickAfterDragRef, + suppressProjectClickForContextMenuRef, + attachProjectListAutoAnimateRef, + projectsLength, + } = props; + const showThreadListChrome = listMode === "threads"; + const showProjectGroups = showThreadListChrome && usesProjectThreadGrouping(threadGrouping); + const showFlatOrRecencyList = showThreadListChrome && usesFlatThreadGrouping(threadGrouping); + + const selectedProjectFilterValue = + selectedProjectFilterKey !== null && + projectFilterOptions.some((project) => project.projectKey === selectedProjectFilterKey) + ? selectedProjectFilterKey + : LIST_PROJECT_FILTER_ALL; + + // Dot on the filter button when anything is non-default (active filters / + // non-default grouping or hide-settled). Matches Sidebar V2 “scoped” cues. + const defaultHideSettled = usesProjectThreadGrouping(threadGrouping) + ? DEFAULT_HIDE_SETTLED_PROJECTS + : DEFAULT_HIDE_SETTLED_RECENT; + const [settledRecencyHeadersEnabled, setSettledRecencyHeadersEnabled] = useLocalStorage( + SIDEBAR_V2_SETTLED_RECENCY_HEADERS_STORAGE_KEY, + DEFAULT_SIDEBAR_V2_SETTLED_RECENCY_HEADERS, + ListHideSettledSchema, + ); + const listOptionsActive = + !isAllEnvironmentsSelected(selectedEnvironmentIds) || + selectedProjectFilterKey !== null || + threadGrouping !== DEFAULT_WEB_THREAD_GROUPING || + hideSettledThreads !== defaultHideSettled || + ownershipFilter !== DEFAULT_SIDEBAR_OWNERSHIP_FILTER || + ownershipRelation !== DEFAULT_OWNERSHIP_RELATION || + (showFlatOrRecencyList && + settledRecencyHeadersEnabled !== DEFAULT_SIDEBAR_V2_SETTLED_RECENCY_HEADERS); + + const handleProjectSortOrderChange = useCallback( + (sortOrder: SidebarProjectSortOrder) => { + updateSettings({ sidebarProjectSortOrder: sortOrder }); + }, + [updateSettings], + ); + const handleThreadSortOrderChange = useCallback( + (sortOrder: SidebarThreadSortOrder) => { + updateSettings({ sidebarThreadSortOrder: sortOrder }); + }, + [updateSettings], + ); + const handleThreadPreviewCountChange = useCallback( + (count: SidebarThreadPreviewCount) => { + updateSettings({ sidebarThreadPreviewCount: count }); + }, + [updateSettings], + ); - {projectsLength === 0 && ( -
No projects yet
- )} + const { isMobile, setOpenMobile } = useSidebar(); + const canCreateThread = sortedProjects.length > 0; + const scopedNewThreadProject = + selectedProjectFilterKey === null + ? null + : (sortedProjects.find((project) => project.projectKey === selectedProjectFilterKey) ?? null); + // Multi-project: show a project picker menu (especially useful when + // grouping by project). Single project or a project filter: create immediately. + const needsNewThreadProjectMenu = scopedNewThreadProject === null && sortedProjects.length > 1; + + const createThreadInProject = useCallback( + (project: SidebarProjectSnapshot) => { + const member = project.memberProjects[0]; + if (!member) return; + if (isMobile) { + setOpenMobile(false); + } + void settlePromise(() => + handleNewThread(scopeProjectRef(member.environmentId, member.id)), + ).then((result) => { + if (result._tag === "Failure") { + const error = squashAtomCommandFailure(result); + toastManager.add( + stackedThreadToast({ + type: "error", + title: "Could not create thread", + description: error instanceof Error ? error.message : "An error occurred.", + }), + ); + } + }); + }, + [handleNewThread, isMobile, setOpenMobile], + ); + + const handleHeaderNewThreadClick = useCallback(() => { + if (!canCreateThread) return; + if (scopedNewThreadProject) { + createThreadInProject(scopedNewThreadProject); + return; + } + if (sortedProjects.length === 1) { + createThreadInProject(sortedProjects[0]!); + return; + } + // Multi-project without a scope: prefer the command palette "New thread + // in…" flow (same as Sidebar V2) when not in project grouping; when + // grouping by project we still offer an inline menu below. + if (!usesProjectThreadGrouping(threadGrouping)) { + if (isMobile) setOpenMobile(false); + openCommandPalette({ open: "new-thread-in" }); + } + }, [ + canCreateThread, + createThreadInProject, + isMobile, + scopedNewThreadProject, + setOpenMobile, + sortedProjects, + threadGrouping, + ]); + + const newThreadButtonClassName = + "relative inline-flex size-8 shrink-0 cursor-pointer items-center justify-center rounded-md text-sidebar-muted-foreground outline-none transition-colors hover:bg-sidebar-row-hover hover:text-sidebar-foreground focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50"; + + return ( + + + {/* Search + New thread on one row (Sidebar V2 layout). */} +
+
+ + } + > + + Search + {commandPaletteShortcutLabel ? ( + + {commandPaletteShortcutLabel} + + ) : null} + +
+ {needsNewThreadProjectMenu ? ( + + + + } + > + + + + {newThreadShortcutLabel ? `New thread (${newThreadShortcutLabel})` : "New thread"} + + + + +
+ New thread in +
+ {sortedProjects.map((project) => ( + createThreadInProject(project)} + > + + + {project.displayName} + + + ))} + + + { + if (isMobile) setOpenMobile(false); + openCommandPalette({ open: "new-thread-in" }); + }} + > + Browse all… + + + + ) : ( + + + } + > + + + + {newThreadShortcutLabel ? `New thread (${newThreadShortcutLabel})` : "New thread"} + + + )} +
+ {/* Compact chrome: Threads|Board + view/filter menu. */} +
+ { + const next = value[0]; + if (isWebListMode(next)) { + onListModeChange(next); + } + }} + data-testid="sidebar-list-mode-switcher" + > + {WEB_LIST_MODES.map((mode) => ( + + {WEB_LIST_MODE_LABELS[mode]} + + ))} + + {showThreadListChrome ? ( + <> + + + + } + > + + {listOptionsActive ? ( + + ) : null} + + View & filters + + + +
+ Group threads +
+ { + if (isWebThreadGrouping(value)) { + onThreadGroupingChange(value); + } + }} + > + {WEB_THREAD_GROUPINGS.map((grouping) => ( + + + {grouping === "recency" ? ( + + ) : grouping === "project" ? ( + + ) : ( + + )} + {WEB_THREAD_GROUPING_LABELS[grouping]} + + + ))} + + + + {projectFilterOptions.length > 0 ? ( + <> + + +
+ Project +
+ { + onSelectedProjectFilterKeyChange( + value === LIST_PROJECT_FILTER_ALL ? null : (value as string), + ); + }} + > + + + + All projects + + + {projectFilterOptions.map((project) => ( + + + + {project.displayName} + + + ))} + + + + ) : null} + + {environmentFilterOptions.length > 1 ? ( + <> + + +
+ Environment +
+ onSelectedEnvironmentIdsChange([])} + > + All environments + + {environmentFilterOptions.map((environment) => ( + { + onSelectedEnvironmentIdsChange( + toggleEnvironmentId( + selectedEnvironmentIds, + environment.environmentId, + ), + ); + }} + > + {environment.label} + + ))} + + + ) : null} + + + +
+ Ownership +
+ { + if (value !== "any" && value !== "mine" && value !== "theirs") return; + onOwnershipFilterChange(value); + }} + > + {SIDEBAR_OWNERSHIP_FILTERS.map((value) => ( + + {SIDEBAR_OWNERSHIP_FILTER_LABELS[value]} + + ))} + + + {ownershipFilter === "mine" || ownershipFilter === "theirs" ? ( + <> + + +
+ {ownershipFilter === "mine" ? "Mine includes" : "Theirs includes"} +
+ { + if (!isOwnershipRelation(value)) return; + onOwnershipRelationChange(value); + }} + > + {SIDEBAR_OWNERSHIP_RELATIONS.map((value) => ( + + {SIDEBAR_OWNERSHIP_RELATION_LABELS[value]} + + ))} + + + + ) : null} + + onHideSettledThreadsChange(checked === true)} + > + Hide settled + + {showFlatOrRecencyList && hideSettledThreads ? ( + + setSettledRecencyHeadersEnabled(checked === true) + } + > + Date headers on settled + + ) : null} + + + {showFlatOrRecencyList ? ( + + + } + > + + + Add project + + ) : null} + + ) : null} +
+ {showArm64IntelBuildWarning && arm64IntelBuildWarningDescription ? ( + + + + Intel build on Apple Silicon + {arm64IntelBuildWarningDescription} + {desktopUpdateButtonAction !== "none" ? ( + + + + ) : null} + + + ) : null} + + {showFlatOrRecencyList ? ( + + ) : null} + {showProjectGroups ? ( + +
+ Projects +
+ + + + } + > + + + Add project + +
+
+ + {isManualProjectSorting ? ( + + + project.projectKey)} + strategy={verticalListSortingStrategy} + > + {sortedProjects.map((project) => ( + + {(dragHandleProps) => ( + + )} + + ))} + + + + ) : ( + + {sortedProjects.map((project) => ( + + ))} + + )} + + {projectsLength === 0 ? ( +
+ No projects yet +
+ ) : sortedProjects.length === 0 ? ( +
+ No projects in selected environments +
+ ) : null} + + ) : null} + {listMode === "board" ? ( + +
+ Board view is open in the main panel +
+ + ) : null} ); }); export default function LegacySidebar() { + const pathname = useLocation({ select: (loc) => loc.pathname }); const projects = useProjects(); const sidebarThreads = useThreadShells(); const projectExpandedById = useUiStateStore((store) => store.projectExpandedById); @@ -3147,7 +5232,9 @@ export default function LegacySidebar() { const sidebarThreadPreviewCount = useClientSettings((s) => s.sidebarThreadPreviewCount); const updateSettings = useUpdateClientSettings(); const handleNewThread = useNewThreadHandler(); - const { archiveThread, deleteThread } = useThreadActions(); + const { archiveThread, deleteThread, settleThread, unsettleThread } = useThreadActions(); + const serverConfigs = useServerConfigs(); + const nowMinute = useNowMinute(); const { isMobile, setOpenMobile } = useSidebar(); const routeTarget = useParams({ strict: false, @@ -3187,6 +5274,136 @@ export default function LegacySidebar() { const terminalFocused = useTerminalFocus(); const { environments } = useEnvironments(); const primaryEnvironmentId = usePrimaryEnvironmentId(); + const [storedListMode, setStoredListMode] = useLocalStorage( + LIST_MODE_STORAGE_KEY, + DEFAULT_WEB_LIST_MODE, + WebListModeSchema, + ); + const defaultThreadGrouping = useMemo(() => { + if (typeof window === "undefined") return DEFAULT_WEB_THREAD_GROUPING; + try { + return defaultThreadGroupingFromLegacyModeStorage( + window.localStorage.getItem(LIST_MODE_STORAGE_KEY), + ); + } catch { + return DEFAULT_WEB_THREAD_GROUPING; + } + }, []); + const [storedThreadGrouping, setStoredThreadGrouping] = useLocalStorage( + LIST_THREAD_GROUPING_STORAGE_KEY, + defaultThreadGrouping, + WebThreadGroupingSchema, + ); + const [storedEnvironmentFilter, setStoredEnvironmentFilter] = useLocalStorage( + LIST_ENVIRONMENT_FILTER_STORAGE_KEY, + EMPTY_LIST_ENVIRONMENT_FILTER, + ListEnvironmentFilterSchema, + ); + const [storedProjectFilter, setStoredProjectFilter] = useLocalStorage( + LIST_PROJECT_FILTER_STORAGE_KEY, + null as string | null, + ListProjectFilterSchema, + ); + const [hideSettledRecent, setHideSettledRecent] = useLocalStorage( + LIST_HIDE_SETTLED_RECENT_STORAGE_KEY, + DEFAULT_HIDE_SETTLED_RECENT, + ListHideSettledSchema, + ); + const [hideSettledProjects, setHideSettledProjects] = useLocalStorage( + LIST_HIDE_SETTLED_PROJECTS_STORAGE_KEY, + DEFAULT_HIDE_SETTLED_PROJECTS, + ListHideSettledSchema, + ); + const [ownershipFilter, setOwnershipFilter] = useState(() => { + try { + return parseSidebarOwnershipFilter( + window.localStorage.getItem(SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY), + ); + } catch { + return DEFAULT_SIDEBAR_OWNERSHIP_FILTER; + } + }); + const handleOwnershipFilterChange = useCallback((filter: SidebarOwnershipFilter) => { + setOwnershipFilter(filter); + try { + window.localStorage.setItem(SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY, filter); + } catch { + // ignore + } + }, []); + const [ownershipRelation, setOwnershipRelation] = useState(() => { + try { + const raw = window.localStorage.getItem(SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY); + if (isOwnershipRelation(raw)) return raw; + } catch { + // ignore + } + return DEFAULT_OWNERSHIP_RELATION; + }); + const handleOwnershipRelationChange = useCallback((relation: OwnershipRelation) => { + setOwnershipRelation(relation); + try { + window.localStorage.setItem(SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY, relation); + } catch { + // ignore + } + }, []); + const hideSettledThreads = usesProjectThreadGrouping(storedThreadGrouping) + ? hideSettledProjects + : hideSettledRecent; + const handleHideSettledThreadsChange = useCallback( + (hide: boolean) => { + if (usesProjectThreadGrouping(storedThreadGrouping)) { + setHideSettledProjects(hide); + return; + } + setHideSettledRecent(hide); + }, + [setHideSettledProjects, setHideSettledRecent, storedThreadGrouping], + ); + const availableEnvironmentIds = useMemo( + () => new Set(environments.map((environment) => environment.environmentId)), + [environments], + ); + const selectedEnvironmentIds = useMemo( + () => + resolveSelectedEnvironmentIds( + storedEnvironmentFilter as readonly EnvironmentId[], + availableEnvironmentIds, + ), + [availableEnvironmentIds, storedEnvironmentFilter], + ); + const claimPersonIdByEnvironment = useAtomValue(identityClaimPersonIdByEnvironmentAtom); + const environmentFilterOptions = useMemo( + () => + environments.map((environment) => ({ + environmentId: environment.environmentId, + label: environment.label, + })), + [environments], + ); + const handleListModeChange = useCallback( + (mode: WebListMode) => { + setStoredListMode(mode); + if (mode === "board") { + if (isMobile) { + setOpenMobile(false); + } + void navigate({ to: "/board" }); + return; + } + if (pathname === "/board") { + void navigate({ to: "/" }); + } + }, + [isMobile, navigate, pathname, setOpenMobile, setStoredListMode], + ); + const handleSelectedEnvironmentIdsChange = useCallback( + (next: readonly EnvironmentId[]) => { + setStoredEnvironmentFilter([...next]); + }, + [setStoredEnvironmentFilter], + ); const environmentLabelById = useMemo( () => new Map( @@ -3419,8 +5636,31 @@ export default function LegacySidebar() { }, []); const visibleThreads = useMemo( - () => sidebarThreads.filter((thread) => thread.archivedAt === null), - [sidebarThreads], + () => + sidebarThreads.filter( + (thread) => + thread.archivedAt === null && + matchesEnvironmentFilter(thread.environmentId, selectedEnvironmentIds) && + threadMatchesMine({ + claimPersonId: claimPersonIdForEnvironment( + claimPersonIdByEnvironment, + thread.environmentId, + ), + originPersonId: thread.originSource?.personId ?? null, + participantPersonIds: (thread.participantSummaries ?? []).map( + (participant) => participant.personId, + ), + mode: ownershipFilter, + relation: ownershipRelation, + }), + ), + [ + claimPersonIdByEnvironment, + ownershipFilter, + ownershipRelation, + selectedEnvironmentIds, + sidebarThreads, + ], ); const sortedProjects = useMemo(() => { const sortableProjects = sidebarProjects.map((project) => ({ @@ -3443,23 +5683,166 @@ export default function LegacySidebar() { sidebarProjectSortOrder, ).flatMap((project) => { const resolvedProject = sidebarProjectByKey.get(project.id); - return resolvedProject ? [resolvedProject] : []; + if (!resolvedProject) { + return []; + } + if ( + !resolvedProject.memberProjects.some((member) => + matchesEnvironmentFilter(member.environmentId, selectedEnvironmentIds), + ) + ) { + return []; + } + return [resolvedProject]; }); }, [ sidebarProjectSortOrder, physicalToLogicalKey, projectPhysicalKeyByScopedRef, + selectedEnvironmentIds, sidebarProjectByKey, sidebarProjects, visibleThreads, ]); const isManualProjectSorting = sidebarProjectSortOrder === "manual"; + // PR states stream in per-row (rows own the VCS subscriptions); a merged or + // closed PR auto-settles its thread on the next classification pass — same + // path Sidebar V2 and the board use so hide-settled matches across surfaces. + const [changeRequestStateByKey, setChangeRequestStateByKey] = useState< + ReadonlyMap + >(() => new Map()); + const handleChangeRequestState = useCallback( + (threadKey: string, state: "open" | "closed" | "merged" | null) => { + setChangeRequestStateByKey((current) => { + if ((current.get(threadKey) ?? null) === state) return current; + const next = new Map(current); + if (state === null) { + next.delete(threadKey); + } else { + next.set(threadKey, state); + } + return next; + }); + }, + [], + ); + const settledThreadKeys = useMemo(() => { + const now = `${nowMinute}:00.000Z`; + const keys = new Set(); + for (const thread of visibleThreads) { + const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)); + if ( + isThreadSettledForDisplay(thread, { + serverConfigs, + now, + autoSettleAfterDays: null, + changeRequestState: changeRequestStateByKey.get(threadKey) ?? null, + }) + ) { + keys.add(threadKey); + } + } + return keys; + }, [changeRequestStateByKey, nowMinute, serverConfigs, visibleThreads]); + const selectedProjectFilterKey = + storedProjectFilter !== null && + sortedProjects.some((project) => project.projectKey === storedProjectFilter) + ? storedProjectFilter + : null; + const projectFilteredProjects = useMemo( + () => + selectedProjectFilterKey === null + ? sortedProjects + : sortedProjects.filter((project) => project.projectKey === selectedProjectFilterKey), + [selectedProjectFilterKey, sortedProjects], + ); + const projectFilterOptions = useMemo( + () => + sortedProjects.map((project) => ({ + projectKey: project.projectKey, + displayName: project.displayName, + environmentId: project.environmentId, + workspaceRoot: project.workspaceRoot, + title: project.title, + faviconPath: project.faviconPath, + projectIcon: project.projectIcon, + })), + [sortedProjects], + ); + /** + * Flat/recency groupings: unarchived threads sorted by latest activity. + * Settled rows stay in this list; when hide-settled is on, the recent list + * shelves them at the bottom instead of omitting them. + */ + const recentThreads = useMemo(() => { + const memberKeysForSelectedProject = + selectedProjectFilterKey === null + ? null + : new Set( + ( + sortedProjects.find((project) => project.projectKey === selectedProjectFilterKey) + ?.memberProjects ?? [] + ).map((member) => scopedProjectKey(scopeProjectRef(member.environmentId, member.id))), + ); + return sortThreads(visibleThreads, "updated_at").flatMap((thread) => { + const memberKey = scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId)); + const physicalKey = projectPhysicalKeyByScopedRef.get(memberKey) ?? memberKey; + const projectKey = physicalToLogicalKey.get(physicalKey) ?? physicalKey; + if ( + memberKeysForSelectedProject !== null && + !memberKeysForSelectedProject.has(memberKey) && + projectKey !== selectedProjectFilterKey + ) { + return []; + } + const project = sidebarProjectByKey.get(projectKey); + return project ? [{ thread, project }] : []; + }); + }, [ + physicalToLogicalKey, + projectPhysicalKeyByScopedRef, + selectedProjectFilterKey, + sidebarProjectByKey, + sortedProjects, + visibleThreads, + ]); + // Jump shortcuts target the main inbox only when settled are shelved — + // collapsed history shouldn't consume 1–9 slots. + const recentThreadKeys = useMemo( + () => + recentThreads.flatMap(({ thread }) => { + const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)); + if ( + hideSettledRecent && + usesFlatThreadGrouping(storedThreadGrouping) && + settledThreadKeys.has(threadKey) + ) { + return []; + } + return [threadKey]; + }), + [hideSettledRecent, recentThreads, settledThreadKeys, storedThreadGrouping], + ); const visibleSidebarThreadKeys = useMemo( () => sortedProjects.flatMap((project) => { const projectThreads = sortThreads( (threadsByProjectKey.get(project.projectKey) ?? []).filter( - (thread) => thread.archivedAt === null, + (thread) => + thread.archivedAt === null && + matchesEnvironmentFilter(thread.environmentId, selectedEnvironmentIds) && + threadMatchesMine({ + claimPersonId: claimPersonIdForEnvironment( + claimPersonIdByEnvironment, + thread.environmentId, + ), + originPersonId: thread.originSource?.personId ?? null, + participantPersonIds: (thread.participantSummaries ?? []).map( + (participant) => participant.personId, + ), + mode: ownershipFilter, + relation: ownershipRelation, + }), ), sidebarThreadSortOrder, ); @@ -3492,18 +5875,29 @@ export default function LegacySidebar() { ); }), [ + claimPersonIdByEnvironment, + ownershipFilter, + ownershipRelation, sidebarThreadSortOrder, sidebarThreadPreviewCount, expandedThreadListsByProject, projectExpandedById, routeThreadKey, + selectedEnvironmentIds, sortedProjects, threadsByProjectKey, ], ); + const jumpCandidateThreadKeys = useMemo( + () => + storedListMode === "threads" && usesFlatThreadGrouping(storedThreadGrouping) + ? recentThreadKeys + : visibleSidebarThreadKeys, + [recentThreadKeys, storedListMode, storedThreadGrouping, visibleSidebarThreadKeys], + ); const threadJumpCommandByKey = useMemo(() => { const mapping = new Map>>(); - for (const [visibleThreadIndex, threadKey] of visibleSidebarThreadKeys.entries()) { + for (const [visibleThreadIndex, threadKey] of jumpCandidateThreadKeys.entries()) { const jumpCommand = threadJumpCommandForIndex(visibleThreadIndex); if (!jumpCommand) { return mapping; @@ -3512,7 +5906,7 @@ export default function LegacySidebar() { } return mapping; - }, [visibleSidebarThreadKeys]); + }, [jumpCandidateThreadKeys]); const threadJumpThreadKeys = useMemo( () => [...threadJumpCommandByKey.keys()], [threadJumpCommandByKey], @@ -3545,7 +5939,11 @@ export default function LegacySidebar() { : EMPTY_THREAD_JUMP_LABELS; const orderedSidebarThreadKeys = visibleSidebarThreadKeys; const prewarmedSidebarThreadKeys = useMemo( - () => getSidebarThreadIdsToPrewarm(visibleSidebarThreadKeys), + // Browser clients can sit behind constrained remote links. Prewarming every + // visible thread hydrates several full detail windows before the user opens + // any of them, so keep the eager cache warm-up desktop-only. The active + // route still subscribes to its selected thread normally in either mode. + () => (isElectron ? getSidebarThreadIdsToPrewarm(visibleSidebarThreadKeys) : []), [visibleSidebarThreadKeys], ); const prewarmedSidebarThreadRefs = useMemo( @@ -3573,6 +5971,17 @@ export default function LegacySidebar() { platform, context: shortcutContext, }); + if (command === "board.open") { + event.preventDefault(); + event.stopPropagation(); + setStoredListMode("board"); + if (isMobile) { + setOpenMobile(false); + } + void navigate({ to: "/board" }); + return; + } + const traversalDirection = threadTraversalDirectionFromCommand(command); if (traversalDirection !== null) { const targetThreadKey = resolveAdjacentThreadId({ @@ -3620,12 +6029,16 @@ export default function LegacySidebar() { }; }, [ getCurrentSidebarShortcutContext, + isMobile, keybindings, + navigate, navigateToThread, orderedSidebarThreadKeys, platform, routeThreadKey, + setStoredListMode, sidebarThreadByKey, + setOpenMobile, threadJumpThreadKeys, ]); @@ -3674,7 +6087,11 @@ export default function LegacySidebar() { .downloadUpdate() .then((result) => { if (result.completed) { - showDesktopUpdateDownloadedToast(bridge, result.state); + toastManager.add({ + type: "success", + title: "Update downloaded", + description: "Restart the app from the update button to install it.", + }); } if (!shouldToastDesktopUpdateActionResult(result)) return; const actionError = getDesktopUpdateActionError(result); @@ -3771,8 +6188,27 @@ export default function LegacySidebar() { }); }, []); + useEffect( + () => + subscribeToProjectReveal(({ environmentId, projectId }) => { + const physicalProjectKey = `${environmentId}:${projectId}`; + const projectKey = physicalToLogicalKey.get(physicalProjectKey) ?? physicalProjectKey; + if (!sidebarProjectByKey.has(projectKey)) return; + expandThreadListForProject(projectKey); + requestAnimationFrame(() => { + const rows = document.querySelectorAll("[data-project-key]"); + for (const row of rows) { + if (row.dataset.projectKey !== projectKey) continue; + row.scrollIntoView({ behavior: "smooth", block: "nearest" }); + break; + } + }); + }), + [expandThreadListForProject, physicalToLogicalKey, sidebarProjectByKey], + ); + return ( - <> + {prewarmedSidebarThreadRefs.map((threadRef) => ( ))} @@ -3799,13 +6235,36 @@ export default function LegacySidebar() { handleNewThread={handleNewThread} archiveThread={archiveThread} deleteThread={deleteThread} - sortedProjects={sortedProjects} + settleThread={settleThread} + unsettleThread={unsettleThread} + sortedProjects={projectFilteredProjects} + recentThreads={recentThreads} + threadByKey={sidebarThreadByKey} + navigateToThread={navigateToThread} expandedThreadListsByProject={expandedThreadListsByProject} activeRouteProjectKey={activeRouteProjectKey} routeThreadKey={routeThreadKey} openPullRequestsInRightPanel={routeThreadRef !== null} newThreadShortcutLabel={newThreadShortcutLabel} commandPaletteShortcutLabel={commandPaletteShortcutLabel} + listMode={storedListMode} + onListModeChange={handleListModeChange} + threadGrouping={storedThreadGrouping} + onThreadGroupingChange={setStoredThreadGrouping} + environmentFilterOptions={environmentFilterOptions} + selectedEnvironmentIds={selectedEnvironmentIds} + onSelectedEnvironmentIdsChange={handleSelectedEnvironmentIdsChange} + projectFilterOptions={projectFilterOptions} + selectedProjectFilterKey={selectedProjectFilterKey} + onSelectedProjectFilterKeyChange={setStoredProjectFilter} + ownershipFilter={ownershipFilter} + onOwnershipFilterChange={handleOwnershipFilterChange} + ownershipRelation={ownershipRelation} + onOwnershipRelationChange={handleOwnershipRelationChange} + claimPersonIdByEnvironment={claimPersonIdByEnvironment} + hideSettledThreads={hideSettledThreads} + onHideSettledThreadsChange={handleHideSettledThreadsChange} + settledThreadKeys={settledThreadKeys} threadJumpLabelByKey={visibleThreadJumpLabelByKey} attachThreadListAutoAnimateRef={attachThreadListAutoAnimateRef} expandThreadListForProject={expandThreadListForProject} @@ -3817,6 +6276,6 @@ export default function LegacySidebar() { projectsLength={projects.length} /> - + ); } diff --git a/apps/web/src/components/ListEnvironmentFilterControl.tsx b/apps/web/src/components/ListEnvironmentFilterControl.tsx new file mode 100644 index 000000000000..91e6088b4d2a --- /dev/null +++ b/apps/web/src/components/ListEnvironmentFilterControl.tsx @@ -0,0 +1,130 @@ +import type { EnvironmentId } from "@t3tools/contracts"; +import { CheckIcon, ChevronsUpDownIcon } from "lucide-react"; +import { useMemo } from "react"; + +import { cn } from "../lib/utils"; +import { Button } from "./ui/button"; +import { Popover, PopoverPopup, PopoverTrigger } from "./ui/popover"; +import { + isAllEnvironmentsSelected, + isEnvironmentSelected, + toggleEnvironmentId, +} from "./listEnvironmentFilter"; + +export interface ListEnvironmentFilterOption { + readonly environmentId: EnvironmentId; + readonly label: string; +} + +export function ListEnvironmentFilterControl(props: { + environments: readonly ListEnvironmentFilterOption[]; + selectedEnvironmentIds: readonly EnvironmentId[]; + onSelectedEnvironmentIdsChange: (next: readonly EnvironmentId[]) => void; + /** Compact trigger for narrow sidebar; default is board/header-sized. */ + size?: "sm" | "xs"; + className?: string; + triggerClassName?: string; + "data-testid"?: string; +}) { + const { + environments, + selectedEnvironmentIds, + onSelectedEnvironmentIdsChange, + size = "sm", + className, + triggerClassName, + } = props; + + const allSelected = isAllEnvironmentsSelected(selectedEnvironmentIds); + const selectedCount = selectedEnvironmentIds.length; + + const triggerLabel = useMemo(() => { + if (allSelected || environments.length === 0) { + return "All environments"; + } + if (selectedCount === 1) { + const onlyId = selectedEnvironmentIds[0]; + return ( + environments.find((environment) => environment.environmentId === onlyId)?.label ?? + "1 environment" + ); + } + return `${selectedCount} environments`; + }, [allSelected, environments, selectedCount, selectedEnvironmentIds]); + + if (environments.length <= 1) { + return null; + } + + return ( +
+ + + } + > + {triggerLabel} + + + + +
+ {environments.map((environment) => { + const checked = isEnvironmentSelected( + selectedEnvironmentIds, + environment.environmentId, + ); + return ( + + ); + })} + + +
+ ); +} diff --git a/apps/web/src/components/OmegentDeepLinkCoordinator.tsx b/apps/web/src/components/OmegentDeepLinkCoordinator.tsx new file mode 100644 index 000000000000..0b1650cae0d7 --- /dev/null +++ b/apps/web/src/components/OmegentDeepLinkCoordinator.tsx @@ -0,0 +1,87 @@ +import { scopeThreadRef } from "@t3tools/client-runtime/environment"; +import { ThreadId } from "@t3tools/contracts"; +import { useNavigate } from "@tanstack/react-router"; +import { useEffect, useLayoutEffect, useRef } from "react"; + +import { + captureDeepLinkFromWindowLocation, + markDeepLinkNavigationIssued, + peekPendingDeepLink, + setPendingDeepLink, +} from "../deepLinkStore"; +import { parseOmegentDeepLink } from "../deepLinks"; +import { buildThreadRouteParams } from "../threadRoutes"; +import { findThreadRef, useThreadRefs } from "../state/entities"; +import { usePrimaryEnvironmentId } from "../state/environments"; + +function stripThreadQueryFromLocation(): void { + const next = new URL(window.location.href); + if (!next.searchParams.has("thread")) return; + next.searchParams.delete("thread"); + const search = next.searchParams.toString(); + const path = `${next.pathname}${search === "" ? "" : `?${search}`}${next.hash}`; + window.history.replaceState(window.history.state, "", path); +} + +/** + * Consumes `/?thread={id}#message-{messageId}` deep links: + * stashes intent immediately (before index auto-draft / welcome bootstrap can + * wipe `?thread=`), then navigates to the thread route. + * + * Does not require the thread to already be in the shell list — falls back to + * the primary environment id. The thread route owns missing/loading states. + */ +export function OmegentDeepLinkCoordinator() { + const navigate = useNavigate(); + const threadRefs = useThreadRefs(); + const primaryEnvironmentId = usePrimaryEnvironmentId(); + const handledThreadIdRef = useRef(null); + + // Capture before paint so sibling landing effects cannot replace the URL first. + useLayoutEffect(() => { + captureDeepLinkFromWindowLocation(); + }, []); + + useEffect(() => { + const fromUrl = parseOmegentDeepLink(new URL(window.location.href)); + const pending = peekPendingDeepLink(); + const threadId = fromUrl.threadId ?? pending?.threadId ?? null; + const messageId = fromUrl.messageId ?? pending?.messageId ?? null; + if (threadId === null) return; + if (handledThreadIdRef.current === threadId) return; + + // Keep store in sync when we only had URL intent (or vice versa). + setPendingDeepLink({ + threadId, + messageId, + awaitingNavigation: pending?.awaitingNavigation ?? true, + }); + + const knownRef = findThreadRef(ThreadId.make(threadId)); + // Prefer the shell list (correct env in multi-env). Fall back to primary + // so we never sit forever on `/` waiting for a ref that is slow/empty. + const threadRef = + knownRef ?? + (primaryEnvironmentId !== null + ? scopeThreadRef(primaryEnvironmentId, ThreadId.make(threadId)) + : null); + if (threadRef === null) { + // No environment yet — retry when catalog/primary becomes available. + return; + } + + handledThreadIdRef.current = threadId; + markDeepLinkNavigationIssued(threadId); + + void navigate({ + to: "/$environmentId/$threadId", + params: buildThreadRouteParams(threadRef), + replace: true, + ...(messageId !== null ? { hash: `message-${messageId}` } : {}), + }).then(() => { + stripThreadQueryFromLocation(); + }); + }, [navigate, primaryEnvironmentId, threadRefs]); + + return null; +} diff --git a/apps/web/src/components/ProjectFavicon.tsx b/apps/web/src/components/ProjectFavicon.tsx index 15597e786c31..e1b00d344321 100644 --- a/apps/web/src/components/ProjectFavicon.tsx +++ b/apps/web/src/components/ProjectFavicon.tsx @@ -180,7 +180,7 @@ export function ProjectFavicon(input: { ); } -function ProjectFaviconFallback({ +export function ProjectFaviconFallback({ className, colorClassName, icon: Icon, diff --git a/apps/web/src/components/ProjectScriptsControl.tsx b/apps/web/src/components/ProjectScriptsControl.tsx index 304922909b0a..93b6159cfbe8 100644 --- a/apps/web/src/components/ProjectScriptsControl.tsx +++ b/apps/web/src/components/ProjectScriptsControl.tsx @@ -10,7 +10,11 @@ import { import { ChevronDownIcon, DownloadIcon, PlusIcon, SettingsIcon } from "lucide-react"; import { useCallback, useMemo, useState } from "react"; -import { commandForProjectScript, primaryProjectScript } from "~/projectScripts"; +import { + commandForProjectScript, + primaryProjectScript, + projectScriptMenuLabel, +} from "~/projectScripts"; import { shortcutLabelForCommand } from "~/keybindings"; import { EMPTY_PROJECT_SCRIPT_INPUT, @@ -113,6 +117,8 @@ export default function ProjectScriptsControl({ command: fileScript.command, icon: fileScript.icon ?? "play", runOnWorktreeCreate: fileScript.runOnWorktreeCreate ?? false, + runOnWorktreeRemove: fileScript.runOnWorktreeRemove ?? false, + runOnPrMerged: fileScript.runOnPrMerged ?? false, keybinding: null, previewUrl: fileScript.previewUrl ?? null, autoOpenPreview: fileScript.previewUrl ? (fileScript.autoOpenPreview ?? false) : false, @@ -202,9 +208,7 @@ export default function ProjectScriptsControl({ onClick={() => onRunScript(script)} > - - {script.runOnWorktreeCreate ? `${script.name} (setup)` : script.name} - + {projectScriptMenuLabel(script)} {shortcutLabel && ( diff --git a/apps/web/src/components/ProviderUpdateLaunchNotification.environments.ts b/apps/web/src/components/ProviderUpdateLaunchNotification.environments.ts index 2fb9c16b654a..d7c8400b6cd5 100644 --- a/apps/web/src/components/ProviderUpdateLaunchNotification.environments.ts +++ b/apps/web/src/components/ProviderUpdateLaunchNotification.environments.ts @@ -1,9 +1,8 @@ -import type { ConnectionCatalogEntry } from "@t3tools/client-runtime/connection"; import type { ServerConfig } from "@t3tools/contracts"; import { useMemo } from "react"; import { useEnvironments, usePrimaryEnvironmentId } from "~/state/environments"; -import { isDesktopLocalConnectionTarget } from "~/connection/desktopLocal"; +import { isLocalConnectionTarget } from "~/connection/desktopLocal"; import { buildLocalEnvironmentUpdateGroups, deriveEnvironmentDisplayLabel, @@ -12,16 +11,6 @@ import { type LocalEnvironmentUpdateGroup, } from "./ProviderUpdateLaunchNotification.logic"; -/** - * A local environment is either the same-origin primary backend or a - * desktop-local secondary (the parallel WSL backend), which connects over - * loopback with a bearer token and carries a `local:` - * connection id. SSH, relay, and other remote targets are excluded. - */ -function isLocalConnectionTarget(target: ConnectionCatalogEntry["target"]): boolean { - return target._tag === "PrimaryConnectionTarget" || isDesktopLocalConnectionTarget(target); -} - function normalizeConnectionState(phase: string | undefined): EnvironmentUpdateConnectionState { switch (phase) { case "connected": diff --git a/apps/web/src/components/ServerUpdateAction.test.tsx b/apps/web/src/components/ServerUpdateAction.test.tsx index 6c388bca4f98..ee06c7c7f37a 100644 --- a/apps/web/src/components/ServerUpdateAction.test.tsx +++ b/apps/web/src/components/ServerUpdateAction.test.tsx @@ -404,6 +404,5 @@ describe("ServerUpdateProgress", () => { expect(markup).toContain('role="alert"'); expect(markup).toContain("The package could not be verified."); - expect(markup).not.toContain("animate-status-pulse"); }); }); diff --git a/apps/web/src/components/Sidebar.logic.test.ts b/apps/web/src/components/Sidebar.logic.test.ts index 33157e7b4b4b..d5cb8baea0ad 100644 --- a/apps/web/src/components/Sidebar.logic.test.ts +++ b/apps/web/src/components/Sidebar.logic.test.ts @@ -9,10 +9,15 @@ import { buildBulkTitleRegenerationContextMenuItem, buildBulkUnpinContextMenuItem, buildMultiSelectThreadContextMenuItems, + buildSidebarThreadWorktreeSections, + buildSidebarV2ThreadContextMenuItems, createThreadJumpHintVisibilityController, deleteSelectedThreadEntries, filterSidebarProjectScopeItems, + formatWorktreeGroupLabel, getSidebarThreadIdsToPrewarm, + resolveSidebarThreadPrewarmLimit, + SIDEBAR_THREAD_PREWARM_LIMIT, resolveAdjacentThreadId, reduceSidebarProjectScopeMenuState, getFallbackThreadIdAfterDelete, @@ -21,10 +26,17 @@ import { isContextMenuPointerDown, isSidebarNestedLinkClick, isTrailingDoubleClick, + normalizeWorktreePathForSidebarGroup, orderItemsByPreferredIds, resolveProjectStatusIndicator, + resolveSidebarProjectBadgeColorIndex, + resolveSidebarProjectBadgeLabel, + resolveSidebarNewThreadSeedContext, + resolveSidebarNewThreadEnvMode, + resolveSidebarStageBadgeLabel, resolveThreadRowClassName, resolveSidebarThreadStatus, + resolveSidebarV2TopStatus, resolveThreadStatusPill, resolveWorkingStartedAt, searchSidebarThreads, @@ -32,6 +44,9 @@ import { shouldClearThreadSelectionOnMouseDown, shouldRecedeSidebarThread, sortLogicalProjectsForSidebar, + groupSettledThreadsByRecencyForSidebarV2, + isThreadSettledForDisplay, + resolveSettledThreadTimestamp, sortSettledThreadsForSidebar, resolveSidebarDropTarget, pinOrderKeyBetween, @@ -56,6 +71,7 @@ import { ProjectId, ProviderInstanceId, ThreadId, + TurnId, } from "@t3tools/contracts"; import { @@ -68,6 +84,25 @@ import { const localEnvironmentId = EnvironmentId.make("environment-local"); +describe("sidebar recent project badges", () => { + it.each([ + ["example-org/scanner", "S"], + ["pingdotgg/t3code", "T3"], + ["effect-app/libs", "L"], + ["patroza/dotfiles-omarchy", "DO"], + ["configurator", "C"], + ])("derives a compact label for %s", (displayName, expected) => { + expect(resolveSidebarProjectBadgeLabel(displayName)).toBe(expected); + }); + + it("assigns the same bounded color index for a stable project key", () => { + const first = resolveSidebarProjectBadgeColorIndex("repository:t3code", 6); + expect(resolveSidebarProjectBadgeColorIndex("repository:t3code", 6)).toBe(first); + expect(first).toBeGreaterThanOrEqual(0); + expect(first).toBeLessThan(6); + }); +}); + describe("animateSidebarLayoutChanges", () => { const baseArgs: Parameters[0] = { active: null, @@ -306,19 +341,148 @@ describe("buildMultiSelectThreadContextMenuItems", () => { }); }); +describe("buildSidebarV2ThreadContextMenuItems", () => { + const baseInput = { + branch: null, + supportsSettlement: false, + isSettled: false, + supportsSnooze: false, + isSnoozed: false, + canSnoozeNow: true, + snoozePresets: [], + } as const; + + it("offers settlement actions matching the thread's state and server support", () => { + expect( + buildSidebarV2ThreadContextMenuItems({ + ...baseInput, + supportsSettlement: true, + })[0], + ).toEqual({ id: "settle", label: "Settle thread" }); + expect( + buildSidebarV2ThreadContextMenuItems({ + ...baseInput, + supportsSettlement: true, + isSettled: true, + })[0], + ).toEqual({ id: "unsettle", label: "Un-settle thread" }); + expect(buildSidebarV2ThreadContextMenuItems(baseInput)).toEqual([ + { id: "rename", label: "Rename thread" }, + { id: "mark-unread", label: "Mark unread" }, + { id: "copy-path", label: "Copy path", icon: "copy" }, + { id: "copy-thread-id", label: "Copy Thread ID", icon: "copy" }, + { id: "delete", label: "Delete", destructive: true, icon: "trash" }, + ]); + }); + + it("leads with a new-thread item for the thread's branch", () => { + expect( + buildSidebarV2ThreadContextMenuItems({ + ...baseInput, + branch: "feature/login", + supportsSettlement: true, + })[0], + ).toEqual({ id: "new-thread-on-branch", label: "New thread on feature/login" }); + }); + + it("offers snooze presets when supported, disabled while the thread blocks on the user", () => { + const presets = [ + { + id: "hour", + label: "In 1 hour", + whenLabel: "10:00 AM", + snoozedUntil: "2026-07-24T10:00:00.000Z", + }, + ] as const; + expect( + buildSidebarV2ThreadContextMenuItems({ + ...baseInput, + supportsSnooze: true, + snoozePresets: presets, + })[0], + ).toEqual({ + id: "snooze", + label: "Snooze", + disabled: false, + children: [{ id: "snooze:hour", label: "In 1 hour (10:00 AM)" }], + }); + expect( + buildSidebarV2ThreadContextMenuItems({ + ...baseInput, + supportsSnooze: true, + canSnoozeNow: false, + snoozePresets: presets, + })[0], + ).toMatchObject({ id: "snooze", disabled: true }); + }); + + it("offers wake instead of snooze for a snoozed thread", () => { + expect( + buildSidebarV2ThreadContextMenuItems({ + ...baseInput, + supportsSnooze: true, + isSnoozed: true, + })[0], + ).toEqual({ id: "unsnooze", label: "Wake thread" }); + }); +}); + +describe("resolveSidebarStageBadgeLabel", () => { + it("returns Nightly for nightly primary server versions", () => { + expect( + resolveSidebarStageBadgeLabel({ + primaryServerVersion: "0.0.28-nightly.20260616.12", + fallbackStageLabel: "Alpha", + }), + ).toBe("Nightly"); + }); + + it("returns the fallback label for stable primary server versions", () => { + expect( + resolveSidebarStageBadgeLabel({ + primaryServerVersion: "0.0.27", + fallbackStageLabel: "Alpha", + }), + ).toBe("Alpha"); + }); + + it("returns the fallback label when the primary server version is missing", () => { + expect( + resolveSidebarStageBadgeLabel({ + primaryServerVersion: null, + fallbackStageLabel: "Dev", + }), + ).toBe("Dev"); + }); + + it("returns the fallback label for malformed nightly prerelease versions", () => { + expect( + resolveSidebarStageBadgeLabel({ + primaryServerVersion: "0.0.28-nightly.20260616", + fallbackStageLabel: "Alpha", + }), + ).toBe("Alpha"); + }); +}); + function makeLatestTurn(overrides?: { completedAt?: string | null; startedAt?: string | null; + state?: OrchestrationLatestTurn["state"]; }): OrchestrationLatestTurn { + const state = overrides?.state ?? "completed"; return { turnId: "turn-1" as never, - state: "completed", + state, assistantMessageId: null, requestedAt: "2026-03-09T10:00:00.000Z", - startedAt: - overrides?.startedAt !== undefined ? overrides.startedAt : "2026-03-09T10:00:00.000Z", + startedAt: overrides?.startedAt ?? "2026-03-09T10:00:00.000Z", completedAt: - overrides?.completedAt !== undefined ? overrides.completedAt : "2026-03-09T10:05:00.000Z", + overrides?.completedAt !== undefined + ? overrides.completedAt + : state === "completed" + ? "2026-03-09T10:05:00.000Z" + : null, }; } @@ -473,6 +637,26 @@ describe("getSidebarThreadIdsToPrewarm", () => { }); }); +describe("resolveSidebarThreadPrewarmLimit", () => { + it("prewarms visible rows when the pointer can hover", () => { + expect(resolveSidebarThreadPrewarmLimit({ hasCoarsePointer: false })).toBe( + SIDEBAR_THREAD_PREWARM_LIMIT, + ); + }); + + it("prewarms nothing behind a coarse pointer", () => { + // Each prewarmed row holds a live thread-detail subscription, so a touch + // client would otherwise retain ten threads of history it never asked for. + expect(resolveSidebarThreadPrewarmLimit({ hasCoarsePointer: true })).toBe(0); + expect( + getSidebarThreadIdsToPrewarm( + ["t1", "t2"], + resolveSidebarThreadPrewarmLimit({ hasCoarsePointer: true }), + ), + ).toEqual([]); + }); +}); + describe("shouldClearThreadSelectionOnMouseDown", () => { it("preserves selection for thread items", () => { const child = { @@ -519,6 +703,280 @@ describe("isTrailingDoubleClick", () => { }); }); +describe("resolveSidebarNewThreadEnvMode", () => { + it("uses the app default when the caller does not request a specific mode", () => { + expect( + resolveSidebarNewThreadEnvMode({ + defaultEnvMode: "worktree", + }), + ).toBe("worktree"); + }); + + it("preserves an explicit requested mode over the app default", () => { + expect( + resolveSidebarNewThreadEnvMode({ + requestedEnvMode: "local", + defaultEnvMode: "worktree", + }), + ).toBe("local"); + }); +}); + +describe("resolveSidebarNewThreadSeedContext", () => { + it("inherits an active draft worktree context even when the default is new worktree mode", () => { + expect( + resolveSidebarNewThreadSeedContext({ + projectId: "project-1", + defaultEnvMode: "worktree", + activeThread: { + projectId: "project-1", + branch: "feature/existing", + worktreePath: "/repo/.t3/worktrees/existing", + }, + activeDraftThread: { + projectId: "project-1", + branch: "feature/draft", + worktreePath: "/repo/.t3/worktrees/draft", + envMode: "worktree", + startFromOrigin: true, + }, + }), + ).toEqual({ + branch: "feature/draft", + worktreePath: "/repo/.t3/worktrees/draft", + envMode: "local", + startFromOrigin: true, + }); + }); + + it("inherits an active server thread worktree context even when the default is new worktree mode", () => { + expect( + resolveSidebarNewThreadSeedContext({ + projectId: "project-1", + defaultEnvMode: "worktree", + activeThread: { + projectId: "project-1", + branch: "feature/existing", + worktreePath: "/repo/.t3/worktrees/existing", + }, + activeDraftThread: null, + }), + ).toEqual({ + branch: "feature/existing", + worktreePath: "/repo/.t3/worktrees/existing", + envMode: "local", + }); + }); + + it("inherits the active server thread context when creating a new thread in the same project", () => { + expect( + resolveSidebarNewThreadSeedContext({ + projectId: "project-1", + defaultEnvMode: "local", + activeThread: { + projectId: "project-1", + branch: "effect-atom", + worktreePath: null, + }, + activeDraftThread: null, + }), + ).toEqual({ + branch: "effect-atom", + worktreePath: null, + envMode: "local", + }); + }); + + it("prefers the active draft thread context when it matches the target project", () => { + expect( + resolveSidebarNewThreadSeedContext({ + projectId: "project-1", + defaultEnvMode: "local", + activeThread: { + projectId: "project-1", + branch: "effect-atom", + worktreePath: null, + }, + activeDraftThread: { + projectId: "project-1", + branch: "feature/new-draft", + worktreePath: "/repo/worktree", + envMode: "worktree", + startFromOrigin: true, + }, + }), + ).toEqual({ + branch: "feature/new-draft", + worktreePath: "/repo/worktree", + envMode: "local", + startFromOrigin: true, + }); + }); + + it("falls back to the default env mode when there is no matching active thread context", () => { + expect( + resolveSidebarNewThreadSeedContext({ + projectId: "project-2", + defaultEnvMode: "worktree", + activeThread: { + projectId: "project-1", + branch: "effect-atom", + worktreePath: null, + }, + activeDraftThread: null, + }), + ).toEqual({ + envMode: "worktree", + }); + }); +}); + +describe("buildSidebarThreadWorktreeSections", () => { + it("groups multiple threads on the same environment project worktree", () => { + const sections = buildSidebarThreadWorktreeSections([ + makeSidebarThreadSummary({ + id: ThreadId.make("thread-a"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + branch: "feature/a", + worktreePath: "/repo/.t3/worktrees/feature-a/", + }), + makeSidebarThreadSummary({ + id: ThreadId.make("thread-b"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + branch: "feature/a", + worktreePath: "/repo/.t3/worktrees/feature-a", + }), + makeSidebarThreadSummary({ + id: ThreadId.make("thread-c"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + branch: "feature/b", + worktreePath: "/repo/.t3/worktrees/feature-b", + }), + ]); + + expect(sections).toHaveLength(2); + expect(sections[0]?.kind).toBe("worktree"); + if (sections[0]?.kind !== "worktree") { + throw new Error("expected worktree section"); + } + expect(sections[0].label).toBe("feature/a · feature-a"); + expect(sections[0].worktreePath).toBe("/repo/.t3/worktrees/feature-a"); + expect(sections[0].threads.map((thread) => thread.id)).toEqual([ + ThreadId.make("thread-a"), + ThreadId.make("thread-b"), + ]); + expect(sections[1]?.kind).toBe("thread"); + if (sections[1]?.kind !== "thread") { + throw new Error("expected thread section"); + } + expect(sections[1].checkoutPath).toBe("/repo/.t3/worktrees/feature-b"); + }); + + it("groups multiple local checkout threads by resolved project path", () => { + const sections = buildSidebarThreadWorktreeSections( + [ + makeSidebarThreadSummary({ + id: ThreadId.make("thread-a"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + branch: "main", + worktreePath: null, + }), + makeSidebarThreadSummary({ + id: ThreadId.make("thread-b"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + branch: "main", + worktreePath: null, + }), + ], + { + resolveLocalCheckoutPath: () => "/repo/t3code/", + }, + ); + + expect(sections).toHaveLength(1); + expect(sections[0]?.kind).toBe("worktree"); + if (sections[0]?.kind !== "worktree") { + throw new Error("expected checkout section"); + } + expect(sections[0].source).toBe("local"); + expect(sections[0].label).toBe("main · t3code"); + expect(sections[0].checkoutPath).toBe("/repo/t3code"); + expect(sections[0].worktreePath).toBeNull(); + expect(sections[0].threads.map((thread) => thread.id)).toEqual([ + ThreadId.make("thread-a"), + ThreadId.make("thread-b"), + ]); + }); + + it("attaches checkoutPath to single local checkout threads", () => { + const sections = buildSidebarThreadWorktreeSections( + [ + makeSidebarThreadSummary({ + id: ThreadId.make("thread-a"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + branch: "main", + worktreePath: null, + }), + ], + { + resolveLocalCheckoutPath: () => "/repo/t3code/", + }, + ); + + expect(sections).toHaveLength(1); + expect(sections[0]).toEqual({ + kind: "thread", + checkoutPath: "/repo/t3code", + thread: expect.objectContaining({ id: ThreadId.make("thread-a") }), + }); + }); + + it("does not group identical worktree paths across environments or projects", () => { + const sections = buildSidebarThreadWorktreeSections([ + makeSidebarThreadSummary({ + id: ThreadId.make("thread-env-1"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-1"), + worktreePath: "/repo/worktree", + }), + makeSidebarThreadSummary({ + id: ThreadId.make("thread-env-2"), + environmentId: EnvironmentId.make("env-2"), + projectId: ProjectId.make("project-1"), + worktreePath: "/repo/worktree", + }), + makeSidebarThreadSummary({ + id: ThreadId.make("thread-project-2"), + environmentId: EnvironmentId.make("env-1"), + projectId: ProjectId.make("project-2"), + worktreePath: "/repo/worktree", + }), + ]); + + expect(sections.map((section) => section.kind)).toEqual(["thread", "thread", "thread"]); + for (const section of sections) { + if (section.kind !== "thread") { + throw new Error("expected thread section"); + } + expect(section.checkoutPath).toBe("/repo/worktree"); + } + }); + + it("normalizes worktree paths and formats labels", () => { + expect(normalizeWorktreePathForSidebarGroup(" /repo/worktree// ")).toBe("/repo/worktree"); + expect(formatWorktreeGroupLabel({ worktreePath: "C:\\repo\\wt", branch: null })).toBe("wt"); + expect( + formatWorktreeGroupLabel({ worktreePath: "/repo/t3code", branch: null, source: "local" }), + ).toBe("Local checkout · t3code"); + }); +}); + describe("isSidebarNestedLinkClick", () => { const linkTarget = { closest: (selector: string) => (selector === "a[href]" ? ({} as Element) : null), @@ -1845,6 +2303,199 @@ describe("sortSettledThreadsForSidebar", () => { }); }); +describe("resolveSettledThreadTimestamp", () => { + it("prefers explicit settledAt over later message activity", () => { + expect( + resolveSettledThreadTimestamp({ + settledAt: "2026-03-09T10:00:00.000Z", + latestUserMessageAt: "2026-03-09T12:00:00.000Z", + latestTurn: null, + updatedAt: "2026-03-09T13:00:00.000Z", + }), + ).toBe("2026-03-09T10:00:00.000Z"); + }); + + it("falls back to the latest activity stamp when settledAt is missing", () => { + expect( + resolveSettledThreadTimestamp({ + settledAt: null, + latestUserMessageAt: "2026-03-09T09:00:00.000Z", + latestTurn: makeLatestTurn({ completedAt: "2026-03-09T11:00:00.000Z" }), + updatedAt: "2026-03-09T08:00:00.000Z", + }), + ).toBe("2026-03-09T11:00:00.000Z"); + }); +}); + +describe("isThreadSettledForDisplay", () => { + const now = "2026-04-10T00:00:00.000Z"; + const baseThread = { + id: ThreadId.make("thread-settled-display"), + environmentId: localEnvironmentId, + projectId: ProjectId.make("project-1"), + title: "Settled display", + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, + runtimeMode: DEFAULT_RUNTIME_MODE, + interactionMode: DEFAULT_INTERACTION_MODE, + session: null, + createdAt: "2026-04-01T00:00:00.000Z", + updatedAt: now, + archivedAt: null, + latestTurn: null, + latestUserMessageAt: "2026-04-01T00:00:00.000Z", + branch: null, + worktreePath: null, + hasPendingApprovals: false, + hasPendingUserInput: false, + hasActionableProposedPlan: false, + settledOverride: "settled" as const, + settledAt: now, + }; + + it("never treats threads as settled when the server lacks threadSettlement", () => { + const serverConfigs = { + get(_environmentId: string) { + return { + environment: { + capabilities: { threadSettlement: false }, + }, + }; + }, + }; + + expect( + isThreadSettledForDisplay(baseThread, { + serverConfigs, + now, + autoSettleAfterDays: 7, + changeRequestState: null, + }), + ).toBe(false); + }); + + it("honors settled override when the server supports settlement", () => { + const serverConfigs = { + get(_environmentId: string) { + return { + environment: { + capabilities: { threadSettlement: true }, + }, + }; + }, + }; + + expect( + isThreadSettledForDisplay(baseThread, { + serverConfigs, + now, + autoSettleAfterDays: 7, + changeRequestState: null, + }), + ).toBe(true); + }); + + it("does not client-auto-settle a merged or closed PR; the server stamps settledOverride", () => { + const serverConfigs = { + get(_environmentId: string) { + return { + environment: { + capabilities: { threadSettlement: true }, + }, + }; + }, + }; + // Activity well past the queued-turn grace window so PR auto-settle is + // not blocked by a just-sent message without a turn. + const activeThread = { + ...baseThread, + settledOverride: null, + settledAt: null, + latestUserMessageAt: "2026-04-01T00:00:00.000Z", + }; + + expect( + isThreadSettledForDisplay(activeThread, { + serverConfigs, + now, + autoSettleAfterDays: null, + changeRequestState: "merged", + }), + ).toBe(false); + expect( + isThreadSettledForDisplay(activeThread, { + serverConfigs, + now, + autoSettleAfterDays: null, + changeRequestState: "closed", + }), + ).toBe(false); + expect( + isThreadSettledForDisplay(activeThread, { + serverConfigs, + now, + autoSettleAfterDays: null, + changeRequestState: null, + }), + ).toBe(false); + }); +}); + +describe("groupSettledThreadsByRecencyForSidebarV2", () => { + // Fixed local afternoon so last-hour and earlier-today both fit the day. + const now = new Date(2026, 2, 15, 14, 30, 0); + + const settled = (input: { + id: string; + settledAt?: string | null; + latestUserMessageAt?: string | null; + updatedAt?: string; + }) => ({ + id: input.id, + settledAt: input.settledAt ?? null, + latestUserMessageAt: input.latestUserMessageAt ?? null, + latestTurn: null, + updatedAt: input.updatedAt ?? "2026-03-09T09:00:00.000Z", + }); + + it("groups by settle/activity time and shows headers when multiple buckets", () => { + const lastHourIso = new Date(now.getTime() - 5 * 60_000).toISOString(); + const olderIso = new Date( + new Date(2026, 2, 15).getTime() - 40 * 24 * 60 * 60 * 1000, + ).toISOString(); + const ordered = sortSettledThreadsForSidebar([ + settled({ id: "old", settledAt: olderIso }), + settled({ id: "fresh", settledAt: lastHourIso }), + ]); + const layout = groupSettledThreadsByRecencyForSidebarV2(ordered, now); + expect(layout.showHeaders).toBe(true); + expect(layout.groups.map((group) => group.id)).toEqual(["last_hour", "older"]); + expect(layout.groups[0]?.threads.map((thread) => thread.id)).toEqual(["fresh"]); + expect(layout.groups[1]?.threads.map((thread) => thread.id)).toEqual(["old"]); + }); + + it("suppresses headers when every row is in one bucket", () => { + const lastHourIso = new Date(now.getTime() - 5 * 60_000).toISOString(); + const layout = groupSettledThreadsByRecencyForSidebarV2( + [settled({ id: "a", settledAt: lastHourIso }), settled({ id: "b", settledAt: lastHourIso })], + now, + ); + expect(layout.showHeaders).toBe(false); + expect(layout.groups).toHaveLength(1); + expect(layout.groups[0]?.threads.map((thread) => thread.id)).toEqual(["a", "b"]); + }); + + it("preserves input order within a bucket", () => { + const t1 = new Date(now.getTime() - 2 * 60_000).toISOString(); + const t2 = new Date(now.getTime() - 10 * 60_000).toISOString(); + // Caller is expected to pre-sort; newer first. + const layout = groupSettledThreadsByRecencyForSidebarV2( + [settled({ id: "newer", settledAt: t1 }), settled({ id: "older-hour", settledAt: t2 })], + now, + ); + expect(layout.groups[0]?.threads.map((thread) => thread.id)).toEqual(["newer", "older-hour"]); + }); +}); + describe("resolveWorkingStartedAt", () => { const session = { threadId: ThreadId.make("thread-1"), @@ -1963,6 +2614,38 @@ describe("resolveThreadStatusPill", () => { ).toMatchObject({ label: "Working", pulse: true }); }); + it("shows that an interrupted mid-turn session needs a wake-up", () => { + expect( + resolveThreadStatusPill({ + thread: { + ...baseThread, + latestTurn: makeLatestTurn({ state: "running" }), + session: { + ...baseThread.session, + status: "interrupted", + activeTurnId: null, + }, + }, + }), + ).toMatchObject({ label: "Wake Required", pulse: false }); + }); + + it("does not show wake-up for zombie interrupted sessions with a completed turn", () => { + expect( + resolveThreadStatusPill({ + thread: { + ...baseThread, + latestTurn: makeLatestTurn({ state: "completed" }), + session: { + ...baseThread.session, + status: "interrupted", + activeTurnId: null, + }, + }, + }), + ).toBeNull(); + }); + it("shows plan ready when a settled plan turn has a proposed plan ready for follow-up", () => { expect( resolveThreadStatusPill({ @@ -1980,6 +2663,24 @@ describe("resolveThreadStatusPill", () => { ).toMatchObject({ label: "Plan Ready", pulse: false }); }); + it("shows plan ready over working when a plan is captured mid-turn", () => { + expect( + resolveThreadStatusPill({ + thread: { + ...baseThread, + hasActionableProposedPlan: true, + interactionMode: "plan", + latestTurn: makeLatestTurn({ completedAt: null }), + session: { + ...baseThread.session, + status: "running", + activeTurnId: TurnId.make("turn-running"), + }, + }, + }), + ).toMatchObject({ label: "Plan Ready", pulse: false }); + }); + it("does not manufacture completed state without a client visit marker", () => { expect( resolveThreadStatusPill({ @@ -2122,6 +2823,8 @@ function makeThread(overrides: Partial = {}): Thread { interactionMode: DEFAULT_INTERACTION_MODE, session: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], createdAt: "2026-03-09T10:00:00.000Z", archivedAt: null, @@ -2139,6 +2842,19 @@ function makeThread(overrides: Partial = {}): Thread { }; } +function makeSidebarThreadSummary( + overrides: Partial = {}, +): SidebarThreadSummary { + return { + ...makeThread(overrides), + latestUserMessageAt: null, + hasPendingApprovals: false, + hasPendingUserInput: false, + hasActionableProposedPlan: false, + ...overrides, + }; +} + describe("getFallbackThreadIdAfterDelete", () => { it("returns the top remaining thread in the deleted thread's project sidebar order", () => { const fallbackThreadId = getFallbackThreadIdAfterDelete({ @@ -2148,24 +2864,28 @@ describe("getFallbackThreadIdAfterDelete", () => { projectId: ProjectId.make("project-1"), createdAt: "2026-03-09T10:00:00.000Z", messages: [], + queuedMessages: [], }), makeThread({ id: ThreadId.make("thread-active"), projectId: ProjectId.make("project-1"), createdAt: "2026-03-09T10:05:00.000Z", messages: [], + queuedMessages: [], }), makeThread({ id: ThreadId.make("thread-newest"), projectId: ProjectId.make("project-1"), createdAt: "2026-03-09T10:10:00.000Z", messages: [], + queuedMessages: [], }), makeThread({ id: ThreadId.make("thread-other-project"), projectId: ProjectId.make("project-2"), createdAt: "2026-03-09T10:20:00.000Z", messages: [], + queuedMessages: [], }), ], deletedThreadId: ThreadId.make("thread-active"), @@ -2183,18 +2903,21 @@ describe("getFallbackThreadIdAfterDelete", () => { projectId: ProjectId.make("project-1"), createdAt: "2026-03-09T10:05:00.000Z", messages: [], + queuedMessages: [], }), makeThread({ id: ThreadId.make("thread-newest"), projectId: ProjectId.make("project-1"), createdAt: "2026-03-09T10:10:00.000Z", messages: [], + queuedMessages: [], }), makeThread({ id: ThreadId.make("thread-next"), projectId: ProjectId.make("project-1"), createdAt: "2026-03-09T10:07:00.000Z", messages: [], + queuedMessages: [], }), ], deletedThreadId: ThreadId.make("thread-active"), @@ -2472,6 +3195,25 @@ describe("sortLogicalProjectsForSidebar", () => { }); }); +describe("resolveSidebarV2TopStatus", () => { + it("shows monitoring as its own calm status, not as Working", () => { + // Board cards read this. Folding monitoring into Working gave a watch loop + // the active-progress shimmer, which is what the v1 pill (pulse: false) and + // the v2 sidebar row both deliberately avoid. + const monitoring = resolveSidebarV2TopStatus({ status: "monitoring", isUnread: false }); + expect(monitoring?.label).toBe("Monitoring"); + expect(monitoring?.icon).toBeNull(); + expect(monitoring?.className).not.toContain("animate-sidebar-working-text"); + }); + + it("keeps working animated so the two remain distinguishable", () => { + const working = resolveSidebarV2TopStatus({ status: "working", isUnread: false }); + expect(working?.label).toBe("Working"); + expect(working?.icon).toBe("working"); + expect(working?.className).toContain("animate-sidebar-working-text"); + }); +}); + describe("resolveSidebarDropVerb", () => { it("names the state change a cross-section drop performs", () => { expect(resolveSidebarDropVerb("active", "pinned")).toBe("pin"); diff --git a/apps/web/src/components/Sidebar.logic.ts b/apps/web/src/components/Sidebar.logic.ts index 0150eb473d51..f60661adf6f1 100644 --- a/apps/web/src/components/Sidebar.logic.ts +++ b/apps/web/src/components/Sidebar.logic.ts @@ -1,6 +1,11 @@ import { threadPullRequestSearchTerms } from "@t3tools/shared/threadPullRequests"; import * as React from "react"; import { defaultAnimateLayoutChanges, type AnimateLayoutChanges } from "@dnd-kit/sortable"; +import { + groupThreadsByRecency, + shouldShowRecencySectionHeaders, + type ThreadRecencyGroup, +} from "@t3tools/client-runtime/state/thread-recency-groups"; import { isAtomCommandInterrupted, type AtomCommandResult, @@ -19,7 +24,46 @@ import { } from "../lib/threadSort"; import type { SidebarThreadSummary, Thread } from "../types"; import { cn } from "../lib/utils"; -import { isLatestTurnSettled } from "../session-logic"; +import { sessionNeedsWakeUp } from "@t3tools/shared/sessionWake"; +import { isLatestTurnSettled, shouldShowPlanReadyStatus } from "../session-logic"; +import { resolveServerBackedAppStageLabel } from "../branding.logic"; +import type { SnoozePreset } from "./Sidebar.snooze"; + +export { resolveSettledThreadTimestamp }; + +type ChangeRequestStateLike = "open" | "closed" | "merged"; + +export function resolveSidebarProjectBadgeLabel(displayName: string): string { + const leafName = displayName.split("/").findLast(Boolean) ?? displayName; + const normalized = leafName.trim(); + if (!normalized) return "?"; + + const digitMatch = normalized.match(/^([a-zA-Z]+\d+)/); + if (digitMatch?.[1]) return digitMatch[1].slice(0, 3).toUpperCase(); + + const words = normalized.split(/[^a-zA-Z0-9]+/).filter(Boolean); + if (words.length > 1) { + return words + .slice(0, 3) + .map((word) => word[0]) + .join("") + .toUpperCase(); + } + + return normalized[0]?.toUpperCase() ?? "?"; +} + +export function resolveSidebarProjectBadgeColorIndex( + projectKey: string, + colorCount: number, +): number { + if (colorCount <= 0) return 0; + let hash = 0; + for (const character of projectKey) { + hash = (hash * 31 + character.charCodeAt(0)) >>> 0; + } + return hash % colorCount; +} const THREAD_SELECTION_SAFE_SELECTOR = "[data-thread-item], [data-thread-selection-safe]"; export const THREAD_JUMP_HINT_SHOW_DELAY_MS = 200; @@ -29,7 +73,31 @@ export const THREAD_JUMP_HINT_SHOW_DELAY_MS = 200; // activities, growing as agents work) for as long as the row stays visible, // so this limit is a direct renderer-heap and server-load multiplier — keep // it small; cold opens still render instantly from the cached snapshot. -const SIDEBAR_THREAD_PREWARM_LIMIT = 3; +export const SIDEBAR_THREAD_PREWARM_LIMIT = 3; +// Settled-tail paging: recent history is the common lookup; the deep tail +// stays behind an explicit Show more. Shared by SidebarV2, classic Recent +// (hide-settled shelf + recency headers), and the board. +export const SETTLED_TAIL_INITIAL_COUNT = 10; +export const SETTLED_TAIL_PAGE_COUNT = 25; +export type SidebarNewThreadEnvMode = "local" | "worktree"; +export type SidebarThreadWorktreeSection = + | { + kind: "thread"; + thread: SidebarThreadSummary; + /** Resolved checkout path for PR/git status when this thread is not grouped. */ + checkoutPath?: string; + } + | { + kind: "worktree"; + key: string; + label: string; + branch: string | null; + checkoutPath: string; + source: "local" | "worktree"; + worktreePath: string | null; + threads: SidebarThreadSummary[]; + }; + // A small buffer keeps the next few rows warm without leasing every row that // content-visibility leaves mounted below the scroll viewport. const SIDEBAR_ROW_SUBSCRIPTION_OVERSCAN_PX = 160; @@ -474,6 +542,111 @@ export function buildBulkTitleRegenerationContextMenuItem(input: { }; } +export type ThreadContextMenuAction = + | "rename" + | "mark-unread" + | "copy-path" + | "copy-thread-id" + | "delete"; + +export function buildThreadContextMenuItems(): readonly ContextMenuItem[] { + return [ + { id: "rename", label: "Rename thread" }, + { id: "mark-unread", label: "Mark unread" }, + { id: "copy-path", label: "Copy Path" }, + { id: "copy-thread-id", label: "Copy Thread ID" }, + { id: "delete", label: "Delete", destructive: true, icon: "trash" }, + ]; +} + +export type SidebarV2ThreadContextMenuAction = + | "new-thread-on-branch" + | "settle" + | "unsettle" + | "snooze" + | `snooze:${string}` + | "unsnooze" + | "pin" + | "unpin" + | "rename" + | "regenerate-title" + | "mark-unread" + | "copy-path" + | "copy-thread-id" + | "copy-branch" + | "delete"; + +// Single source for the per-thread menu on both v2 surfaces (sidebar rows +// and board cards) so the two can't drift apart item-by-item. +export function buildSidebarV2ThreadContextMenuItems(input: { + branch: string | null; + supportsSettlement: boolean; + isSettled: boolean; + supportsSnooze: boolean; + isSnoozed: boolean; + supportsPinning?: boolean; + isPinned?: boolean; + canSnoozeNow: boolean; + snoozePresets: ReadonlyArray; + supportsTitleRegeneration?: boolean; + isRegeneratingTitle?: boolean; +}): readonly ContextMenuItem[] { + return [ + ...(input.branch + ? [ + { + id: "new-thread-on-branch", + label: `New thread on ${input.branch}`, + } as const, + ] + : []), + ...(input.supportsPinning + ? [ + input.isPinned + ? ({ id: "unpin", label: "Unpin thread" } as const) + : ({ id: "pin", label: "Pin thread" } as const), + ] + : []), + ...(input.supportsSettlement + ? [ + input.isSettled + ? ({ id: "unsettle", label: "Un-settle thread" } as const) + : ({ id: "settle", label: "Settle thread" } as const), + ] + : []), + ...(input.supportsSnooze + ? [ + input.isSnoozed + ? ({ id: "unsnooze", label: "Wake thread" } as const) + : ({ + id: "snooze", + label: "Snooze", + disabled: !input.canSnoozeNow, + children: input.snoozePresets.map((preset) => ({ + id: `snooze:${preset.id}` as const, + label: `${preset.label} (${preset.whenLabel})`, + })), + } satisfies ContextMenuItem), + ] + : []), + { id: "rename", label: "Rename thread" }, + ...(input.supportsTitleRegeneration + ? [ + { + id: "regenerate-title", + label: input.isRegeneratingTitle ? "Regenerating…" : "Regenerate title", + disabled: input.isRegeneratingTitle === true, + } as const, + ] + : []), + { id: "mark-unread", label: "Mark unread" }, + { id: "copy-path", label: "Copy path", icon: "copy" }, + { id: "copy-thread-id", label: "Copy Thread ID", icon: "copy" }, + ...(input.branch ? ([{ id: "copy-branch", label: "Copy branch", icon: "copy" }] as const) : []), + { id: "delete", label: "Delete", destructive: true, icon: "trash" }, + ]; +} + /** * Bulk unpin follows the same "count only what the action will touch" rule * as title regeneration: on a mixed selection the label counts the pinned @@ -494,6 +667,7 @@ export interface ThreadStatusPill { | "Completed" | "Pending Approval" | "Awaiting Input" + | "Wake Required" | "Plan Ready"; colorClass: string; dotClass: string; @@ -506,6 +680,7 @@ export interface ThreadStatusPill { const THREAD_STATUS_PRIORITY: Record = { "Pending Approval": 6, "Awaiting Input": 5, + "Wake Required": 4, Working: 4, Connecting: 4, "Plan Ready": 3, @@ -526,6 +701,13 @@ type ThreadStatusInput = Pick< lastVisitedAt?: string | undefined; }; +export function resolveSidebarStageBadgeLabel(input: { + primaryServerVersion: string | null | undefined; + fallbackStageLabel: string; +}): string { + return resolveServerBackedAppStageLabel(input); +} + export interface ThreadJumpHintVisibilityController { sync: (shouldShow: boolean) => void; dispose: () => void; @@ -611,15 +793,59 @@ export function useThreadJumpHintVisibility(): { }; } +/** + * Whether `completedAt` is a completion the user has not seen yet: a missing + * last-visited timestamp counts as seen, an unparsable one as unseen. + */ +export function isCompletionUnseen( + completedAt: string | null | undefined, + lastVisitedAt: string | null | undefined, +): boolean { + if (!completedAt) return false; + const completedAtMs = Date.parse(completedAt); + if (Number.isNaN(completedAtMs)) return false; + if (!lastVisitedAt) return false; + + const lastVisitedAtMs = Date.parse(lastVisitedAt); + if (Number.isNaN(lastVisitedAtMs)) return true; + return completedAtMs > lastVisitedAtMs; +} + export function hasUnseenCompletion(thread: ThreadStatusInput): boolean { - if (!thread.latestTurn?.completedAt) return false; - const completedAt = Date.parse(thread.latestTurn.completedAt); - if (Number.isNaN(completedAt)) return false; - if (!thread.lastVisitedAt) return false; + return isCompletionUnseen(thread.latestTurn?.completedAt, thread.lastVisitedAt); +} - const lastVisitedAt = Date.parse(thread.lastVisitedAt); - if (Number.isNaN(lastVisitedAt)) return true; - return completedAt > lastVisitedAt; +/** + * Shared settled classification for display surfaces (sidebar v1/v2, board), + * so they always agree on what is settled. Threads on servers without the + * settlement capability (old server, or descriptor not loaded yet) never + * classify as settled: the user could neither un-settle nor pin them, so + * auto-settling them would strand rows in a tail with no working affordances. + */ +export function isThreadSettledForDisplay( + thread: { + readonly environmentId: string; + readonly settledOverride: "settled" | "active" | null; + }, + input: { + serverConfigs: { + get(environmentId: string): + | { + readonly environment: { + readonly capabilities: { readonly threadSettlement?: boolean }; + }; + } + | undefined; + }; + now: string; + autoSettleAfterDays: number | null; + changeRequestState: ChangeRequestStateLike | null; + }, +): boolean { + const supportsSettlement = + input.serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSettlement === + true; + return supportsSettlement && thread.settledOverride === "settled"; } export function shouldClearThreadSelectionOnMouseDown(target: HTMLElement | null): boolean { @@ -636,6 +862,191 @@ export function isTrailingDoubleClick(detail: number): boolean { return detail > 1; } +export function resolveSidebarNewThreadEnvMode(input: { + requestedEnvMode?: SidebarNewThreadEnvMode; + defaultEnvMode: SidebarNewThreadEnvMode; +}): SidebarNewThreadEnvMode { + return input.requestedEnvMode ?? input.defaultEnvMode; +} + +export function resolveSidebarNewThreadSeedContext(input: { + projectId: string; + defaultEnvMode: SidebarNewThreadEnvMode; + activeThread?: { + projectId: string; + branch: string | null; + worktreePath: string | null; + } | null; + activeDraftThread?: { + projectId: string; + branch: string | null; + worktreePath: string | null; + envMode: SidebarNewThreadEnvMode; + startFromOrigin: boolean; + } | null; +}): { + branch?: string | null; + worktreePath?: string | null; + envMode: SidebarNewThreadEnvMode; + startFromOrigin?: boolean; +} { + if ( + input.activeDraftThread?.projectId === input.projectId && + input.activeDraftThread.worktreePath + ) { + return { + branch: input.activeDraftThread.branch, + worktreePath: input.activeDraftThread.worktreePath, + envMode: "local", + startFromOrigin: input.activeDraftThread.startFromOrigin, + }; + } + + if (input.activeThread?.projectId === input.projectId && input.activeThread.worktreePath) { + return { + branch: input.activeThread.branch, + worktreePath: input.activeThread.worktreePath, + envMode: "local", + }; + } + + if (input.defaultEnvMode === "worktree") { + return { + envMode: "worktree", + }; + } + + if (input.activeDraftThread?.projectId === input.projectId) { + return { + branch: input.activeDraftThread.branch, + worktreePath: input.activeDraftThread.worktreePath, + envMode: input.activeDraftThread.envMode, + startFromOrigin: input.activeDraftThread.startFromOrigin, + }; + } + + if (input.activeThread?.projectId === input.projectId) { + return { + branch: input.activeThread.branch, + worktreePath: input.activeThread.worktreePath, + envMode: input.activeThread.worktreePath ? "worktree" : "local", + }; + } + + return { + envMode: input.defaultEnvMode, + }; +} + +export function normalizeWorktreePathForSidebarGroup(worktreePath: string | null): string | null { + const trimmed = worktreePath?.trim() ?? ""; + if (trimmed.length === 0) { + return null; + } + const withoutTrailingSeparators = trimmed.replace(/[\\/]+$/u, ""); + return withoutTrailingSeparators.length > 0 ? withoutTrailingSeparators : trimmed; +} + +export function formatWorktreeGroupLabel(input: { + worktreePath: string; + branch: string | null; + source?: "local" | "worktree"; +}): string { + const pathSegments = input.worktreePath.split(/[\\/]/u); + const pathLabel = pathSegments.findLast((segment) => segment.length > 0) ?? input.worktreePath; + if (input.branch) { + return `${input.branch} · ${pathLabel}`; + } + return input.source === "local" ? `Local checkout · ${pathLabel}` : pathLabel; +} + +function checkoutSectionBucket( + thread: SidebarThreadSummary, + resolveLocalCheckoutPath?: (thread: SidebarThreadSummary) => string | null, +): { + key: string; + checkoutPath: string; + source: "local" | "worktree"; + worktreePath: string | null; +} | null { + const worktreePath = normalizeWorktreePathForSidebarGroup(thread.worktreePath); + if (worktreePath) { + return { + key: `${thread.environmentId}:${thread.projectId}:worktree:${worktreePath}`, + checkoutPath: worktreePath, + source: "worktree", + worktreePath, + }; + } + const localCheckoutPath = normalizeWorktreePathForSidebarGroup( + resolveLocalCheckoutPath?.(thread) ?? null, + ); + if (!localCheckoutPath) { + return null; + } + return { + key: `${thread.environmentId}:${thread.projectId}:local:${localCheckoutPath}`, + checkoutPath: localCheckoutPath, + source: "local", + worktreePath: null, + }; +} + +export function buildSidebarThreadWorktreeSections( + threads: readonly SidebarThreadSummary[], + options: { + readonly resolveLocalCheckoutPath?: (thread: SidebarThreadSummary) => string | null; + } = {}, +): SidebarThreadWorktreeSection[] { + const threadsByWorktreeKey = new Map(); + for (const thread of threads) { + const bucket = checkoutSectionBucket(thread, options.resolveLocalCheckoutPath); + if (!bucket) { + continue; + } + const existing = threadsByWorktreeKey.get(bucket.key); + if (existing) { + existing.push(thread); + } else { + threadsByWorktreeKey.set(bucket.key, [thread]); + } + } + + const emittedWorktreeKeys = new Set(); + const sections: SidebarThreadWorktreeSection[] = []; + for (const thread of threads) { + const bucket = checkoutSectionBucket(thread, options.resolveLocalCheckoutPath); + const groupThreads = bucket ? threadsByWorktreeKey.get(bucket.key) : undefined; + if (!bucket || !groupThreads || groupThreads.length < 2) { + sections.push({ + kind: "thread", + thread, + ...(bucket ? { checkoutPath: bucket.checkoutPath } : {}), + }); + continue; + } + if (emittedWorktreeKeys.has(bucket.key)) { + continue; + } + emittedWorktreeKeys.add(bucket.key); + sections.push({ + kind: "worktree", + key: bucket.key, + label: formatWorktreeGroupLabel({ + worktreePath: bucket.checkoutPath, + branch: thread.branch, + source: bucket.source, + }), + branch: thread.branch, + checkoutPath: bucket.checkoutPath, + source: bucket.source, + worktreePath: bucket.worktreePath, + threads: groupThreads, + }); + } + return sections; +} + function nodeClosest(node: object | null, selector: string): unknown { if (node === null || !("closest" in node) || typeof node.closest !== "function") return null; return node.closest(selector); @@ -711,6 +1122,19 @@ export function getSidebarThreadIdsToPrewarm( return visibleThreadIds.slice(0, Math.max(0, limit)); } +/** + * Prewarming keeps a live thread-detail subscription per row, so the cache is + * paid for in retained history, not just in requests. A coarse pointer reports + * no hover, so nothing narrows those rows down to the one the reader is heading + * for, and the devices behind it are the ones least able to hold ten threads of + * history at once. Prewarm nothing there and let opening a thread fetch it. + */ +export function resolveSidebarThreadPrewarmLimit(input: { + readonly hasCoarsePointer: boolean; +}): number { + return input.hasCoarsePointer ? 0 : SIDEBAR_THREAD_PREWARM_LIMIT; +} + export function resolveAdjacentThreadId(input: { threadIds: readonly T[]; currentThreadId: T | null; @@ -842,6 +1266,62 @@ export function resolveSidebarThreadStatus(thread: SidebarThreadStatusInput): Si return "ready"; } +export interface SidebarV2TopStatus { + label: "Working" | "Monitoring" | "Approval" | "Input" | "Failed" | "Done"; + icon: "working" | "done" | null; + className: string; +} + +export function resolveSidebarV2TopStatus(input: { + status: SidebarThreadStatus; + isUnread: boolean; +}): SidebarV2TopStatus | null { + switch (input.status) { + case "working": + return { + label: "Working", + icon: "working", + className: + "animate-sidebar-working-text text-sky-600 motion-reduce:animate-none dark:text-sky-400", + }; + // Steady label, no icon, no duty-cycled shimmer: monitoring is calm + // background presence, not active progress (monitoring-pill D6). Matches the + // v2 sidebar row and the v1 pill, which uses pulse: false here. + case "monitoring": + return { + label: "Monitoring", + icon: null, + className: "text-sky-600 dark:text-sky-400", + }; + case "approval": + return { + label: "Approval", + icon: null, + className: "text-amber-700 dark:text-amber-300", + }; + case "input": + return { + label: "Input", + icon: null, + className: "text-indigo-600 dark:text-indigo-300", + }; + case "failed": + return { + label: "Failed", + icon: null, + className: "text-red-700 dark:text-red-300", + }; + case "ready": + return input.isUnread + ? { + label: "Done", + icon: "done", + className: "text-emerald-700 dark:text-emerald-300", + } + : null; + } +} + /** First VALID timestamp wins: `a ?? b` falls through on null, but a present- yet-malformed string must also fall through to the next candidate rather than sink the row to the epoch. */ @@ -944,6 +1424,39 @@ export function sortSettledThreadsForSidebar< ); } +/** + * Recency section layout for the V2 settled shelf. Callers must pass threads + * already ordered by {@link sortSettledThreadsForSidebarV2} (or an equivalent + * activity/settle-time order) so buckets preserve that order within each day. + * + * Headers are suppressed when every visible row lands in a single bucket + * (same rule as classic Threads recency). + */ +export function groupSettledThreadsByRecencyForSidebarV2< + T extends SettledThreadTimestampInput & { readonly id: string }, +>( + threads: readonly T[], + now: Date = new Date(), +): { + readonly groups: ReadonlyArray>; + readonly showHeaders: boolean; +} { + const groups = groupThreadsByRecency( + threads, + (thread) => { + const timestamp = resolveSettledThreadTimestamp(thread); + if (timestamp === null) return Number.NaN; + const ms = Date.parse(timestamp); + return Number.isNaN(ms) ? Number.NaN : ms; + }, + now, + ); + return { + groups, + showHeaders: shouldShowRecencySectionHeaders(groups), + }; +} + /** The timestamp a working thread's elapsed label counts from: the running turn's start (request time until adoption), falling back to the session's last transition when the turn projection lags behind. Malformed @@ -989,6 +1502,23 @@ export function resolveThreadStatusPill(input: { }; } + // Plan Ready outranks Working: Grok often stays "running" long after the plan + // is captured (agent-entered plan mode). Users need Implement immediately. + if ( + shouldShowPlanReadyStatus({ + interactionMode: thread.interactionMode, + hasPendingUserInput: thread.hasPendingUserInput, + hasActionableProposedPlan: thread.hasActionableProposedPlan, + }) + ) { + return { + label: "Plan Ready", + colorClass: "text-violet-600 dark:text-violet-300/90", + dotClass: "bg-violet-500 dark:bg-violet-300/90", + pulse: false, + }; + } + if (thread.session?.status === "running") { return { label: "Working", @@ -1007,6 +1537,22 @@ export function resolveThreadStatusPill(input: { }; } + if ( + sessionNeedsWakeUp({ + sessionStatus: thread.session?.status ?? null, + activeTurnId: thread.session?.activeTurnId ?? null, + latestTurnState: thread.latestTurn?.state ?? null, + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + }) + ) { + return { + label: "Wake Required", + colorClass: "text-orange-600 dark:text-orange-300/90", + dotClass: "bg-orange-500 dark:bg-orange-300/90", + pulse: false, + }; + } + // An actionable plan prompt outranks lingering background work: it needs // the user's decision, while liveness merely reports (review finding). const hasPlanReadyPrompt = diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx index c269b73ee761..2d134627f2d4 100644 --- a/apps/web/src/components/Sidebar.tsx +++ b/apps/web/src/components/Sidebar.tsx @@ -19,6 +19,10 @@ import { effectiveSnoozed, threadWokeAt, } from "@t3tools/client-runtime/state/thread-settled"; +import { + groupSortedThreadsByRecency, + shouldShowRecencySectionHeaders, +} from "@t3tools/client-runtime/state/thread-recency-groups"; import { resolveSettledThreadTimestamp } from "@t3tools/client-runtime/state/thread-sort"; import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/models"; import { @@ -29,6 +33,7 @@ import { } from "@t3tools/client-runtime/environment"; import { resolveEnvironmentMachineKind, + type EnvironmentId, type EnvironmentMachineKind, type ProjectIconOverride, type ScopedThreadRef, @@ -47,10 +52,13 @@ import { FolderIcon, FolderPlusIcon, GitBranchIcon, + ListIcon, + ListFilterIcon, PinIcon, PinOffIcon, PlusIcon, SearchIcon, + SquareKanbanIcon, SettingsIcon, SquarePenIcon, TerminalIcon, @@ -70,7 +78,7 @@ import { type MouseEvent as ReactMouseEvent, type ReactNode, } from "react"; -import { useParams, useRouter } from "@tanstack/react-router"; +import { useLocation, useParams, useRouter } from "@tanstack/react-router"; import { useRightPanelStore } from "../rightPanelStore"; import { @@ -114,10 +122,10 @@ import { import { useThreadActions } from "../hooks/useThreadActions"; import { useHandleNewThread } from "../hooks/useHandleNewThread"; import { isCommandPaletteOpen, openCommandPalette } from "../commandPaletteBus"; +import { subscribeToProjectReveal } from "../projectJump"; import { startNewThreadFromContext } from "../lib/chatThreadActions"; import { useClientSettings } from "../hooks/useSettings"; import { useCopyToClipboard } from "../hooks/useCopyToClipboard"; -import { useLocalStorage } from "../hooks/useLocalStorage"; import { useNowMinute } from "../hooks/useNowMinute"; import { useEnvironments, usePrimaryEnvironmentId } from "../state/environments"; import { @@ -140,11 +148,23 @@ import { formatRelativeTimeLabel, parseTimestampDate } from "../timestampFormat" import type { SidebarThreadSummary } from "../types"; import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; import { cn } from "~/lib/utils"; +import { ThreadIdentityMark } from "./identity/ParticipantStack"; import { EnvironmentMachineIcon } from "./EnvironmentMachineIcon"; import { buildThreadActionMenuItems } from "./threadActionMenu.logic"; +import { + isIdentityClaimRequiredMessage, + requestIdentityClaimGate, +} from "./identity/IdentityClaimGate"; +import { + DEFAULT_OWNERSHIP_RELATION, + isOwnershipRelation, +} from "@t3tools/client-runtime/state/identity"; +import { identityClaimPersonIdByEnvironmentAtom } from "../state/identity"; import { animateSidebarLayoutChanges, applySidebarThreadDrop, + SETTLED_TAIL_INITIAL_COUNT, + SETTLED_TAIL_PAGE_COUNT, buildBulkTitleRegenerationContextMenuItem, buildBulkUnpinContextMenuItem, deleteSelectedThreadEntries, @@ -204,9 +224,12 @@ import { type SnoozePreset, } from "./Sidebar.snooze"; import { ProjectFavicon, type ProjectFaviconProject } from "./ProjectFavicon"; +import { AiUsageStats } from "./chat/AiUsageStats"; import { makeWorkspaceFileDropHandlers } from "./chat/workspaceFileDrop"; import { ProviderInstanceIcon } from "./chat/ProviderInstanceIcon"; import { getTriggerDisplayModelLabel } from "./chat/providerIconUtils"; +import { resolveDriverUsage, usageDotFillClass, usageDotRingColor } from "../aiUsageState"; +import { useAiUsageSnapshot } from "../hooks/useAiUsageSnapshot"; import { deriveProviderEntriesByEnvironment, shouldShowInstanceBadge, @@ -216,6 +239,49 @@ import { useThreadRunningTerminalIds } from "../state/terminalSessions"; import { stackedThreadToast, toastManager } from "./ui/toast"; import { Button } from "./ui/button"; import { Input } from "./ui/input"; +import { + Menu, + MenuCheckboxItem, + MenuGroup, + MenuPopup, + MenuRadioGroup, + MenuRadioItem, + MenuSeparator, + MenuTrigger, +} from "./ui/menu"; +import { useLocalStorage } from "~/hooks/useLocalStorage"; +import { buildOwnershipPredicate, useOwnershipFilter } from "./ownershipFilter"; +import { + DEFAULT_SIDEBAR_OWNERSHIP_FILTER, + DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED, + DEFAULT_WEB_THREAD_GROUPING, + EMPTY_LIST_ENVIRONMENT_FILTER, + LIST_ENVIRONMENT_FILTER_STORAGE_KEY, + LIST_MODE_STORAGE_KEY, + LIST_THREAD_GROUPING_STORAGE_KEY, + ListEnvironmentFilterSchema, + ListHideSettledSchema, + parseSidebarOwnershipFilter, + SIDEBAR_OWNERSHIP_FILTER_LABELS, + SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY, + SIDEBAR_OWNERSHIP_FILTERS, + SIDEBAR_OWNERSHIP_RELATION_LABELS, + SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY, + SIDEBAR_OWNERSHIP_RELATIONS, + SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY, + WEB_THREAD_GROUPING_LABELS, + WEB_THREAD_GROUPINGS, + WebThreadGroupingSchema, + defaultThreadGroupingFromLegacyModeStorage, + isAllEnvironmentsSelected, + isEnvironmentSelected, + matchesEnvironmentFilter, + resolveSelectedEnvironmentIds, + toggleEnvironmentId, + usesFlatThreadGrouping, + type SidebarOwnershipFilter, + type WebThreadGrouping, +} from "./listEnvironmentFilter"; import { Combobox, ComboboxEmpty, @@ -239,13 +305,10 @@ import { type DraftSessionState, } from "../composerDraftStore"; -// Settled-tail paging: recent history is the common lookup; the deep tail -// stays behind an explicit Show more. -const SETTLED_TAIL_INITIAL_COUNT = 10; -const SETTLED_TAIL_PAGE_COUNT = 25; -// Fresh keys deliberately reset both shelves to collapsed for existing users. -const SETTLED_SHELF_EXPANDED_KEY = "t3code:sidebar:settled-expanded"; -const SNOOZED_SHELF_EXPANDED_KEY = "t3code:sidebar:snoozed-expanded"; +// Upstream's snoozed key spelling is "v2"/legacy; the fork had no snoozed-shelf +// preference before sync, so adopt it. Settled shelf keeps the fork's older key +// (SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY), which holds existing prefs. +const SNOOZED_SHELF_EXPANDED_KEY = "t3code:sidebar-v2:snoozed-expanded"; function compactSidebarTimeLabel(label: string): string { if (label === "just now") return "now"; @@ -315,6 +378,9 @@ function SidebarThreadTooltip({ modelInstanceId, modelLabel, branchMismatch, + usageDotClass, + usageRingColor, + threadUsage, terminalStatus, terminalProcessCount, }: { @@ -331,6 +397,9 @@ function SidebarThreadTooltip({ threadBranch: string; currentBranch: string; } | null; + usageDotClass?: string | undefined; + usageRingColor?: string | undefined; + threadUsage?: ReturnType | undefined; terminalStatus: TerminalStatusIndicator | null; terminalProcessCount: number; }) { @@ -391,6 +460,8 @@ function SidebarThreadTooltip({ badgeContent="none" badgeClassName="h-2 min-w-2 px-0" iconClassName="size-3 shrink-0 grayscale opacity-60" + {...(usageDotClass ? { statusDotClassName: usageDotClass } : {})} + {...(usageRingColor ? { statusDotRingColor: usageRingColor } : {})} />
{showInstanceBadge && providerEntry @@ -399,6 +470,11 @@ function SidebarThreadTooltip({
) : null} + {threadUsage ? ( +
+ +
+ ) : null} {terminalStatus ? (
{props.visible ? ( @@ -673,7 +751,7 @@ function SidebarSectionHeader(props: { type="button" onClick={props.toggle.onToggle} aria-expanded={props.toggle.expanded} - data-testid={`sidebar-${snoozed ? "snoozed" : "settled"}-shelf-toggle`} + data-testid={snoozed ? "sidebar-snoozed-shelf-toggle" : "sidebar-settled-shelf-toggle"} className={cn(className, "cursor-pointer")} > {content} @@ -1031,7 +1109,6 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { ); const threadKey = scopedThreadKey(threadRef); const { leaseLiveStatus, rowRef } = useSidebarRowSubscriptionLease(props.isActive); - const isRegeneratingTitle = thread.titleRegeneration != null; const lastVisitedAt = useUiStateStore((state) => state.threadLastVisitedAtById[threadKey]); const isSelected = useThreadSelectionStore((state) => state.selectedThreadKeys.has(threadKey)); const openPrLink = useOpenPrLink(); @@ -1055,6 +1132,22 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { [clearComposerContent, threadRef], ); + // Same semantics as v1 (never-visited counts as read): flipping the beta + // flag must not light up every historical thread as unread. + const isUnread = hasUnseenCompletion({ ...thread, lastVisitedAt }); + const status = resolveSidebarThreadStatus(thread); + // Screen-reader status for an in-flight title regeneration: the v2 rows are + // a fork rewrite of upstream's row, so this never came across with the rest + // of that surface even though the projection field did. + const isRegeneratingTitle = thread.titleRegeneration != null; + // A woken thread reappears at its original position (the sort is + // deliberately static), so the pill has to carry the weight. Snoozing is + // an explicit act, so the pill clears only when the user re-engages: + // reading a completion-triggered wake, clicking the pill, sending a + // message, settling, archiving — or finishing the work outright (merged + // or closed PR). Timer wakes survive a mere visit. An unparseable visit + // timestamp counts as never-visited — corrupt local data must not eat + // the wake signal. const gitCwd = thread.worktreePath ?? props.project?.workspaceRoot ?? null; const linkedPullRequestStatus = useLinkedThreadPullRequest( thread.environmentId, @@ -1065,7 +1158,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { ); const gitStatus = useEnvironmentQuery( leaseLiveStatus && (thread.branch != null || thread.worktreePath !== null) && gitCwd !== null - ? vcsEnvironment.status({ + ? vcsEnvironment.listStatus({ environmentId: thread.environmentId, input: { cwd: gitCwd }, }) @@ -1081,10 +1174,6 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { ? resolveThreadCurrentPullRequestLink(thread.pullRequests) : null; - // Same semantics as the legacy sidebar (never-visited counts as read): - // switching sidebars must not light up every historical thread as unread. - const isUnread = hasUnseenCompletion({ ...thread, lastVisitedAt }); - const status = resolveSidebarThreadStatus(thread); const isInFlight = status === "working" || status === "monitoring" || status === "approval" || status === "input"; // A woken thread reappears at its original position (the sort is @@ -1186,6 +1275,13 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { const modelLabel = selectedModel ? getTriggerDisplayModelLabel(selectedModel) : thread.modelSelection.model; + const aiUsageSnapshot = useAiUsageSnapshot(thread.environmentId); + const threadUsage = useMemo( + () => resolveDriverUsage(aiUsageSnapshot, driverKind, thread.modelSelection.model), + [aiUsageSnapshot, driverKind, thread.modelSelection.model], + ); + const usageDotClass = threadUsage ? usageDotFillClass(threadUsage.marker) : undefined; + const usageRingColor = threadUsage ? usageDotRingColor(threadUsage.marker) : undefined; // The local environment is "this machine" and needs no marker; every other // one gets its machine glyph. With no local environment (the hosted app) @@ -1205,6 +1301,9 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { modelInstanceId={modelInstanceId} modelLabel={modelLabel} branchMismatch={branchMismatch} + usageDotClass={usageDotClass} + usageRingColor={usageRingColor} + threadUsage={threadUsage} terminalStatus={terminalStatus} terminalProcessCount={terminalProcessCount} /> @@ -1436,50 +1535,64 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { ) : null; - const title = isRenaming ? ( - onRenameTitleChange(event.target.value)} - onFocus={(event) => event.currentTarget.select()} - onKeyDown={handleRenameKeyDown} - onBlur={handleRenameBlur} - onClick={(event) => event.stopPropagation()} - onDoubleClick={(event) => event.stopPropagation()} - className="min-w-0 flex-1 rounded-sm border border-input bg-card px-1 text-sm font-medium text-card-foreground outline-none focus:border-foreground" - /> - ) : ( - + {isRenaming ? ( + onRenameTitleChange(event.target.value)} + onFocus={(event) => event.currentTarget.select()} + onKeyDown={handleRenameKeyDown} + onBlur={handleRenameBlur} + onClick={(event) => event.stopPropagation()} + onDoubleClick={(event) => event.stopPropagation()} + className="min-w-0 flex-1 rounded-sm border border-input bg-card px-1 text-sm font-medium text-card-foreground outline-none focus:border-foreground" + /> + ) : ( + + {thread.title} + )} - > - {thread.title} - + {!isRenaming ? ( + + ) : null} +
); // Stacks show their layer count; multiple unrelated links show their total count. @@ -1933,7 +2046,10 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: { ) : null} {driverKind ? ( - + ) : null} @@ -1996,7 +2114,7 @@ const SidebarSearchResultRow = memo(function SidebarSearchResultRow(props: { const gitCwd = thread.worktreePath ?? props.project?.workspaceRoot ?? null; const gitStatus = useEnvironmentQuery( leaseLiveStatus && (thread.branch != null || thread.worktreePath !== null) && gitCwd !== null - ? vcsEnvironment.status({ + ? vcsEnvironment.listStatus({ environmentId: thread.environmentId, input: { cwd: gitCwd }, }) @@ -2117,6 +2235,11 @@ export default function Sidebar() { const sidebarProjectSortOrder = useClientSettings((s) => s.sidebarProjectSortOrder); const timestampFormat = useClientSettings((s) => s.timestampFormat); const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings); + const [threadGrouping, setThreadGrouping] = useLocalStorage( + LIST_THREAD_GROUPING_STORAGE_KEY, + DEFAULT_WEB_THREAD_GROUPING, + WebThreadGroupingSchema, + ); const { settleThread, unsettleThread, @@ -2234,6 +2357,57 @@ export default function Sidebar() { ), [environments], ); + // Shared with the Board so the selection applies to both while they are on + // screen together, rather than being a sidebar-local view of the same data. + const { + mode: ownershipFilter, + relation: ownershipRelation, + setMode: setOwnershipFilter, + setRelation: setOwnershipRelation, + } = useOwnershipFilter(); + // Per-environment claims (not primary-only): smart has no map while t3vm does. + const claimPersonIdByEnvironment = useAtomValue(identityClaimPersonIdByEnvironmentAtom); + const ownershipPredicate = useMemo( + () => + buildOwnershipPredicate({ + claimPersonIdByEnvironment, + mode: ownershipFilter, + relation: ownershipRelation, + }), + [claimPersonIdByEnvironment, ownershipFilter, ownershipRelation], + ); + + // Shared with classic list / Board so multi-env filters (e.g. hide t3vm) stick + // when switching sidebars. + const [storedEnvironmentFilter, setStoredEnvironmentFilter] = useLocalStorage( + LIST_ENVIRONMENT_FILTER_STORAGE_KEY, + EMPTY_LIST_ENVIRONMENT_FILTER, + ListEnvironmentFilterSchema, + ); + const [settledShelfExpanded, setSettledShelfExpanded] = useLocalStorage( + SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY, + DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED, + ListHideSettledSchema, + ); + const availableEnvironmentIds = useMemo( + () => new Set(environments.map((environment) => environment.environmentId)), + [environments], + ); + const selectedEnvironmentIds = useMemo( + () => + resolveSelectedEnvironmentIds( + storedEnvironmentFilter as readonly EnvironmentId[], + availableEnvironmentIds, + ), + [availableEnvironmentIds, storedEnvironmentFilter], + ); + + const listOptionsActive = + ownershipFilter !== DEFAULT_SIDEBAR_OWNERSHIP_FILTER || + ownershipRelation !== DEFAULT_OWNERSHIP_RELATION || + !isAllEnvironmentsSelected(selectedEnvironmentIds) || + settledShelfExpanded !== DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED; + const environmentMachineById = useMemo( () => new Map( @@ -2313,6 +2487,20 @@ export default function Sidebar() { ), [projectGroups], ); + const orderForThreadGrouping = useCallback( + (ordered: EnvironmentThreadShell[]) => { + if (threadGrouping !== "recency") return ordered; + return ordered + .slice() + .sort( + (left, right) => + firstValidTimestampMs(right.latestUserMessageAt, right.updatedAt, right.createdAt) - + firstValidTimestampMs(left.latestUserMessageAt, left.updatedAt, left.createdAt) || + left.id.localeCompare(right.id), + ); + }, + [threadGrouping], + ); const nowMinute = useNowMinute(); // Snooze wake times are second-precise, so classifying with the quantized @@ -2329,6 +2517,20 @@ export default function Sidebar() { // app restarts keep it. const projectScopeKey = useUiStateStore((store) => store.sidebarProjectScopeKey); const setProjectScopeKey = useUiStateStore((store) => store.setSidebarProjectScopeKey); + useEffect( + () => + subscribeToProjectReveal(({ environmentId, projectId }) => { + const projectGroup = projectGroups.find((project) => + project.memberProjectRefs.some( + (ref) => ref.environmentId === environmentId && ref.projectId === projectId, + ), + ); + if (projectGroup !== undefined) { + setProjectScopeKey(projectGroup.projectKey); + } + }), + [projectGroups, setProjectScopeKey], + ); // {value, label} items let Base UI drive the combobox selection contract // while the popup search filters the same collection. const projectScopeItems = useMemo( @@ -2492,14 +2694,18 @@ export default function Sidebar() { // Snooze classification uses a REAL clock, not the quantized minute: // wake times are second-precise and a woken thread must not linger on // the shelf for the rest of the minute. snoozeWakeTick re-runs this - // memo exactly at the next wake boundary. + // memo exactly at the next wake boundary. nowMinute also retriggers so + // recency grouping of the same visible set can move across buckets. + void nowMinute; void snoozeWakeTick; const preciseNow = new Date().toISOString(); const visible = threads.filter( (thread) => thread.archivedAt === null && + matchesEnvironmentFilter(thread.environmentId, selectedEnvironmentIds) && (scopedProjectKeys === null || - scopedProjectKeys.has(`${thread.environmentId}:${thread.projectId}`)), + scopedProjectKeys.has(`${thread.environmentId}:${thread.projectId}`)) && + ownershipPredicate(thread), ); const pinned: EnvironmentThreadShell[] = []; const active: EnvironmentThreadShell[] = []; @@ -2522,6 +2728,9 @@ export default function Sidebar() { if (capabilities?.threadPinning === true && capabilities.threadPinReorder === true) { draggable.add(threadKey); } + // Snooze outranks settlement and pinning until the thread wakes. + // Settlement outranks pinning so a pinned thread that has settled + // stays in the settled tail (#7969) instead of a separate pin bucket. if (optimisticDrop?.key === threadKey) { const projected = applySidebarThreadDrop( thread, @@ -2540,7 +2749,6 @@ export default function Sidebar() { : { ...projected, snoozedAt: thread.snoozedAt, snoozedUntil: thread.snoozedUntil }, ); } else if (supportsSnooze && effectiveSnoozed(thread, { now: preciseNow })) { - // Snooze outranks settlement and pinning until the thread wakes. snoozed.push(thread); } else if (supportsSettlement && thread.settledOverride === "settled") { settled.push(thread); @@ -2554,9 +2762,10 @@ export default function Sidebar() { // user-arranged keys first, keyless threads in creation order below. // Server capability only gates DRAGGING — it must not influence the // sort, or mixed-version fleets would render different pinned orders on - // web and mobile from the same data. + // web and mobile from the same data. The fork's grouping + // preference therefore applies to the active rows, not to pins. const sortedPinned = sortPinnedThreadsForSidebar(pinned); - const sortedActive = sortThreadsForSidebar(active); + const sortedActive = orderForThreadGrouping(sortThreadsForSidebar(active)); return { pinnedThreads: optimisticDrop?.section !== "pinned" || optimisticDrop.order === null @@ -2577,15 +2786,27 @@ export default function Sidebar() { getId: (thread) => scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), }), // Soonest wake first: "what comes back next" is the shelf's question. - snoozedThreads: snoozed.toSorted( - (left, right) => - firstValidTimestampMs(left.snoozedUntil ?? null) - - firstValidTimestampMs(right.snoozedUntil ?? null), - ), + snoozedThreads: snoozed + .slice() + .sort( + (left, right) => + firstValidTimestampMs(left.snoozedUntil ?? null) - + firstValidTimestampMs(right.snoozedUntil ?? null), + ), settledThreads: sortSettledThreadsForSidebar(settled), snoozeNow: preciseNow, }; - }, [nowMinute, optimisticDrop, scopedProjectKeys, serverConfigs, snoozeWakeTick, threads]); + }, [ + nowMinute, + optimisticDrop, + orderForThreadGrouping, + ownershipPredicate, + scopedProjectKeys, + selectedEnvironmentIds, + serverConfigs, + snoozeWakeTick, + threads, + ]); const threadSearchInputRef = useRef(null); const [threadSearchQuery, setThreadSearchQuery] = useState(""); @@ -2637,7 +2858,7 @@ export default function Sidebar() { // filter context changes so a scope/search flip never inherits a deep // page state. const [settledVisibleCount, setSettledVisibleCount] = useState(SETTLED_TAIL_INITIAL_COUNT); - const settledResetKey = projectScopeKey ?? "all"; + const settledResetKey = `${projectScopeKey ?? "all"}:${selectedEnvironmentIds.join(",")}`; const lastSettledResetKeyRef = useRef(settledResetKey); if (lastSettledResetKeyRef.current !== settledResetKey) { lastSettledResetKeyRef.current = settledResetKey; @@ -2665,11 +2886,7 @@ export default function Sidebar() { () => setSettledVisibleCount((count) => count + SETTLED_TAIL_PAGE_COUNT), [], ); - const [settledShelfExpanded, setSettledShelfExpanded] = useLocalStorage( - SETTLED_SHELF_EXPANDED_KEY, - false, - Schema.Boolean, - ); + const toggleSettledShelf = useCallback( () => setSettledShelfExpanded((value) => !value), [setSettledShelfExpanded], @@ -3014,11 +3231,15 @@ export default function Sidebar() { // Never navigate away from a thread that did not settle. if (!isAtomCommandInterrupted(result)) { const error = squashAtomCommandFailure(result); + const message = error instanceof Error ? error.message : "An error occurred."; + if (isIdentityClaimRequiredMessage(message)) { + requestIdentityClaimGate(threadRef.environmentId); + } toastManager.add( stackedThreadToast({ type: "error", title: "Failed to settle thread", - description: error instanceof Error ? error.message : "An error occurred.", + description: message, }), ); } @@ -3717,7 +3938,7 @@ export default function Sidebar() { const count = threadKeys.length; // Snooze (N) is offered when every selected thread can actually take // it — a mixed selection with blocked-on-you work would half-apply. - const selectionNow = new Date(); + const selectionNow = new Date().toISOString(); const selectedThreads = threadKeys.flatMap((threadKey) => { const thread = threadByKeyRef.current.get(threadKey); return thread ? [thread] : []; @@ -3725,7 +3946,7 @@ export default function Sidebar() { const canSnoozeSelection = selectedThreads.every( (thread) => serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSnooze === true && - canSnooze(thread, { now: selectionNow.toISOString() }), + canSnooze(thread, { now: selectionNow }), ); const titleRegenerationThreads = selectedThreads.filter( (thread) => @@ -4066,7 +4287,7 @@ export default function Sidebar() { startThreadRename(threadRef, thread.title); return; case "regenerate-title": { - if (isRegeneratingTitle) return; + if (!supportsTitleRegeneration || isRegeneratingTitle) return; const result = await updateThreadMetadata({ environmentId: threadRef.environmentId, input: { threadId: threadRef.threadId, regenerateTitle: true }, @@ -4212,6 +4433,13 @@ export default function Sidebar() { modelPickerOpen: isModelPickerOpen(), }, }); + if (command === "board.open") { + event.preventDefault(); + event.stopPropagation(); + if (isMobile) setOpenMobile(false); + void router.navigate({ to: "/board" }); + return; + } const navigateToThreadKey = (targetThreadKey: string | null) => { if (!targetThreadKey) return false; const targetThread = threadByKey.get(targetThreadKey); @@ -4239,11 +4467,14 @@ export default function Sidebar() { window.addEventListener("keydown", onWindowKeyDown); return () => window.removeEventListener("keydown", onWindowKeyDown); }, [ + isMobile, keybindings, navigateToThread, orderedThreadKeys, routeTerminalOpen, routeThreadKey, + router, + setOpenMobile, threadByKey, ]); @@ -4293,6 +4524,15 @@ export default function Sidebar() { [isMobile, newThreadContext, projectGroups.length, setOpenMobile], ); + const pathname = useLocation({ select: (l) => l.pathname }); + const isBoardActive = pathname === "/board"; + const handleBoardClick = useCallback(() => { + if (isMobile) setOpenMobile(false); + void router.navigate({ to: "/board" }); + }, [isMobile, router, setOpenMobile]); + + const commandPaletteShortcutLabel = shortcutLabelForCommand(keybindings, "commandPalette.toggle"); + const boardShortcutLabel = shortcutLabelForCommand(keybindings, "board.open"); // The button mirrors chat.new: in multi-project setups both route through // the command palette's "New thread in..." picker, and in single-project // setups both create immediately. In multi-project setups the label is only @@ -4361,6 +4601,35 @@ export default function Sidebar() { ) : null} +
+ + + } + > + + + + {boardShortcutLabel ? `Board (${boardShortcutLabel})` : "Board"} + + +
{projectGroups.length > 0 ? (
+ + + } + > + {threadGrouping === "project" ? : } + + + setThreadGrouping(value as WebThreadGrouping)} + > + {WEB_THREAD_GROUPINGS.filter((grouping) => grouping !== "none").map( + (grouping) => ( + + {grouping === "project" ? : } + {WEB_THREAD_GROUPING_LABELS[grouping]} + + ), + )} + + + + + + + } + /> + } + > + + {listOptionsActive ? ( + + ) : null} + + View & filters + + + +
+ Ownership +
+ { + if (value !== "any" && value !== "mine" && value !== "theirs") return; + setOwnershipFilter(value); + }} + > + {SIDEBAR_OWNERSHIP_FILTERS.map((value) => ( + + {SIDEBAR_OWNERSHIP_FILTER_LABELS[value]} + + ))} + + + {ownershipFilter === "mine" || ownershipFilter === "theirs" ? ( + <> + + +
+ {ownershipFilter === "mine" ? "Mine includes" : "Theirs includes"} +
+ { + if (!isOwnershipRelation(value)) return; + setOwnershipRelation(value); + }} + > + {SIDEBAR_OWNERSHIP_RELATIONS.map((value) => ( + + {SIDEBAR_OWNERSHIP_RELATION_LABELS[value]} + + ))} + + + + ) : null} + + +
+ Settled shelf +
+ setSettledShelfExpanded(checked === true)} + > + Expand settled shelf + + + {environments.length > 1 ? ( + <> + + +
+ Environment +
+ setStoredEnvironmentFilter([])} + > + All environments + + {environments.map((environment) => ( + { + setStoredEnvironmentFilter([ + ...toggleEnvironmentId( + selectedEnvironmentIds, + environment.environmentId, + ), + ]); + }} + > + {environment.label} + + ))} + + + ) : null} + + ); }; + const recencyHeaderBefore = ( + rows: readonly EnvironmentThreadShell[], + ): Map => { + const headers = new Map(); + const groups = groupSortedThreadsByRecency( + rows, + new Date(`${nowMinute}:00.000Z`), + ); + if ( + threadGrouping !== "recency" || + !shouldShowRecencySectionHeaders(groups) + ) { + return headers; + } + for (const group of groups) { + const first = group.threads[0]; + if (first === undefined) continue; + headers.set( + scopedThreadKey(scopeThreadRef(first.environmentId, first.id)), + { id: group.id, label: group.label }, + ); + } + return headers; + }; + const activeRecencyHeaders = recencyHeaderBefore(activeThreads); + const settledRecencyHeaders = recencyHeaderBefore(renderedSettledThreads); const from = dragState?.activeSection ?? null; const items: ReactNode[] = [ + {group.label} + , + ); + } + items.push(renderThreadRow(threadByKey.get(item.key)!, section)); continue; } switch (item.marker) { @@ -4802,6 +5292,15 @@ export default function Sidebar() { isDropTarget={dragTargetSection === "active"} />, ); + if (from === null && pinnedThreads.length > 0) { + items.push( +
  • , + ); + } break; case "active-placeholder": items.push( diff --git a/apps/web/src/components/ThreadStatusIndicators.test.tsx b/apps/web/src/components/ThreadStatusIndicators.test.tsx index 2ad3ef64448e..db4d83b29ee3 100644 --- a/apps/web/src/components/ThreadStatusIndicators.test.tsx +++ b/apps/web/src/components/ThreadStatusIndicators.test.tsx @@ -36,6 +36,22 @@ describe("ThreadWorktreeIndicator", () => { expect(markup).toBe(""); }); + + it("renders a new-worktree action when requested without an existing worktree", () => { + const markup = renderToStaticMarkup( + undefined} + />, + ); + + expect(markup).toContain('aria-label="New worktree from feature/recent-action"'); + expect(markup).toContain('data-testid="thread-worktree-new-session-thread-1"'); + }); }); describe("linked pull request snapshots", () => { diff --git a/apps/web/src/components/ThreadStatusIndicators.tsx b/apps/web/src/components/ThreadStatusIndicators.tsx index 2a69eaeddc9d..cf122d7c3267 100644 --- a/apps/web/src/components/ThreadStatusIndicators.tsx +++ b/apps/web/src/components/ThreadStatusIndicators.tsx @@ -8,25 +8,40 @@ import { type ThreadPullRequestLink, type VcsStatusResult, } from "@t3tools/contracts"; +import { Atom } from "effect/unstable/reactivity"; import { resolveThreadCurrentPullRequestLink, resolveThreadPullRequestChains, visibleThreadPullRequests, type ThreadPullRequestBadge, } from "@t3tools/shared/threadPullRequests"; -import { FolderGit2Icon, GitPullRequestArrowIcon, LayersIcon, TerminalIcon } from "lucide-react"; +import { + CircleCheckIcon, + CircleDashedIcon, + FolderGit2Icon, + FolderPlusIcon, + GitPullRequestArrowIcon, + LayersIcon, + PencilRulerIcon, + TerminalIcon, +} from "lucide-react"; import { useMemo, type MouseEvent } from "react"; +import { appAtomRegistry } from "../rpc/atomRegistry"; import { buttonVariants, InlineButton } from "./ui/button"; -import { cn } from "../lib/utils"; import { useEnvironment, usePrimaryEnvironmentId } from "../state/environments"; import { EnvironmentMachineIcon } from "./EnvironmentMachineIcon"; import { parseChangeRequestUrl } from "../lib/openPullRequestLink"; import { useEnvironmentQuery } from "../state/query"; import { linkedPullRequestDetailAtom, useSharedPullRequestSummary } from "../state/pullRequests"; import { useThreadRunningTerminalIds } from "../state/terminalSessions"; +import { cn } from "../lib/utils"; import { useUiStateStore } from "../uiStateStore"; import { resolveChangeRequestPresentation } from "../sourceControlPresentation"; -import { resolveThreadStatusPill, type ThreadStatusPill } from "./Sidebar.logic"; +import { + resolveThreadStatusPill, + type SidebarV2TopStatus, + type ThreadStatusPill, +} from "./Sidebar.logic"; import type { SidebarThreadSummary } from "../types"; import { formatWorktreePathForDisplay } from "../worktreeCleanup"; import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip"; @@ -374,6 +389,273 @@ export function PrStatusTooltipContent({ status }: { status: PrStatusIndicator } ); } +export function resolveThreadPr(input: { + threadBranch: string | null; + gitStatus: VcsStatusResult | null; + /** When true, board UI may still show PR state for worktree threads. Accepted for call-site parity. */ + hasDedicatedWorktree?: boolean; +}): ThreadPr | null { + const { threadBranch, gitStatus } = input; + if (gitStatus === null) { + return null; + } + + if (threadBranch === null || gitStatus.refName !== threadBranch) { + return null; + } + + return gitStatus.pr ?? null; +} + +/** + * Parent-held PR snapshot for Sidebar V2. Rows remount when settlement + * partitions move them, so terminal PR metadata must live above the row. + */ +export interface ThreadChangeRequestSnapshot { + readonly branch: string; + readonly pr: NonNullable; + readonly sourceControlProvider: VcsStatusResult["sourceControlProvider"] | undefined; + readonly linkedPullRequest?: ThreadLinkedPullRequest; +} + +export const threadChangeRequestSnapshotsAtom = Atom.make< + ReadonlyMap +>(new Map()).pipe(Atom.keepAlive, Atom.withLabel("sidebar:thread-change-request-snapshots")); + +function isTerminalChangeRequestState( + state: NonNullable["state"], +): state is "merged" | "closed" { + return state === "merged" || state === "closed"; +} + +function sourceControlProvidersEqual( + left: VcsStatusResult["sourceControlProvider"] | undefined, + right: VcsStatusResult["sourceControlProvider"] | undefined, +): boolean { + if (left === right) return true; + if (left == null || right == null) return left == null && right == null; + return left.kind === right.kind && left.name === right.name && left.baseUrl === right.baseUrl; +} + +function linkedPullRequestsEqual( + left: ThreadLinkedPullRequest | null | undefined, + right: ThreadLinkedPullRequest | null | undefined, +): boolean { + if (left == null || right == null) return left == null && right == null; + return ( + left.projectId === right.projectId && + left.repository === right.repository && + left.number === right.number && + left.url === right.url + ); +} + +export function threadChangeRequestSnapshotsEqual( + left: ThreadChangeRequestSnapshot, + right: ThreadChangeRequestSnapshot, +): boolean { + return ( + left.branch === right.branch && + left.pr.number === right.pr.number && + left.pr.title === right.pr.title && + left.pr.url === right.pr.url && + left.pr.baseRef === right.pr.baseRef && + left.pr.headRef === right.pr.headRef && + left.pr.state === right.pr.state && + left.pr.isDraft === right.pr.isDraft && + (left.pr.updatedAt ?? null) === (right.pr.updatedAt ?? null) && + sourceControlProvidersEqual(left.sourceControlProvider, right.sourceControlProvider) && + linkedPullRequestsEqual(left.linkedPullRequest, right.linkedPullRequest) + ); +} + +export function setThreadChangeRequestSnapshot( + threadKey: string, + snapshot: ThreadChangeRequestSnapshot | null, +): void { + appAtomRegistry.modify(threadChangeRequestSnapshotsAtom, (current) => { + const existing = current.get(threadKey); + if (snapshot === null) { + if (existing === undefined) return [false, current]; + const next = new Map(current); + next.delete(threadKey); + return [true, next]; + } + if (existing !== undefined && threadChangeRequestSnapshotsEqual(existing, snapshot)) { + return [false, current]; + } + const next = new Map(current); + next.set(threadKey, snapshot); + return [true, next]; + }); +} + +/** + * Authoritative snapshot update from live VCS status. + * - `undefined`: missing status, or a local checkout retaining a terminal PR — leave the map alone + * - `null`: no PR (without a retained terminal snapshot), a cleared branch, or a mismatch without a terminal PR — clear + * - snapshot: matching branch reports a PR — store/replace + */ +export function nextThreadChangeRequestSnapshot(input: { + threadBranch: string | null; + gitStatus: VcsStatusResult | null; + snapshot: ThreadChangeRequestSnapshot | null | undefined; + retainTerminalOnBranchMismatch: boolean; + linkedPullRequest?: ThreadLinkedPullRequest | null | undefined; + linkedPullRequestStatus?: LinkedThreadPullRequestStatus | null | undefined; +}): ThreadChangeRequestSnapshot | null | undefined { + const { + threadBranch, + gitStatus, + snapshot, + retainTerminalOnBranchMismatch, + linkedPullRequest, + linkedPullRequestStatus, + } = input; + if (linkedPullRequest != null) { + if (linkedPullRequestStatus === null || linkedPullRequestStatus === undefined) { + return linkedPullRequestsEqual(snapshot?.linkedPullRequest, linkedPullRequest) + ? undefined + : null; + } + return { + branch: threadBranch ?? linkedPullRequestStatus.pr.headRef, + pr: linkedPullRequestStatus.pr, + sourceControlProvider: linkedPullRequestStatus.sourceControlProvider, + linkedPullRequest, + }; + } + if (gitStatus === null) { + return snapshot?.linkedPullRequest === undefined ? undefined : null; + } + if (threadBranch === null) { + return null; + } + if (gitStatus.refName !== threadBranch) { + return retainTerminalOnBranchMismatch && + snapshot != null && + snapshot.linkedPullRequest === undefined && + isTerminalChangeRequestState(snapshot.pr.state) + ? undefined + : null; + } + if (gitStatus.pr == null) { + if ( + retainTerminalOnBranchMismatch && + snapshot != null && + snapshot.linkedPullRequest === undefined && + isTerminalChangeRequestState(snapshot.pr.state) + ) { + return undefined; + } + return null; + } + return { + branch: threadBranch, + pr: gitStatus.pr, + sourceControlProvider: gitStatus.sourceControlProvider, + }; +} + +/** + * Live PR when the checkout matches the thread branch; otherwise, for local + * checkouts only, a cached merged/closed PR for the thread. Local thread + * metadata follows the shared checkout, so the cached branch intentionally + * survives that metadata changing to the newly checked-out branch. Open PRs + * are never retained — their state can still change. + */ +export function resolveDisplayedThreadPr(input: { + threadBranch: string | null; + gitStatus: VcsStatusResult | null; + snapshot: ThreadChangeRequestSnapshot | null | undefined; + retainTerminalOnBranchMismatch: boolean; + linkedPullRequest?: ThreadLinkedPullRequest | null | undefined; + linkedPullRequestStatus?: LinkedThreadPullRequestStatus | null | undefined; +}): ThreadPr | null { + const { + threadBranch, + gitStatus, + snapshot, + retainTerminalOnBranchMismatch, + linkedPullRequest, + linkedPullRequestStatus, + } = input; + if (linkedPullRequest != null) { + return ( + linkedPullRequestStatus?.pr ?? + (linkedPullRequestsEqual(snapshot?.linkedPullRequest, linkedPullRequest) + ? (snapshot?.pr ?? null) + : null) + ); + } + if ( + threadBranch !== null && + gitStatus !== null && + gitStatus.refName === threadBranch && + gitStatus.pr != null + ) { + return gitStatus.pr; + } + + if ( + threadBranch !== null && + retainTerminalOnBranchMismatch && + snapshot != null && + snapshot.linkedPullRequest === undefined && + isTerminalChangeRequestState(snapshot.pr.state) + ) { + return snapshot.pr; + } + + return null; +} + +export function resolveDisplayedThreadPrProvider(input: { + threadBranch: string | null; + gitStatus: VcsStatusResult | null; + snapshot: ThreadChangeRequestSnapshot | null | undefined; + retainTerminalOnBranchMismatch: boolean; + linkedPullRequest?: ThreadLinkedPullRequest | null | undefined; + linkedPullRequestStatus?: LinkedThreadPullRequestStatus | null | undefined; +}): VcsStatusResult["sourceControlProvider"] | undefined { + const { + threadBranch, + gitStatus, + snapshot, + retainTerminalOnBranchMismatch, + linkedPullRequest, + linkedPullRequestStatus, + } = input; + if (linkedPullRequest != null) { + return ( + linkedPullRequestStatus?.sourceControlProvider ?? + (linkedPullRequestsEqual(snapshot?.linkedPullRequest, linkedPullRequest) + ? snapshot?.sourceControlProvider + : undefined) + ); + } + if ( + threadBranch !== null && + gitStatus !== null && + gitStatus.refName === threadBranch && + gitStatus.pr != null + ) { + return gitStatus.sourceControlProvider; + } + + if ( + threadBranch !== null && + retainTerminalOnBranchMismatch && + snapshot != null && + snapshot.linkedPullRequest === undefined && + isTerminalChangeRequestState(snapshot.pr.state) + ) { + return snapshot.sourceControlProvider; + } + + return undefined; +} + export function terminalStatusFromRunningIds( runningTerminalIds: ReadonlyArray, ): TerminalStatusIndicator | null { @@ -389,18 +671,68 @@ export function terminalStatusFromRunningIds( export function ThreadWorktreeIndicator({ thread, + onCreateSession, }: { thread: Pick; + onCreateSession?: (event: React.MouseEvent) => void; }) { const worktreePath = thread.worktreePath?.trim(); - if (!worktreePath) { + if (!worktreePath && !onCreateSession) { return null; } - const displayPath = formatWorktreePathForDisplay(worktreePath); - const tooltip = thread.branch - ? `Worktree: ${displayPath} (${thread.branch})` - : `Worktree: ${displayPath}`; + const tooltip = worktreePath + ? thread.branch + ? `Worktree: ${formatWorktreePathForDisplay(worktreePath)} (${thread.branch})` + : `Worktree: ${formatWorktreePathForDisplay(worktreePath)}` + : thread.branch + ? `New worktree from ${thread.branch}` + : "New worktree"; + + return ( + + { + event.stopPropagation(); + }} + onClick={onCreateSession} + /> + ) : ( + + ) + } + > + {onCreateSession ? ( + + ) : ( + + )} + + {tooltip} + + ); +} + +export function ThreadPlanModeIndicator({ + thread, +}: { + thread: Pick; +}) { + if (thread.interactionMode !== "plan") { + return null; + } return ( @@ -408,19 +740,76 @@ export function ThreadWorktreeIndicator({ render={ } > - + - {tooltip} + Plan-only thread ); } +export function ThreadSettledIndicator({ thread }: { thread: Pick }) { + return ( + + + } + > + + Settled + + Settled + + ); +} + +export function ThreadStatusV2Indicator({ + status, + className, +}: { + status: SidebarV2TopStatus; + className?: string; +}) { + return ( + + {status.icon === "working" ? ( + + ) : status.icon === "done" ? ( + + ) : null} + {status.label} + + ); +} + +/** Sidebar cue for an unsent composer draft on a thread row. */ +export function ComposerDraftDot({ className }: { className?: string }) { + return ( + + ); +} + export function ThreadStatusLabel({ status, compact = false, diff --git a/apps/web/src/components/WebUpdateBanner.test.ts b/apps/web/src/components/WebUpdateBanner.test.ts new file mode 100644 index 000000000000..7e30300a9706 --- /dev/null +++ b/apps/web/src/components/WebUpdateBanner.test.ts @@ -0,0 +1,19 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { isWebUpdateAvailable } from "./WebUpdateBanner"; + +describe("isWebUpdateAvailable", () => { + it("is false until both a boot and a latest version are known", () => { + expect(isWebUpdateAvailable(null, null)).toBe(false); + expect(isWebUpdateAvailable(null, "v1")).toBe(false); + expect(isWebUpdateAvailable("v1", null)).toBe(false); + }); + + it("is false while the served version matches what the tab booted with", () => { + expect(isWebUpdateAvailable("v1", "v1")).toBe(false); + }); + + it("is true once the server serves a different bundle than the tab booted with", () => { + expect(isWebUpdateAvailable("v1", "v2")).toBe(true); + }); +}); diff --git a/apps/web/src/components/WebUpdateBanner.tsx b/apps/web/src/components/WebUpdateBanner.tsx new file mode 100644 index 000000000000..9f42261d9d54 --- /dev/null +++ b/apps/web/src/components/WebUpdateBanner.tsx @@ -0,0 +1,53 @@ +import { useAtomValue } from "@effect/atom-react"; +import { useRef } from "react"; + +import { primaryServerWebVersionAtom } from "../state/server"; + +/** + * Whether a newer web bundle is being served than the one this tab booted with. + * `boot` is the version observed first (what the running code was loaded from); + * `latest` is the most recent version the server has reported. Pure so the + * decision can be unit-tested without a DOM. + */ +export function isWebUpdateAvailable(boot: string | null, latest: string | null): boolean { + return boot !== null && latest !== null && boot !== latest; +} + +/** + * Unobtrusive "a new version is available" affordance. The server broadcasts its + * served web-bundle version over the lifecycle stream; the first value this tab + * sees is the version it booted with, so any later, different value means the + * assets were hot-swapped on the server. We never reload automatically -- the + * user reloads when convenient. (vitePreloadRecovery still auto-reloads on a + * genuinely missing chunk, so nothing breaks if the user ignores this.) + */ +export function WebUpdateBanner() { + const latest = useAtomValue(primaryServerWebVersionAtom); + const bootVersionRef = useRef(null); + if (latest !== null && bootVersionRef.current === null) { + bootVersionRef.current = latest; + } + + if (!isWebUpdateAvailable(bootVersionRef.current, latest)) { + return null; + } + + return ( +
    + A new version of T3 Code is available. + +
    + ); +} diff --git a/apps/web/src/components/board/Board.logic.test.ts b/apps/web/src/components/board/Board.logic.test.ts new file mode 100644 index 000000000000..b6b5445fd233 --- /dev/null +++ b/apps/web/src/components/board/Board.logic.test.ts @@ -0,0 +1,607 @@ +import { EnvironmentId, ProjectId, type VcsStatusResult } from "@t3tools/contracts"; +import { scopeProjectRef } from "@t3tools/client-runtime/environment"; +import { describe, expect, it } from "vite-plus/test"; +import { + BOARD_ARCHIVE_DROPPABLE_ID, + BOARD_SETTLED_COLUMN_DROPPABLE_ID, + BOARD_TRASH_DROPPABLE_ID, + BOARD_UNSETTLE_DROPPABLE_ID, + boardWorktreeGroupDragId, + boardWorktreeKey, + buildBoardColumns, + buildBoardProjectFilterPredicate, + countBoardColumnThreads, + deriveBoardColumn, + parseBoardWorktreeGroupDragId, + resolveBoardDropIntent, + sliceBoardSettledItems, + sortBoardThreads, + type BoardColumnItem, + type BoardColumnInput, +} from "./Board.logic"; + +const localEnvironmentId = EnvironmentId.make("environment-local"); +const remoteEnvironmentId = EnvironmentId.make("environment-remote"); + +function columnThreadIds( + items: readonly BoardColumnItem[], +): string[] { + return items.flatMap((item) => + item.kind === "thread" ? [item.thread.id] : item.threads.map((thread) => thread.id), + ); +} + +function makeGitStatus(overrides: Partial = {}): VcsStatusResult { + return { + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "feature/board", + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + pr: null, + ...overrides, + }; +} + +function makePr(state: "open" | "closed" | "merged"): NonNullable { + return { + number: 42, + title: "Board view", + url: "https://github.com/example/repo/pull/42", + baseRef: "main", + headRef: "feature/board", + state, + }; +} + +function makeColumnInput(overrides: Partial = {}): BoardColumnInput { + return { + threadStatusLabel: null, + interactionMode: "default", + isSettled: false, + latestTurnCompletedAt: null, + readySessionUpdatedAt: null, + lastVisitedAt: null, + threadBranch: "feature/board", + hasDedicatedWorktree: false, + hasWorkingThreadForWorktree: false, + gitStatus: makeGitStatus(), + ...overrides, + }; +} + +describe("deriveBoardColumn", () => { + it("puts attention status pills in review ahead of working or merged lifecycle state", () => { + const gitStatus = makeGitStatus({ pr: makePr("merged") }); + expect( + deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Pending Approval", gitStatus })), + ).toBe("review"); + expect( + deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Awaiting Input", gitStatus })), + ).toBe("review"); + expect( + deriveBoardColumn( + makeColumnInput({ + interactionMode: "plan", + threadStatusLabel: "Plan Ready", + gitStatus, + }), + ), + ).toBe("review"); + expect(deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Completed", gitStatus }))).toBe( + "review", + ); + }); + + it("puts working and connecting status pills in working, even with a merged PR", () => { + const gitStatus = makeGitStatus({ pr: makePr("merged") }); + expect(deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Working", gitStatus }))).toBe( + "working", + ); + expect(deriveBoardColumn(makeColumnInput({ threadStatusLabel: "Connecting", gitStatus }))).toBe( + "working", + ); + }); + + it("defaults to review while git status is unloaded or the cwd is not a repo", () => { + expect(deriveBoardColumn(makeColumnInput({ gitStatus: null }))).toBe("review"); + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ isRepo: false }) })), + ).toBe("review"); + }); + + it("ignores git status from a shared cwd checked out on a different branch", () => { + const gitStatus = makeGitStatus({ + refName: "someone-elses-branch", + hasWorkingTreeChanges: true, + pr: makePr("open"), + }); + expect(deriveBoardColumn(makeColumnInput({ gitStatus }))).toBe("review"); + }); + + it("applies git status from a dedicated worktree regardless of ref name", () => { + const gitStatus = makeGitStatus({ refName: "detached-head", hasWorkingTreeChanges: true }); + expect(deriveBoardColumn(makeColumnInput({ hasDedicatedWorktree: true, gitStatus }))).toBe( + "review", + ); + }); + + it("puts a branch ahead of upstream in review", () => { + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ aheadCount: 2 }) })), + ).toBe("review"); + }); + + it("puts a never-pushed branch ahead of (or with unknown distance to) the default in review", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + gitStatus: makeGitStatus({ hasUpstream: false, aheadOfDefaultCount: 3 }), + }), + ), + ).toBe("review"); + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ hasUpstream: false }) })), + ).toBe("review"); + }); + + it("puts a clean fully pushed feature branch without a PR in published", () => { + expect(deriveBoardColumn(makeColumnInput())).toBe("published"); + }); + + it("puts an open PR with unpublished work in review", () => { + const gitStatus = makeGitStatus({ + hasWorkingTreeChanges: true, + pr: makePr("open"), + }); + expect(deriveBoardColumn(makeColumnInput({ gitStatus }))).toBe("review"); + }); + + it("does not move a sibling thread to review for a dirty worktree that is still working", () => { + const gitStatus = makeGitStatus({ + hasWorkingTreeChanges: true, + pr: makePr("open"), + }); + expect( + deriveBoardColumn( + makeColumnInput({ + hasDedicatedWorktree: true, + hasWorkingThreadForWorktree: true, + gitStatus, + }), + ), + ).toBe("published"); + }); + + it("still moves locally-ahead siblings to review while their worktree is working", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + hasDedicatedWorktree: true, + hasWorkingThreadForWorktree: true, + gitStatus: makeGitStatus({ aheadCount: 1, pr: makePr("open") }), + }), + ), + ).toBe("review"); + }); + + it("puts a clean open PR in published", () => { + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ pr: makePr("open") }) })), + ).toBe("published"); + }); + + it("keeps an unsettled merged PR in published instead of guessing settled", () => { + expect( + deriveBoardColumn(makeColumnInput({ gitStatus: makeGitStatus({ pr: makePr("merged") }) })), + ).toBe("published"); + }); + + it("lets the settled flag win regardless of git or completion state", () => { + expect(deriveBoardColumn(makeColumnInput({ isSettled: true, gitStatus: null }))).toBe( + "settled", + ); + expect( + deriveBoardColumn( + makeColumnInput({ + isSettled: true, + gitStatus: makeGitStatus({ hasWorkingTreeChanges: true, aheadCount: 1 }), + }), + ), + ).toBe("settled"); + expect( + deriveBoardColumn(makeColumnInput({ isSettled: true, threadStatusLabel: "Completed" })), + ).toBe("settled"); + }); + + it("puts an unseen turn completion in review regardless of git state", () => { + const unseen = { + latestTurnCompletedAt: "2026-07-22T10:00:00.000Z", + lastVisitedAt: "2026-07-22T09:00:00.000Z", + }; + expect(deriveBoardColumn(makeColumnInput({ ...unseen, gitStatus: null }))).toBe("review"); + expect( + deriveBoardColumn( + makeColumnInput({ ...unseen, gitStatus: makeGitStatus({ pr: makePr("merged") }) }), + ), + ).toBe("review"); + }); + + it("keeps a working status pill in working even with an unseen completion", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + threadStatusLabel: "Working", + latestTurnCompletedAt: "2026-07-22T10:00:00.000Z", + lastVisitedAt: "2026-07-22T09:00:00.000Z", + }), + ), + ).toBe("working"); + }); + + it("keeps a visited ready session in review when its latest turn summary is unavailable", () => { + expect( + deriveBoardColumn( + makeColumnInput({ + latestTurnCompletedAt: null, + readySessionUpdatedAt: "2026-07-22T03:45:04.819Z", + lastVisitedAt: "2026-07-22T03:45:04.819Z", + gitStatus: null, + }), + ), + ).toBe("review"); + }); + + it("lets in-flight git work outrank a seen completion", () => { + const seen = { + latestTurnCompletedAt: "2026-07-22T09:00:00.000Z", + lastVisitedAt: "2026-07-22T10:00:00.000Z", + }; + expect( + deriveBoardColumn( + makeColumnInput({ ...seen, gitStatus: makeGitStatus({ hasWorkingTreeChanges: true }) }), + ), + ).toBe("review"); + expect(deriveBoardColumn(makeColumnInput({ ...seen }))).toBe("published"); + }); + + it("keeps a plan-only thread's column off its worktree's git state", () => { + // This git state would classify as published; a plan-mode thread does not + // own it (the implementation thread does), so the plan thread stays in + // review until settled. + const badgelessPlan = { + interactionMode: "plan" as const, + threadStatusLabel: null, + hasDedicatedWorktree: true, + gitStatus: makeGitStatus({ pr: makePr("open") }), + }; + expect( + deriveBoardColumn(makeColumnInput({ ...badgelessPlan, interactionMode: "default" })), + ).toBe("published"); + expect(deriveBoardColumn(makeColumnInput(badgelessPlan))).toBe("review"); + expect(deriveBoardColumn(makeColumnInput({ ...badgelessPlan, isSettled: true }))).toBe( + "settled", + ); + }); + + it("puts a clean default branch in review", () => { + const gitStatus = makeGitStatus({ refName: "main", isDefaultRef: true }); + expect(deriveBoardColumn(makeColumnInput({ threadBranch: "main", gitStatus }))).toBe("review"); + }); +}); + +describe("sortBoardThreads", () => { + const byUpdatedAt = (thread: { updatedAt: string }) => thread.updatedAt; + + it("orders by the selected timestamp descending", () => { + const sorted = sortBoardThreads( + [ + { id: "thread-1", updatedAt: "2026-07-20T10:00:00.000Z" }, + { id: "thread-2", updatedAt: "2026-07-21T10:00:00.000Z" }, + { id: "thread-3", updatedAt: "2026-07-19T10:00:00.000Z" }, + ], + byUpdatedAt, + ); + expect(sorted.map((thread) => thread.id)).toEqual(["thread-2", "thread-1", "thread-3"]); + }); + + it("breaks timestamp ties by thread id", () => { + const sorted = sortBoardThreads( + [ + { id: "thread-b", updatedAt: "2026-07-20T10:00:00.000Z" }, + { id: "thread-a", updatedAt: "2026-07-20T10:00:00.000Z" }, + ], + byUpdatedAt, + ); + expect(sorted.map((thread) => thread.id)).toEqual(["thread-a", "thread-b"]); + }); + + it("sorts invalid timestamps last", () => { + const sorted = sortBoardThreads( + [ + { id: "thread-1", updatedAt: "not-a-date" }, + { id: "thread-2", updatedAt: "2026-07-20T10:00:00.000Z" }, + ], + byUpdatedAt, + ); + expect(sorted.map((thread) => thread.id)).toEqual(["thread-2", "thread-1"]); + }); +}); + +describe("buildBoardColumns", () => { + it("sorts working threads by active session start (falling back to update time) and other columns by update time", () => { + const threads = [ + { + id: "thread-review-old", + updatedAt: "2026-07-18T10:00:00.000Z", + workingStartedAt: null, + }, + { + id: "thread-review-new", + updatedAt: "2026-07-21T10:00:00.000Z", + workingStartedAt: null, + }, + { + id: "thread-working-old", + updatedAt: "2026-07-22T10:00:00.000Z", + workingStartedAt: "2026-07-19T10:00:00.000Z", + }, + { + id: "thread-working-new", + updatedAt: "2026-07-20T10:00:00.000Z", + workingStartedAt: "2026-07-21T10:00:00.000Z", + }, + { + id: "thread-working-fallback", + updatedAt: "2026-07-23T10:00:00.000Z", + workingStartedAt: null, + }, + ]; + const columns = buildBoardColumns( + threads, + (thread) => (thread.id.startsWith("thread-working") ? "working" : "review"), + (thread) => thread.workingStartedAt, + ); + expect(columnThreadIds(columns.review)).toEqual(["thread-review-new", "thread-review-old"]); + expect(columnThreadIds(columns.working)).toEqual([ + "thread-working-fallback", + "thread-working-new", + "thread-working-old", + ]); + expect(columns.published).toEqual([]); + expect(columns.settled).toEqual([]); + }); + + it("hosts shared groups in their earliest column and orders members by actual column then time", () => { + const threads = [ + { + id: "group-review-old", + updatedAt: "2026-07-19T10:00:00.000Z", + workingStartedAt: null, + column: "review" as const, + groupKey: "shared-worktree", + }, + { + id: "group-working-old", + updatedAt: "2026-07-24T10:00:00.000Z", + workingStartedAt: "2026-07-20T10:00:00.000Z", + column: "working" as const, + groupKey: "shared-worktree", + }, + { + id: "group-published", + updatedAt: "2026-07-25T10:00:00.000Z", + workingStartedAt: null, + column: "published" as const, + groupKey: "shared-worktree", + }, + { + id: "group-review-new", + updatedAt: "2026-07-23T10:00:00.000Z", + workingStartedAt: null, + column: "review" as const, + groupKey: "shared-worktree", + }, + { + id: "group-working-new", + updatedAt: "2026-07-18T10:00:00.000Z", + workingStartedAt: "2026-07-22T10:00:00.000Z", + column: "working" as const, + groupKey: "shared-worktree", + }, + ]; + const columns = buildBoardColumns( + threads, + (thread) => thread.column, + (thread) => thread.workingStartedAt, + (thread) => thread.groupKey, + ); + + expect(columns.working).toEqual([ + { + kind: "worktreeGroup", + worktreeKey: "shared-worktree", + threads: [threads[4], threads[1], threads[3], threads[0], threads[2]], + }, + ]); + expect(columns.review).toEqual([]); + expect(columns.published).toEqual([]); + expect(columns.settled).toEqual([]); + }); + + it("uses the earliest represented column rather than moving every group to working", () => { + const threads = [ + { + id: "standalone-working", + updatedAt: "2026-07-22T10:00:00.000Z", + column: "working" as const, + groupKey: null, + }, + { + id: "group-settled", + updatedAt: "2026-07-23T10:00:00.000Z", + column: "settled" as const, + groupKey: "later-group", + }, + { + id: "group-review", + updatedAt: "2026-07-21T10:00:00.000Z", + column: "review" as const, + groupKey: "later-group", + }, + ]; + const columns = buildBoardColumns( + threads, + (thread) => thread.column, + () => null, + (thread) => thread.groupKey, + ); + + expect(columns.working).toEqual([{ kind: "thread", thread: threads[0] }]); + expect(columns.review).toEqual([ + { + kind: "worktreeGroup", + worktreeKey: "later-group", + threads: [threads[2], threads[1]], + }, + ]); + expect(columns.settled).toEqual([]); + }); +}); + +describe("countBoardColumnThreads", () => { + it("counts a worktree group as its member count", () => { + const items: BoardColumnItem<{ readonly id: string }>[] = [ + { kind: "thread", thread: { id: "thread-1" } }, + { + kind: "worktreeGroup", + worktreeKey: "shared-worktree", + threads: [{ id: "thread-2" }, { id: "thread-3" }], + }, + ]; + expect(countBoardColumnThreads(items)).toBe(3); + expect(countBoardColumnThreads([])).toBe(0); + }); +}); + +describe("sliceBoardSettledItems", () => { + const thread = (id: string): BoardColumnItem<{ readonly id: string }> => ({ + kind: "thread", + thread: { id }, + }); + const group = ( + worktreeKey: string, + ...ids: string[] + ): BoardColumnItem<{ readonly id: string }> => ({ + kind: "worktreeGroup", + worktreeKey, + threads: ids.map((id) => ({ id })), + }); + + it("returns the same array with no hidden count when the total fits the limit", () => { + const items = [thread("thread-1"), group("shared-worktree", "thread-2", "thread-3")]; + const result = sliceBoardSettledItems(items, 3); + expect(result.visibleItems).toBe(items); + expect(result.hiddenThreadCount).toBe(0); + }); + + it("slices plain thread items at the limit", () => { + const items = [thread("thread-1"), thread("thread-2"), thread("thread-3")]; + const result = sliceBoardSettledItems(items, 2); + expect(columnThreadIds(result.visibleItems)).toEqual(["thread-1", "thread-2"]); + expect(result.hiddenThreadCount).toBe(1); + }); + + it("includes a group straddling the limit whole and counts its members", () => { + const items = [ + thread("thread-1"), + group("shared-worktree", "thread-2", "thread-3", "thread-4"), + thread("thread-5"), + ]; + const result = sliceBoardSettledItems(items, 2); + expect(result.visibleItems).toEqual([items[0], items[1]]); + expect(result.hiddenThreadCount).toBe(1); + }); + + it("returns no visible items for a zero limit with non-empty input", () => { + const items = [thread("thread-1"), thread("thread-2")]; + const result = sliceBoardSettledItems(items, 0); + expect(result.visibleItems).toEqual([]); + expect(result.hiddenThreadCount).toBe(2); + }); +}); + +describe("buildBoardProjectFilterPredicate", () => { + const projectId = ProjectId.make("project-1"); + const otherProjectId = ProjectId.make("project-2"); + const snapshots = [ + { + projectKey: "logical-project-1", + memberProjectRefs: [ + scopeProjectRef(localEnvironmentId, projectId), + scopeProjectRef(remoteEnvironmentId, projectId), + ], + }, + ]; + + it("matches everything when no project is selected or the stored key no longer resolves", () => { + const noSelection = buildBoardProjectFilterPredicate({ selectedProjectKey: null, snapshots }); + expect(noSelection({ environmentId: localEnvironmentId, projectId: otherProjectId })).toBe( + true, + ); + const staleSelection = buildBoardProjectFilterPredicate({ + selectedProjectKey: "removed-project", + snapshots, + }); + expect(staleSelection({ environmentId: localEnvironmentId, projectId: otherProjectId })).toBe( + true, + ); + }); + + it("matches threads from any member project of the selected group", () => { + const predicate = buildBoardProjectFilterPredicate({ + selectedProjectKey: "logical-project-1", + snapshots, + }); + expect(predicate({ environmentId: localEnvironmentId, projectId })).toBe(true); + expect(predicate({ environmentId: remoteEnvironmentId, projectId })).toBe(true); + expect(predicate({ environmentId: localEnvironmentId, projectId: otherProjectId })).toBe(false); + }); +}); + +describe("boardWorktreeKey", () => { + it("returns null without a dedicated worktree", () => { + expect(boardWorktreeKey({ environmentId: localEnvironmentId, worktreePath: null })).toBeNull(); + expect(boardWorktreeKey({ environmentId: localEnvironmentId, worktreePath: " " })).toBeNull(); + }); +}); + +describe("resolveBoardDropIntent", () => { + it("maps the drop-zone droppables to their intents and everything else to null", () => { + expect(resolveBoardDropIntent(BOARD_ARCHIVE_DROPPABLE_ID)).toBe("archive"); + expect(resolveBoardDropIntent(BOARD_TRASH_DROPPABLE_ID)).toBe("trash"); + expect(resolveBoardDropIntent(BOARD_UNSETTLE_DROPPABLE_ID)).toBe("unsettle"); + expect(resolveBoardDropIntent(BOARD_SETTLED_COLUMN_DROPPABLE_ID)).toBe("settle"); + expect(resolveBoardDropIntent("board-column-review")).toBeNull(); + expect(resolveBoardDropIntent(null)).toBeNull(); + }); +}); + +describe("parseBoardWorktreeGroupDragId", () => { + it("round-trips the worktree key through the group drag id and rejects thread drag ids", () => { + const worktreeKey = boardWorktreeKey({ + environmentId: localEnvironmentId, + worktreePath: "/wt", + }); + expect(worktreeKey).not.toBeNull(); + const dragId = boardWorktreeGroupDragId(worktreeKey ?? ""); + + expect(dragId).not.toBe(worktreeKey); + expect(parseBoardWorktreeGroupDragId(dragId)).toBe(worktreeKey); + expect(parseBoardWorktreeGroupDragId("environment-local thread-1")).toBeNull(); + }); +}); diff --git a/apps/web/src/components/board/Board.logic.ts b/apps/web/src/components/board/Board.logic.ts new file mode 100644 index 000000000000..cb310211d781 --- /dev/null +++ b/apps/web/src/components/board/Board.logic.ts @@ -0,0 +1,390 @@ +import { scopedProjectKey, scopeProjectRef } from "@t3tools/client-runtime/environment"; +import type { + EnvironmentId, + ProjectId, + ProviderInteractionMode, + ScopedProjectRef, + VcsStatusResult, +} from "@t3tools/contracts"; +import { toSortableTimestamp } from "../../lib/threadSort"; +import { isCompletionUnseen, type ThreadStatusPill } from "../Sidebar.logic"; +import { resolveThreadPr } from "../ThreadStatusIndicators"; + +export type BoardColumnId = "working" | "review" | "published" | "settled"; + +export const BOARD_COLUMN_IDS: readonly BoardColumnId[] = [ + "working", + "review", + "published", + "settled", +]; + +export const BOARD_COLUMN_LABELS: Record = { + working: "Working", + review: "Review", + published: "Published", + settled: "Settled", +}; + +export const BOARD_TRASH_DROPPABLE_ID = "board-trash"; +export const BOARD_ARCHIVE_DROPPABLE_ID = "board-archive"; +export const BOARD_UNSETTLE_DROPPABLE_ID = "board-unsettle"; +export const BOARD_SETTLED_COLUMN_DROPPABLE_ID = "board-column-settled"; + +export type BoardDropIntent = "archive" | "trash" | "settle" | "unsettle"; + +/** Drag-overlay feedback per drop intent, shared by the card and group overlays. */ +export const BOARD_DROP_INTENT_OVERLAY_CLASSES: Record = { + archive: "scale-90 border-amber-500 opacity-60", + trash: "scale-90 border-destructive opacity-60", + settle: "scale-90 border-primary opacity-60", + unsettle: "scale-90 border-emerald-500 opacity-60", +}; + +/** + * Intent implied by the droppable currently under the pointer, or null when + * the drag is over neither zone. Drives feedback on the dragged card itself — + * the card usually covers the drop zone, hiding the zone's own highlight. + */ +export function resolveBoardDropIntent( + droppableId: string | number | null | undefined, +): BoardDropIntent | null { + if (droppableId === BOARD_ARCHIVE_DROPPABLE_ID) return "archive"; + if (droppableId === BOARD_TRASH_DROPPABLE_ID) return "trash"; + if (droppableId === BOARD_UNSETTLE_DROPPABLE_ID) return "unsettle"; + if (droppableId === BOARD_SETTLED_COLUMN_DROPPABLE_ID) return "settle"; + return null; +} + +const BOARD_WORKTREE_GROUP_DRAG_PREFIX = "board-worktree-group\u0000"; + +/** Draggable id for a whole worktree group; drops act on every member thread. */ +export function boardWorktreeGroupDragId(worktreeKey: string): string { + return `${BOARD_WORKTREE_GROUP_DRAG_PREFIX}${worktreeKey}`; +} + +/** Worktree key encoded in a group draggable id, or null for thread drags. */ +export function parseBoardWorktreeGroupDragId( + dragId: string | number | null | undefined, +): string | null { + return typeof dragId === "string" && dragId.startsWith(BOARD_WORKTREE_GROUP_DRAG_PREFIX) + ? dragId.slice(BOARD_WORKTREE_GROUP_DRAG_PREFIX.length) + : null; +} + +export interface BoardColumnInput { + threadStatusLabel: ThreadStatusPill["label"] | null; + interactionMode: ProviderInteractionMode; + isSettled: boolean; + latestTurnCompletedAt: string | null; + readySessionUpdatedAt: string | null; + lastVisitedAt: string | null; + threadBranch: string | null; + hasDedicatedWorktree: boolean; + hasWorkingThreadForWorktree: boolean; + gitStatus: VcsStatusResult | null; +} + +/** + * Whether the thread completed after the user's last visit. Falls back to the + * ready-session timestamp for providers whose shell cannot retain a + * latest-turn summary; both sources follow the sidebar's `isCompletionUnseen` + * rules. + */ +export function hasUnseenBoardCompletion( + input: Pick< + BoardColumnInput, + "latestTurnCompletedAt" | "readySessionUpdatedAt" | "lastVisitedAt" + >, +): boolean { + return isCompletionUnseen( + input.latestTurnCompletedAt ?? input.readySessionUpdatedAt, + input.lastVisitedAt, + ); +} + +/** + * Cache key for the board's aggregated VCS status map. Matches the dedupe + * granularity of the underlying subscription family: one entry per unique + * (environmentId, cwd) pair. + */ +export function boardGitKey(environmentId: EnvironmentId, cwd: string): string { + return `${environmentId}\u0000${cwd}`; +} + +/** + * Git status a thread may be attributed at all, or null. Threads sharing the + * project-root cwd must not inherit another branch's state, so without a + * dedicated worktree the checked-out ref has to match the thread's branch. + */ +export function resolveAppliedBoardGitStatus( + input: Pick, +): VcsStatusResult | null { + if (input.gitStatus === null || !input.gitStatus.isRepo) { + return null; + } + if (input.hasDedicatedWorktree) { + return input.gitStatus; + } + return input.threadBranch !== null && input.gitStatus.refName === input.threadBranch + ? input.gitStatus + : null; +} + +/** + * Lifecycle column for a thread. The server-backed settled flag is + * authoritative — safe to check first because `effectiveSettled` is never + * true for running or blocked threads, and it keeps a just-settled card from + * bouncing back to review on an unseen completion pill. Attention states win + * over the remaining lifecycle states: a thread blocked on the user + * (question/permission prompt) or holding an unseen completion sits in + * "review" regardless of git state. An actionable ready plan is also always + * reviewable. Git-driven columns still only move a card rightward as statuses + * stream in: unknown/unattributable git state falls through instead of + * guessing. + */ +export function deriveBoardColumn(input: BoardColumnInput): BoardColumnId { + if (input.isSettled) { + return "settled"; + } + + switch (input.threadStatusLabel) { + case "Pending Approval": + case "Awaiting Input": + case "Wake Required": + case "Plan Ready": + case "Completed": + return "review"; + case "Working": + case "Connecting": + case "Monitoring": + return "working"; + case null: + break; + default: { + const exhaustiveStatusLabel: never = input.threadStatusLabel; + return exhaustiveStatusLabel; + } + } + + if (hasUnseenBoardCompletion(input)) { + return "review"; + } + + // A plan-mode thread does not own worktree changes made by the separate + // implementation thread that consumed its plan. Keep its column tied to + // its own attention/completion state instead of the shared worktree. + const gitStatus = input.interactionMode === "plan" ? null : resolveAppliedBoardGitStatus(input); + if (gitStatus !== null) { + const hasUnpublishedWork = + (gitStatus.hasWorkingTreeChanges && !input.hasWorkingThreadForWorktree) || + gitStatus.aheadCount > 0 || + (!gitStatus.hasUpstream && (gitStatus.aheadOfDefaultCount ?? 0) > 0); + if (hasUnpublishedWork) { + return "review"; + } + + // A merged PR is not special-cased here: it settles the thread through + // `effectiveSettled` upstream. When that is unavailable (pinned active, + // server without the settlement capability) the branch classifies by its + // git state alone, since it could not be moved out of Settled anyway. + const pr = resolveThreadPr({ + threadBranch: input.threadBranch, + gitStatus: input.gitStatus, + }); + const isCleanPushedFeatureBranch = + gitStatus.aheadCount === 0 && gitStatus.hasUpstream && !gitStatus.isDefaultRef; + if (pr?.state === "open" || isCleanPushedFeatureBranch) { + return "published"; + } + } + + return "review"; +} + +export interface BoardSortableThread { + readonly id: string; + readonly updatedAt: string; +} + +/** Sorts board threads newest-first by the timestamp selected for the column. */ +export function sortBoardThreads( + threads: readonly T[], + getSortTimestamp: (thread: T) => string | null, +): T[] { + return [...threads].sort((left, right) => { + const leftTimestamp = + toSortableTimestamp(getSortTimestamp(left) ?? undefined) ?? Number.NEGATIVE_INFINITY; + const rightTimestamp = + toSortableTimestamp(getSortTimestamp(right) ?? undefined) ?? Number.NEGATIVE_INFINITY; + if (leftTimestamp !== rightTimestamp) { + return rightTimestamp > leftTimestamp ? 1 : -1; + } + return left.id < right.id ? -1 : left.id > right.id ? 1 : 0; + }); +} + +export type BoardColumnItem = + | { readonly kind: "thread"; readonly thread: T } + | { + readonly kind: "worktreeGroup"; + readonly worktreeKey: string; + readonly threads: readonly T[]; + }; + +/** + * Builds board items in lifecycle order. A shared group is emitted on its + * first encounter, which is its earliest column and most recent member there. + * Its members are already ordered by actual column, then that column's time. + */ +export function buildBoardColumns( + threads: readonly T[], + getColumn: (thread: T) => BoardColumnId, + getWorkingStartedAt: (thread: T) => string | null, + getGroupKey: (thread: T) => string | null = () => null, +): Record[]> { + const threadsByColumn: Record = { + working: [], + review: [], + published: [], + settled: [], + }; + for (const thread of threads) { + threadsByColumn[getColumn(thread)].push(thread); + } + for (const columnId of BOARD_COLUMN_IDS) { + threadsByColumn[columnId] = sortBoardThreads( + threadsByColumn[columnId], + columnId === "working" + ? (thread) => getWorkingStartedAt(thread) ?? thread.updatedAt + : (thread) => thread.updatedAt, + ); + } + + const groupMembersByKey = new Map(); + for (const columnId of BOARD_COLUMN_IDS) { + for (const thread of threadsByColumn[columnId]) { + const groupKey = getGroupKey(thread); + if (groupKey === null) { + continue; + } + const members = groupMembersByKey.get(groupKey); + if (members) { + members.push(thread); + } else { + groupMembersByKey.set(groupKey, [thread]); + } + } + } + + const columns: Record[]> = { + working: [], + review: [], + published: [], + settled: [], + }; + const emittedGroupKeys = new Set(); + for (const columnId of BOARD_COLUMN_IDS) { + for (const thread of threadsByColumn[columnId]) { + const groupKey = getGroupKey(thread); + const groupMembers = groupKey === null ? undefined : groupMembersByKey.get(groupKey); + if (groupKey === null || groupMembers === undefined || groupMembers.length < 2) { + columns[columnId].push({ kind: "thread", thread }); + continue; + } + if (emittedGroupKeys.has(groupKey)) { + continue; + } + emittedGroupKeys.add(groupKey); + columns[columnId].push({ + kind: "worktreeGroup", + worktreeKey: groupKey, + threads: groupMembers, + }); + } + } + return columns; +} + +/** Total threads across column items; a worktree group counts each member. */ +export function countBoardColumnThreads(items: readonly BoardColumnItem[]): number { + return items.reduce( + (count, item) => count + (item.kind === "thread" ? 1 : item.threads.length), + 0, + ); +} + +/** + * Settled-tail slice for the board column. The limit counts threads (a + * worktree group counts as its member count) so paging matches the sidebar's + * thread-based tail; a group straddling the limit is included whole since a + * group card cannot render partially. + */ +export function sliceBoardSettledItems( + items: readonly BoardColumnItem[], + limit: number, +): { visibleItems: readonly BoardColumnItem[]; hiddenThreadCount: number } { + const total = countBoardColumnThreads(items); + if (total <= limit) { + return { visibleItems: items, hiddenThreadCount: 0 }; + } + const visibleItems: BoardColumnItem[] = []; + let shown = 0; + for (const item of items) { + if (shown >= limit) break; + visibleItems.push(item); + shown += item.kind === "thread" ? 1 : item.threads.length; + } + return { visibleItems, hiddenThreadCount: total - shown }; +} + +export interface BoardWorktreeThread { + readonly environmentId: EnvironmentId; + readonly worktreePath: string | null; +} + +/** + * Identity of a thread's dedicated worktree for board grouping, or null when + * the thread runs in the shared project checkout. Only dedicated worktrees + * group: threads in the project root are unrelated lines of work even though + * they share a checkout. + */ +export function boardWorktreeKey(thread: BoardWorktreeThread): string | null { + const worktreePath = thread.worktreePath?.trim(); + if (!worktreePath) { + return null; + } + return `${thread.environmentId}\u0000${worktreePath}`; +} + +export interface BoardProjectFilterThread { + readonly environmentId: EnvironmentId; + readonly projectId: ProjectId; +} + +/** + * Predicate matching threads against a selected sidebar project group. + * Membership is by scoped project ref so locally+remotely-open copies of the + * same repository stay one entry, matching the sidebar's grouping. An + * unresolvable stored key (project removed, grouping changed) matches + * everything, i.e. falls back to "All projects". + */ +export function buildBoardProjectFilterPredicate(input: { + selectedProjectKey: string | null; + snapshots: ReadonlyArray<{ + readonly projectKey: string; + readonly memberProjectRefs: readonly ScopedProjectRef[]; + }>; +}): (thread: BoardProjectFilterThread) => boolean { + const selectedSnapshot = + input.selectedProjectKey === null + ? null + : (input.snapshots.find((snapshot) => snapshot.projectKey === input.selectedProjectKey) ?? + null); + if (selectedSnapshot === null) { + return () => true; + } + const memberKeys = new Set(selectedSnapshot.memberProjectRefs.map(scopedProjectKey)); + return (thread) => + memberKeys.has(scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId))); +} diff --git a/apps/web/src/components/board/BoardCard.test.tsx b/apps/web/src/components/board/BoardCard.test.tsx new file mode 100644 index 000000000000..e8756ccca319 --- /dev/null +++ b/apps/web/src/components/board/BoardCard.test.tsx @@ -0,0 +1,270 @@ +import { DndContext } from "@dnd-kit/core"; +import { + DEFAULT_RUNTIME_MODE, + EnvironmentId, + IdentityUsername, + PersonId, + ProjectId, + ProviderInstanceId, + ThreadId, + type VcsStatusResult, +} from "@t3tools/contracts"; +import { renderToStaticMarkup } from "react-dom/server"; +import { describe, expect, it } from "vite-plus/test"; + +import type { SidebarThreadSummary } from "../../types"; +import { BoardCard, BoardCardDragOverlay } from "./BoardCard"; + +const environmentId = EnvironmentId.make("environment-local"); + +function makeThread(overrides: Partial = {}): SidebarThreadSummary { + return { + id: ThreadId.make("thread-1"), + environmentId, + projectId: ProjectId.make("project-1"), + title: "Fix board keyboard semantics", + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, + runtimeMode: DEFAULT_RUNTIME_MODE, + interactionMode: "default", + session: null, + createdAt: "2026-07-22T09:00:00.000Z", + updatedAt: "2026-07-22T10:00:00.000Z", + archivedAt: null, + latestTurn: null, + latestUserMessageAt: "2026-07-22T09:30:00.000Z", + branch: "feature/board", + worktreePath: null, + pullRequests: [], + hasPendingApprovals: false, + hasPendingUserInput: false, + hasActionableProposedPlan: false, + settledOverride: null, + settledAt: null, + ...overrides, + }; +} + +function makeGitStatus(): VcsStatusResult { + return { + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "feature/board", + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + pr: { + number: 42, + title: "Board controls", + url: "https://github.com/example/repo/pull/42", + baseRef: "main", + headRef: "feature/board", + state: "open", + }, + }; +} + +function renderCard(thread: SidebarThreadSummary = makeThread(), isSettled = false): string { + return renderToStaticMarkup( + + {}} + onShowContextMenu={() => {}} + dragClickGuard={{ + startDrag: () => {}, + finishDrag: () => {}, + consumeSuppressedClick: () => false, + dispose: () => {}, + }} + /> + , + ); +} + +describe("BoardCard", () => { + it("uses a noninteractive card root and a native open-thread button", () => { + const markup = renderCard(); + const rootTag = markup.match(/]*data-testid="board-card-thread-1"[^>]*>/)?.[0]; + + expect(rootTag).toBeDefined(); + expect(rootTag).not.toContain('role="button"'); + expect(rootTag).not.toContain('tabindex="0"'); + expect(markup).toContain('", openButtonStart); + const prButtonStart = markup.indexOf(' + ) : ( + + # + {pr.number} + + ) + ) : null} + {dirtyFileCount > 0 ? ( + + {dirtyFileCount} {dirtyFileCount === 1 ? "file" : "files"} + + ) : null} + {aheadCount > 0 ? ( + ↑{aheadCount} + ) : null} + {gitStatusPending ? ( + + ) : null} + + + {driverKind ? ( + + } + > + + + {modelLabel} + + ) : null} + +
    • + + ); +} + +export const BoardCard = memo(function BoardCard({ + thread, + project, + gitStatus, + gitStatusPending, + isSettled, + onOpenThread, + onShowContextMenu, + dragClickGuard, +}: BoardCardProps) { + const threadRef = scopeThreadRef(thread.environmentId, thread.id); + const { attributes, listeners, setNodeRef, isDragging } = useDraggable({ + id: scopedThreadKey(threadRef), + data: { threadRef }, + }); + + const openThread = () => { + if (dragClickGuard.consumeSuppressedClick()) { + return; + } + onOpenThread(threadRef); + }; + + const showContextMenu = (event: MouseEvent) => { + event.preventDefault(); + event.stopPropagation(); + onShowContextMenu(thread, { x: event.clientX, y: event.clientY }); + }; + + return ( +
    + { + event.stopPropagation(); + openThread(); + }} + /> +
    + ); +}); + +/** Non-interactive clone rendered inside the DragOverlay while dragging. */ +export function BoardCardDragOverlay({ + thread, + project, + gitStatus, + gitStatusPending, + isSettled, + dropIntent = null, +}: Pick & { + dropIntent?: BoardDropIntent | null; +}) { + return ( + + ); +} diff --git a/apps/web/src/components/board/BoardColumn.tsx b/apps/web/src/components/board/BoardColumn.tsx new file mode 100644 index 000000000000..dbc77169a201 --- /dev/null +++ b/apps/web/src/components/board/BoardColumn.tsx @@ -0,0 +1,55 @@ +import type { ReactNode } from "react"; + +import { cn } from "../../lib/utils"; +import { ScrollArea } from "../ui/scroll-area"; +import { BOARD_COLUMN_LABELS, type BoardColumnId } from "./Board.logic"; + +/** Small rounded count pill used by column headers and worktree groups. */ +export function BoardCountPill({ count, className }: { count: number; className?: string }) { + return ( + + {count} + + ); +} + +export function BoardColumn({ + columnId, + count, + children, +}: { + columnId: BoardColumnId; + count: number; + children: ReactNode; +}) { + return ( +
    +
    + {BOARD_COLUMN_LABELS[columnId]} + +
    + {/* Horizontal touch pans must chain to the board's scroll container; + the viewport's default overscroll containment would swallow them. */} + +
    + {count === 0 ? ( +
    + No threads +
    + ) : ( + children + )} +
    +     +
    + ); +} diff --git a/apps/web/src/components/board/BoardDragClickGuard.test.ts b/apps/web/src/components/board/BoardDragClickGuard.test.ts new file mode 100644 index 000000000000..b35ef0580d01 --- /dev/null +++ b/apps/web/src/components/board/BoardDragClickGuard.test.ts @@ -0,0 +1,48 @@ +import { afterEach, describe, expect, it, vi } from "vite-plus/test"; + +import { createBoardDragClickGuard } from "./BoardDragClickGuard"; + +afterEach(() => { + vi.useRealTimers(); +}); + +describe("createBoardDragClickGuard", () => { + it("does not suppress ordinary clicks", () => { + const guard = createBoardDragClickGuard(); + + expect(guard.consumeSuppressedClick()).toBe(false); + }); + + it("suppresses the click generated when a drag finishes", () => { + const guard = createBoardDragClickGuard(); + + guard.startDrag(); + guard.finishDrag(); + + expect(guard.consumeSuppressedClick()).toBe(true); + expect(guard.consumeSuppressedClick()).toBe(false); + }); + + it("releases suppression when a finished drag produces no click", () => { + vi.useFakeTimers(); + const guard = createBoardDragClickGuard(); + + guard.startDrag(); + guard.finishDrag(); + vi.runOnlyPendingTimers(); + + expect(guard.consumeSuppressedClick()).toBe(false); + }); + + it("does not let an earlier reset clear suppression for a newer drag", () => { + vi.useFakeTimers(); + const guard = createBoardDragClickGuard(); + + guard.startDrag(); + guard.finishDrag(); + guard.startDrag(); + vi.runOnlyPendingTimers(); + + expect(guard.consumeSuppressedClick()).toBe(true); + }); +}); diff --git a/apps/web/src/components/board/BoardDragClickGuard.ts b/apps/web/src/components/board/BoardDragClickGuard.ts new file mode 100644 index 000000000000..cd99579db08c --- /dev/null +++ b/apps/web/src/components/board/BoardDragClickGuard.ts @@ -0,0 +1,47 @@ +export interface BoardDragClickGuard { + startDrag: () => void; + finishDrag: () => void; + consumeSuppressedClick: () => boolean; + dispose: () => void; +} + +/** + * Prevents the click synthesized by the pointer release that finishes a drag + * from opening a thread. If that release produces no click, the suppression + * expires on the next task instead of swallowing a later, intentional click. + */ +export function createBoardDragClickGuard(): BoardDragClickGuard { + let suppressClick = false; + let resetTimer: ReturnType | null = null; + + const clearResetTimer = () => { + if (resetTimer !== null) { + clearTimeout(resetTimer); + resetTimer = null; + } + }; + + return { + startDrag() { + clearResetTimer(); + suppressClick = true; + }, + finishDrag() { + clearResetTimer(); + resetTimer = setTimeout(() => { + suppressClick = false; + resetTimer = null; + }, 0); + }, + consumeSuppressedClick() { + if (!suppressClick) { + return false; + } + suppressClick = false; + return true; + }, + dispose() { + clearResetTimer(); + }, + }; +} diff --git a/apps/web/src/components/board/BoardDropZones.tsx b/apps/web/src/components/board/BoardDropZones.tsx new file mode 100644 index 000000000000..5c6135677497 --- /dev/null +++ b/apps/web/src/components/board/BoardDropZones.tsx @@ -0,0 +1,78 @@ +import { useDroppable } from "@dnd-kit/core"; +import { ArchiveIcon, ArchiveRestoreIcon, Trash2Icon, type LucideIcon } from "lucide-react"; + +import { cn } from "../../lib/utils"; +import { + BOARD_ARCHIVE_DROPPABLE_ID, + BOARD_TRASH_DROPPABLE_ID, + BOARD_UNSETTLE_DROPPABLE_ID, +} from "./Board.logic"; + +function BoardDropZone({ + droppableId, + testId, + label, + icon: Icon, + activeClass, +}: { + droppableId: string; + testId: string; + label: string; + icon: LucideIcon; + activeClass: string; +}) { + const { isOver, setNodeRef } = useDroppable({ id: droppableId }); + + return ( +
    + + {label} +
    + ); +} + +/** + * Floating droppables shown while a drag is active: archive and delete are + * always available, and restore (un-settle) appears when the drag includes a + * settled thread. Columns are derived state, so settling happens by dropping + * on the Settled column itself rather than a zone here. + */ +export function BoardDropZones({ showRestoreZone }: { showRestoreZone: boolean }) { + return ( + // w-max: shrink-to-fit against left:50% would otherwise cap the width at + // half the board and wrap the labels on narrow viewports. +
    + {showRestoreZone ? ( + + ) : null} + + +
    + ); +} diff --git a/apps/web/src/components/board/BoardScroll.test.ts b/apps/web/src/components/board/BoardScroll.test.ts new file mode 100644 index 000000000000..2a8ad4744e72 --- /dev/null +++ b/apps/web/src/components/board/BoardScroll.test.ts @@ -0,0 +1,157 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { scrollBoardFromWheel, shouldScrollColumnFromWheel } from "./BoardScroll"; + +function makeContainer(overrides: Partial = {}): MockScrollContainer { + return { + clientWidth: 500, + scrollLeft: 200, + scrollWidth: 1_500, + ...overrides, + }; +} + +interface MockScrollContainer { + clientWidth: number; + scrollLeft: number; + scrollWidth: number; +} + +describe("shouldScrollColumnFromWheel", () => { + const verticalWheel = { deltaX: 0, deltaY: 50 }; + + it("keeps vertical wheel movement in a column that can scroll in that direction", () => { + expect( + shouldScrollColumnFromWheel( + { clientHeight: 500, scrollHeight: 1_000, scrollTop: 200 }, + verticalWheel, + ), + ).toBe(true); + expect( + shouldScrollColumnFromWheel( + { clientHeight: 500, scrollHeight: 1_000, scrollTop: 200 }, + { deltaX: 0, deltaY: -50 }, + ), + ).toBe(true); + }); + + it("releases vertical movement to the board at the matching column edge", () => { + expect( + shouldScrollColumnFromWheel( + { clientHeight: 500, scrollHeight: 1_000, scrollTop: 500 }, + verticalWheel, + ), + ).toBe(false); + expect( + shouldScrollColumnFromWheel( + { clientHeight: 500, scrollHeight: 1_000, scrollTop: 0 }, + { deltaX: 0, deltaY: -50 }, + ), + ).toBe(false); + }); + + it("releases horizontal gestures and non-overflowing columns to the board", () => { + expect( + shouldScrollColumnFromWheel( + { clientHeight: 500, scrollHeight: 1_000, scrollTop: 200 }, + { deltaX: 50, deltaY: 10 }, + ), + ).toBe(false); + expect( + shouldScrollColumnFromWheel( + { clientHeight: 500, scrollHeight: 500, scrollTop: 0 }, + verticalWheel, + ), + ).toBe(false); + }); +}); + +describe("scrollBoardFromWheel", () => { + it("maps vertical wheel movement to horizontal board movement", () => { + const container = makeContainer(); + + expect( + scrollBoardFromWheel(container, { + ctrlKey: false, + deltaMode: 0, + deltaX: 0, + deltaY: 80, + }), + ).toBe(true); + expect(container.scrollLeft).toBe(280); + + scrollBoardFromWheel(container, { + ctrlKey: false, + deltaMode: 0, + deltaX: 0, + deltaY: -50, + }); + expect(container.scrollLeft).toBe(230); + + // Horizontal trackpad movement wins when it is the dominant axis. + scrollBoardFromWheel(container, { + ctrlKey: false, + deltaMode: 0, + deltaX: 60, + deltaY: 10, + }); + expect(container.scrollLeft).toBe(290); + }); + + it("normalizes line and page wheel deltas", () => { + const lineContainer = makeContainer(); + const pageContainer = makeContainer(); + + scrollBoardFromWheel(lineContainer, { + ctrlKey: false, + deltaMode: 1, + deltaX: 0, + deltaY: 2, + }); + scrollBoardFromWheel(pageContainer, { + ctrlKey: false, + deltaMode: 2, + deltaX: 0, + deltaY: 1, + }); + + expect(lineContainer.scrollLeft).toBe(232); + expect(pageContainer.scrollLeft).toBe(700); + }); + + it("clamps movement at both ends while retaining ownership of board scrolling", () => { + const rightEdge = makeContainer({ scrollLeft: 990 }); + const leftEdge = makeContainer({ scrollLeft: 10 }); + + expect( + scrollBoardFromWheel(rightEdge, { + ctrlKey: false, + deltaMode: 0, + deltaX: 0, + deltaY: 100, + }), + ).toBe(true); + expect(rightEdge.scrollLeft).toBe(1_000); + + expect( + scrollBoardFromWheel(leftEdge, { + ctrlKey: false, + deltaMode: 0, + deltaX: 0, + deltaY: -100, + }), + ).toBe(true); + expect(leftEdge.scrollLeft).toBe(0); + }); + + it("leaves pinch zoom and non-overflowing boards untouched", () => { + const zoomContainer = makeContainer(); + const fittingContainer = makeContainer({ clientWidth: 1_500 }); + const wheel = { ctrlKey: false, deltaMode: 0, deltaX: 0, deltaY: 100 }; + + expect(scrollBoardFromWheel(zoomContainer, { ...wheel, ctrlKey: true })).toBe(false); + expect(zoomContainer.scrollLeft).toBe(200); + expect(scrollBoardFromWheel(fittingContainer, wheel)).toBe(false); + expect(fittingContainer.scrollLeft).toBe(200); + }); +}); diff --git a/apps/web/src/components/board/BoardScroll.ts b/apps/web/src/components/board/BoardScroll.ts new file mode 100644 index 000000000000..ed607d997936 --- /dev/null +++ b/apps/web/src/components/board/BoardScroll.ts @@ -0,0 +1,84 @@ +const PIXELS_PER_WHEEL_LINE = 16; + +interface BoardScrollContainer { + readonly clientWidth: number; + scrollLeft: number; + readonly scrollWidth: number; +} + +interface BoardWheelInput { + readonly ctrlKey: boolean; + readonly deltaMode: number; + readonly deltaX: number; + readonly deltaY: number; +} + +interface ColumnScrollContainer { + readonly clientHeight: number; + readonly scrollHeight: number; + readonly scrollTop: number; +} + +interface WheelAxes { + readonly deltaX: number; + readonly deltaY: number; +} + +/** Returns true when a vertical gesture can still move an overflowing column. */ +export function shouldScrollColumnFromWheel( + container: ColumnScrollContainer, + event: WheelAxes, +): boolean { + if ( + !Number.isFinite(event.deltaY) || + event.deltaY === 0 || + Math.abs(event.deltaX) >= Math.abs(event.deltaY) + ) { + return false; + } + + const maxScrollTop = Math.max(0, container.scrollHeight - container.clientHeight); + if (maxScrollTop === 0) { + return false; + } + + return event.deltaY < 0 ? container.scrollTop > 0 : container.scrollTop < maxScrollTop; +} + +/** + * Redirects the wheel's dominant axis into the board's native horizontal + * scroll position. Handling horizontal input here as well keeps nested column + * scroll areas from swallowing trackpad gestures before they reach the board. + */ +export function scrollBoardFromWheel( + container: BoardScrollContainer, + event: BoardWheelInput, +): boolean { + if (event.ctrlKey) { + // Ctrl+wheel is commonly a trackpad pinch gesture. Leave browser zoom alone. + return false; + } + + const maxScrollLeft = Math.max(0, container.scrollWidth - container.clientWidth); + if (maxScrollLeft === 0) { + return false; + } + + const dominantDelta = + Math.abs(event.deltaX) > Math.abs(event.deltaY) ? event.deltaX : event.deltaY; + if (!Number.isFinite(dominantDelta) || dominantDelta === 0) { + return false; + } + + const multiplier = + event.deltaMode === 1 + ? PIXELS_PER_WHEEL_LINE + : event.deltaMode === 2 + ? container.clientWidth + : 1; + container.scrollLeft = Math.min( + maxScrollLeft, + Math.max(0, container.scrollLeft + dominantDelta * multiplier), + ); + return true; +} diff --git a/apps/web/src/components/board/BoardView.tsx b/apps/web/src/components/board/BoardView.tsx new file mode 100644 index 000000000000..ff5ffeb6b434 --- /dev/null +++ b/apps/web/src/components/board/BoardView.tsx @@ -0,0 +1,1085 @@ +import { useAtomValue } from "@effect/atom-react"; +import { + DndContext, + DragOverlay, + MouseSensor, + pointerWithin, + TouchSensor, + useSensor, + useSensors, + type DragEndEvent, + type DragOverEvent, + type DragStartEvent, +} from "@dnd-kit/core"; +import { + scopedProjectKey, + scopedThreadKey, + scopeProjectRef, + scopeThreadRef, +} from "@t3tools/client-runtime/environment"; +import { + isAtomCommandInterrupted, + settlePromise, + squashAtomCommandFailure, + type AtomCommandResult, +} from "@t3tools/client-runtime/state/runtime"; +import { canSnooze, effectiveSnoozed } from "@t3tools/client-runtime/state/thread-settled"; +import type { EnvironmentId, ScopedThreadRef, VcsStatusResult } from "@t3tools/contracts"; +import { useNavigate } from "@tanstack/react-router"; +import * as Schema from "effect/Schema"; +import { useCallback, useEffect, useMemo, useRef, useState } from "react"; + +import { + isIdentityClaimRequiredMessage, + requestIdentityClaimGate, +} from "../identity/IdentityClaimGate"; +import { isDesktopLocalConnectionTarget } from "../../connection/desktopLocal"; +import { isElectron } from "../../env"; +import { useNewThreadHandler } from "../../hooks/useHandleNewThread"; +import { useLocalStorage } from "../../hooks/useLocalStorage"; +import { useNowMinute } from "../../hooks/useNowMinute"; +import { useClientSettings } from "../../hooks/useSettings"; +import { useThreadActions } from "../../hooks/useThreadActions"; +import { cn } from "../../lib/utils"; +import { readLocalApi } from "../../localApi"; +import { selectProjectGroupingSettings } from "../../logicalProject"; +import { + buildSidebarProjectSnapshots, + type SidebarProjectSnapshot, +} from "../../sidebarProjectGrouping"; +import { + useAllEnvironmentShellsBootstrapped, + useProjects, + useServerConfigs, + useThreadShells, +} from "../../state/entities"; +import { useEnvironments, usePrimaryEnvironmentId } from "../../state/environments"; +import { buildThreadRouteParams } from "../../threadRoutes"; +import type { Project, SidebarThreadSummary } from "../../types"; +import { useUiStateStore } from "../../uiStateStore"; +import { COLLAPSED_SIDEBAR_TITLEBAR_INSET_CLASS } from "../../workspaceTitlebar"; +import { ListEnvironmentFilterControl } from "../ListEnvironmentFilterControl"; +import { + EMPTY_LIST_ENVIRONMENT_FILTER, + LIST_ENVIRONMENT_FILTER_STORAGE_KEY, + ListEnvironmentFilterSchema, + matchesEnvironmentFilter, + resolveSelectedEnvironmentIds, +} from "../listEnvironmentFilter"; +import { buildOwnershipPredicate, useOwnershipFilter } from "../ownershipFilter"; +import { identityClaimPersonIdByEnvironmentAtom } from "../../state/identity"; +import { ProjectFavicon, ProjectFaviconFallback } from "../ProjectFavicon"; +import { + SETTLED_TAIL_INITIAL_COUNT, + SETTLED_TAIL_PAGE_COUNT, + archiveSelectedThreadEntries, + buildSidebarV2ThreadContextMenuItems, + isThreadSettledForDisplay, + resolveThreadStatusPill, +} from "../Sidebar.logic"; +import { resolveSnoozePresets, snoozeWakeDescription } from "../Sidebar.snooze"; +import { resolveThreadPr } from "../ThreadStatusIndicators"; +import { Button } from "../ui/button"; +import { + Dialog, + DialogDescription, + DialogFooter, + DialogHeader, + DialogPanel, + DialogPopup, + DialogTitle, +} from "../ui/dialog"; +import { Input } from "../ui/input"; +import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select"; +import { SidebarInset } from "../ui/sidebar"; +import { Spinner } from "../ui/spinner"; +import { stackedThreadToast, toastManager } from "../ui/toast"; +import { + BOARD_COLUMN_IDS, + boardGitKey, + boardWorktreeKey, + buildBoardColumns, + buildBoardProjectFilterPredicate, + countBoardColumnThreads, + deriveBoardColumn, + parseBoardWorktreeGroupDragId, + resolveBoardDropIntent, + sliceBoardSettledItems, + type BoardDropIntent, +} from "./Board.logic"; +import { BoardCard, BoardCardDragOverlay } from "./BoardCard"; +import { BoardColumn } from "./BoardColumn"; +import { createBoardDragClickGuard } from "./BoardDragClickGuard"; +import { BoardDropZones } from "./BoardDropZones"; +import { scrollBoardFromWheel, shouldScrollColumnFromWheel } from "./BoardScroll"; +import { BoardWorktreeGroup, BoardWorktreeGroupDragOverlay } from "./BoardWorktreeGroup"; +import { useBoardVcsStatuses, type BoardVcsTarget } from "./useBoardVcsStatuses"; + +const BOARD_PROJECT_FILTER_STORAGE_KEY = "t3code:board:project-filter:v1"; +const BOARD_PROJECT_FILTER_ALL = "all"; +const BoardProjectFilterSchema = Schema.NullOr(Schema.String); + +interface BoardThreadGitContext { + readonly project: Project | null; + readonly gitStatus: VcsStatusResult | null; + readonly gitStatusPending: boolean; +} + +/** Error toast for a failed thread action; interruptions and successes are silent. */ +function reportThreadActionFailure( + result: AtomCommandResult, + title: string, + environmentId?: EnvironmentId | null, +) { + if (result._tag !== "Failure" || isAtomCommandInterrupted(result)) { + return; + } + const error = squashAtomCommandFailure(result); + const message = error instanceof Error ? error.message : "An error occurred."; + if (isIdentityClaimRequiredMessage(message)) { + requestIdentityClaimGate(environmentId); + } + toastManager.add( + stackedThreadToast({ + type: "error", + title, + description: message, + }), + ); +} + +export function BoardView() { + const bootstrapped = useAllEnvironmentShellsBootstrapped(); + + return ( + +
    + {bootstrapped ? ( + + ) : ( +
    + +
    + )} +
    +     + ); +} + +function BoardContent() { + const projects = useProjects(); + const threadShells = useThreadShells(); + const { environments } = useEnvironments(); + const primaryEnvironmentId = usePrimaryEnvironmentId(); + const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings); + const timestampFormat = useClientSettings((s) => s.timestampFormat); + const serverConfigs = useServerConfigs(); + const { + archiveThread, + confirmAndDeleteThread, + confirmAndDeleteThreads, + renameThread, + settleThread, + snoozeThread, + unsettleThread, + unsnoozeThread, + } = useThreadActions(); + const handleNewThread = useNewThreadHandler(); + const navigate = useNavigate(); + const boardScrollRef = useRef(null); + const markThreadUnread = useUiStateStore((state) => state.markThreadUnread); + const [threadRenameTarget, setThreadRenameTarget] = useState(null); + const [threadRenameTitle, setThreadRenameTitle] = useState(""); + + useEffect(() => { + const scrollContainer = boardScrollRef.current; + if (scrollContainer === null) { + return; + } + + const handleWheel = (event: WheelEvent) => { + const columnScrollViewport = + event.target instanceof Element + ? event.target.closest( + '[data-testid^="board-column-"] [data-slot="scroll-area-viewport"]', + ) + : null; + if ( + columnScrollViewport instanceof HTMLElement && + shouldScrollColumnFromWheel(columnScrollViewport, event) + ) { + return; + } + + if (scrollBoardFromWheel(scrollContainer, event)) { + event.preventDefault(); + } + }; + + // React's delegated wheel events can be passive. This listener must be + // non-passive so gestures released by nested columns can move the board. + scrollContainer.addEventListener("wheel", handleWheel, { passive: false }); + return () => scrollContainer.removeEventListener("wheel", handleWheel); + }, []); + + const [storedProjectFilter, setStoredProjectFilter] = useLocalStorage( + BOARD_PROJECT_FILTER_STORAGE_KEY, + null, + BoardProjectFilterSchema, + ); + const [storedEnvironmentFilter, setStoredEnvironmentFilter] = useLocalStorage( + LIST_ENVIRONMENT_FILTER_STORAGE_KEY, + EMPTY_LIST_ENVIRONMENT_FILTER, + ListEnvironmentFilterSchema, + ); + const availableEnvironmentIds = useMemo( + () => new Set(environments.map((environment) => environment.environmentId)), + [environments], + ); + const selectedEnvironmentIds = useMemo( + () => + resolveSelectedEnvironmentIds( + storedEnvironmentFilter as readonly EnvironmentId[], + availableEnvironmentIds, + ), + [availableEnvironmentIds, storedEnvironmentFilter], + ); + const environmentFilterOptions = useMemo( + () => + environments.map((environment) => ({ + environmentId: environment.environmentId, + label: environment.label, + })), + [environments], + ); + const handleSelectedEnvironmentIdsChange = useCallback( + (next: readonly EnvironmentId[]) => { + setStoredEnvironmentFilter([...next]); + }, + [setStoredEnvironmentFilter], + ); + + const environmentLabelById = useMemo( + () => + new Map( + environments.map((environment) => [environment.environmentId, environment.label] as const), + ), + [environments], + ); + const desktopLocalEnvironmentIds = useMemo( + () => + new Set( + environments + .filter((environment) => isDesktopLocalConnectionTarget(environment.entry.target)) + .map((environment) => environment.environmentId), + ), + [environments], + ); + const projectSnapshots = useMemo( + () => + buildSidebarProjectSnapshots({ + projects, + settings: projectGroupingSettings, + primaryEnvironmentId, + resolveEnvironmentLabel: (environmentId) => environmentLabelById.get(environmentId) ?? null, + isDesktopLocalEnvironment: (environmentId) => desktopLocalEnvironmentIds.has(environmentId), + }), + [ + desktopLocalEnvironmentIds, + environmentLabelById, + primaryEnvironmentId, + projectGroupingSettings, + projects, + ], + ); + + const projectByKey = useMemo( + () => + new Map( + projects.map( + (project) => + [ + scopedProjectKey(scopeProjectRef(project.environmentId, project.id)), + project, + ] as const, + ), + ), + [projects], + ); + + // The ownership selection is a user-level "whose work am I looking at", + // shared with the sidebar rather than a sidebar-only view: a board sitting + // beside a sidebar filtered to Mine must not show everyone's threads. + const { mode: ownershipMode, relation: ownershipRelation } = useOwnershipFilter(); + const claimPersonIdByEnvironment = useAtomValue(identityClaimPersonIdByEnvironmentAtom); + const ownershipPredicate = useMemo( + () => + buildOwnershipPredicate({ + claimPersonIdByEnvironment, + mode: ownershipMode, + relation: ownershipRelation, + }), + [claimPersonIdByEnvironment, ownershipMode, ownershipRelation], + ); + const threads = useMemo( + () => + threadShells.filter( + (thread) => + thread.archivedAt === null && + matchesEnvironmentFilter(thread.environmentId, selectedEnvironmentIds) && + ownershipPredicate(thread), + ), + [ownershipPredicate, selectedEnvironmentIds, threadShells], + ); + const envFilteredProjectSnapshots = useMemo( + () => + projectSnapshots.filter((snapshot) => + snapshot.memberProjects.some((member) => + matchesEnvironmentFilter(member.environmentId, selectedEnvironmentIds), + ), + ), + [projectSnapshots, selectedEnvironmentIds], + ); + const filterPredicate = useMemo( + () => + buildBoardProjectFilterPredicate({ + selectedProjectKey: storedProjectFilter, + snapshots: envFilteredProjectSnapshots, + }), + [envFilteredProjectSnapshots, storedProjectFilter], + ); + const filteredThreads = useMemo( + () => threads.filter(filterPredicate), + [filterPredicate, threads], + ); + + const resolveThreadGitCwd = useCallback( + (thread: SidebarThreadSummary): string | null => { + if (thread.branch == null) { + return null; + } + const project = projectByKey.get( + scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId)), + ); + return thread.worktreePath ?? project?.workspaceRoot ?? null; + }, + [projectByKey], + ); + + const vcsTargets = useMemo( + () => + filteredThreads.flatMap((thread) => { + const cwd = resolveThreadGitCwd(thread); + return cwd === null ? [] : [{ environmentId: thread.environmentId, cwd }]; + }), + [filteredThreads, resolveThreadGitCwd], + ); + const gitStatuses = useBoardVcsStatuses(vcsTargets); + + const getThreadGitContext = useCallback( + (thread: SidebarThreadSummary): BoardThreadGitContext => { + const project = + projectByKey.get( + scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId)), + ) ?? null; + const cwd = resolveThreadGitCwd(thread); + const gitStatus = + cwd === null ? null : (gitStatuses.get(boardGitKey(thread.environmentId, cwd)) ?? null); + return { + project, + gitStatus, + gitStatusPending: cwd !== null && gitStatus === null, + }; + }, + [gitStatuses, projectByKey, resolveThreadGitCwd], + ); + + const nowMinute = useNowMinute(); + + const previousSettledThreadKeys = useRef>(new Set()); + const settledThreadKeys = useMemo(() => { + const now = `${nowMinute}:00.000Z`; + const keys = new Set(); + for (const thread of filteredThreads) { + const changeRequestState = + resolveThreadPr({ + threadBranch: thread.branch, + gitStatus: getThreadGitContext(thread).gitStatus, + })?.state ?? null; + if ( + isThreadSettledForDisplay(thread, { + serverConfigs, + now, + autoSettleAfterDays: null, + changeRequestState, + }) + ) { + keys.add(scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id))); + } + } + // Column building and the drag handlers key on this set; keep the previous + // identity when the contents did not change so the minute tick and + // git-status churn don't cascade a full board re-render. + const previous = previousSettledThreadKeys.current; + if (previous.size === keys.size && [...keys].every((key) => previous.has(key))) { + return previous; + } + previousSettledThreadKeys.current = keys; + return keys; + }, [filteredThreads, getThreadGitContext, nowMinute, serverConfigs]); + // The context-menu handler reads these through refs: depending on the live + // identities would hand every BoardCard a fresh callback prop on each + // git-status or shell event and defeat the cards' memoization. + const settledThreadKeysRef = useRef(settledThreadKeys); + settledThreadKeysRef.current = settledThreadKeys; + const serverConfigsRef = useRef(serverConfigs); + serverConfigsRef.current = serverConfigs; + + const threadLastVisitedAtById = useUiStateStore((state) => state.threadLastVisitedAtById); + const threadStatusLabelByKey = useMemo( + () => + new Map( + threads.map((thread) => { + const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)); + const threadStatusLabel = resolveThreadStatusPill({ + thread: { + ...thread, + lastVisitedAt: threadLastVisitedAtById[threadKey], + }, + })?.label; + return [threadKey, threadStatusLabel ?? null] as const; + }), + ), + [threadLastVisitedAtById, threads], + ); + const workingWorktreeKeys = useMemo(() => { + const keys = new Set(); + for (const thread of threads) { + const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)); + const statusLabel = threadStatusLabelByKey.get(threadKey); + if (statusLabel !== "Working" && statusLabel !== "Connecting") { + continue; + } + const cwd = resolveThreadGitCwd(thread); + if (cwd !== null) { + keys.add(boardGitKey(thread.environmentId, cwd)); + } + } + return keys; + }, [resolveThreadGitCwd, threadStatusLabelByKey, threads]); + const columns = useMemo( + () => + buildBoardColumns( + filteredThreads, + (thread) => { + const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)); + const lastVisitedAt = threadLastVisitedAtById[threadKey]; + const cwd = resolveThreadGitCwd(thread); + + return deriveBoardColumn({ + threadStatusLabel: threadStatusLabelByKey.get(threadKey) ?? null, + interactionMode: thread.interactionMode, + isSettled: settledThreadKeys.has(threadKey), + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + readySessionUpdatedAt: + thread.latestTurn === null && thread.session?.status === "ready" + ? thread.session.updatedAt + : null, + lastVisitedAt: lastVisitedAt ?? null, + threadBranch: thread.branch, + hasDedicatedWorktree: thread.worktreePath != null, + hasWorkingThreadForWorktree: + cwd !== null && workingWorktreeKeys.has(boardGitKey(thread.environmentId, cwd)), + gitStatus: getThreadGitContext(thread).gitStatus, + }); + }, + (thread) => + thread.session?.status === "running" && + thread.latestTurn?.turnId === thread.session.activeTurnId + ? (thread.latestTurn.startedAt ?? thread.latestTurn.requestedAt) + : null, + boardWorktreeKey, + ), + [ + filteredThreads, + getThreadGitContext, + resolveThreadGitCwd, + settledThreadKeys, + threadLastVisitedAtById, + threadStatusLabelByKey, + workingWorktreeKeys, + ], + ); + + // Settled tail renders in pages, mirroring SidebarV2: expansion resets when + // the project filter changes so a scope flip never inherits a deep page. + const [settledVisibleCount, setSettledVisibleCount] = useState(SETTLED_TAIL_INITIAL_COUNT); + const settledResetKey = storedProjectFilter ?? "all"; + const lastSettledResetKeyRef = useRef(settledResetKey); + if (lastSettledResetKeyRef.current !== settledResetKey) { + lastSettledResetKeyRef.current = settledResetKey; + setSettledVisibleCount(SETTLED_TAIL_INITIAL_COUNT); + } + const settledTail = useMemo( + () => sliceBoardSettledItems(columns.settled, settledVisibleCount), + [columns, settledVisibleCount], + ); + const showMoreSettled = useCallback( + () => setSettledVisibleCount((count) => count + SETTLED_TAIL_PAGE_COUNT), + [], + ); + + const dragClickGuard = useMemo(() => createBoardDragClickGuard(), []); + useEffect(() => () => dragClickGuard.dispose(), [dragClickGuard]); + const [activeDragId, setActiveDragId] = useState(null); + const [dropIntent, setDropIntent] = useState(null); + const activeThread = useMemo( + () => + activeDragId === null || parseBoardWorktreeGroupDragId(activeDragId) !== null + ? null + : (filteredThreads.find( + (thread) => + scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)) === activeDragId, + ) ?? null), + [activeDragId, filteredThreads], + ); + const activeWorktreeGroup = useMemo(() => { + const worktreeKey = parseBoardWorktreeGroupDragId(activeDragId); + if (worktreeKey === null) { + return null; + } + for (const columnId of BOARD_COLUMN_IDS) { + for (const item of columns[columnId]) { + if (item.kind === "worktreeGroup" && item.worktreeKey === worktreeKey) { + return item; + } + } + } + return null; + }, [activeDragId, columns]); + const activeDragIncludesSettledThread = useMemo(() => { + if (activeDragId === null) { + return false; + } + if (activeWorktreeGroup !== null) { + return activeWorktreeGroup.threads.some((thread) => + settledThreadKeys.has(scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id))), + ); + } + return settledThreadKeys.has(activeDragId); + }, [activeDragId, activeWorktreeGroup, settledThreadKeys]); + + // Touch drags require a long-press so swipe gestures keep scrolling the + // board; a distance-only constraint would claim every swipe as a drag. + const dndSensors = useSensors( + useSensor(MouseSensor, { activationConstraint: { distance: 6 } }), + useSensor(TouchSensor, { activationConstraint: { delay: 250, tolerance: 8 } }), + ); + + const handleDragStart = useCallback( + (event: DragStartEvent) => { + dragClickGuard.startDrag(); + setActiveDragId(String(event.active.id)); + }, + [dragClickGuard], + ); + + const handleDragOver = useCallback((event: DragOverEvent) => { + setDropIntent(resolveBoardDropIntent(event.over?.id)); + }, []); + + const handleDragCancel = useCallback(() => { + dragClickGuard.finishDrag(); + setActiveDragId(null); + setDropIntent(null); + }, [dragClickGuard]); + + const handleDragEnd = useCallback( + (event: DragEndEvent) => { + dragClickGuard.finishDrag(); + setActiveDragId(null); + setDropIntent(null); + const dragData = event.active.data.current as + | { + threadRef?: ScopedThreadRef; + worktreeGroupThreadRefs?: readonly ScopedThreadRef[]; + } + | undefined; + const threadRefs = + dragData?.worktreeGroupThreadRefs ?? (dragData?.threadRef ? [dragData.threadRef] : []); + if (threadRefs.length === 0) { + return; + } + const intent = resolveBoardDropIntent(event.over?.id); + if (intent === null) { + return; + } + + if (intent === "settle" || intent === "unsettle") { + // Dropping onto a state a card is already in is a no-op: the restore + // zone only shows for settled drags, and a group can hold a mix. + const wantSettled = intent === "settle"; + const refs = threadRefs.filter( + (threadRef) => settledThreadKeys.has(scopedThreadKey(threadRef)) !== wantSettled, + ); + if (refs.length === 0) { + return; + } + const action = wantSettled ? settleThread : unsettleThread; + const failureTitle = `Failed to ${wantSettled ? "settle" : "restore"} ${ + refs.length === 1 ? "thread" : "threads" + }`; + // Success is silent: the card moves when the shell update streams in. + void Promise.all(refs.map((threadRef) => action(threadRef))).then((results) => { + const failure = results.find( + (result) => result._tag === "Failure" && !isAtomCommandInterrupted(result), + ); + if (failure) { + reportThreadActionFailure(failure, failureTitle); + } + }); + return; + } + + if (intent === "trash") { + void confirmAndDeleteThreads(threadRefs).then((result) => { + reportThreadActionFailure( + result, + threadRefs.length === 1 ? "Failed to delete thread" : "Failed to delete threads", + ); + }); + return; + } + + void archiveSelectedThreadEntries({ + entries: threadRefs.map((threadRef) => ({ + threadKey: scopedThreadKey(threadRef), + threadRef, + })), + archive: ({ threadRef }, onArchived) => archiveThread(threadRef, { onArchived }), + }).then((outcome) => { + for (const failure of outcome.followupFailures) { + reportThreadActionFailure(failure, "Thread archived, but navigation failed"); + } + if (outcome.mutationFailure) { + reportThreadActionFailure( + outcome.mutationFailure, + threadRefs.length === 1 ? "Failed to archive thread" : "Failed to archive threads", + ); + } + }); + }, + [ + archiveThread, + confirmAndDeleteThreads, + dragClickGuard, + settledThreadKeys, + settleThread, + unsettleThread, + ], + ); + + const handleOpenThread = useCallback( + (threadRef: ScopedThreadRef) => { + void navigate({ + to: "/$environmentId/$threadId", + params: buildThreadRouteParams(threadRef), + }); + }, + [navigate], + ); + + const closeThreadRenameDialog = useCallback(() => { + setThreadRenameTarget(null); + setThreadRenameTitle(""); + }, []); + + const submitThreadRename = useCallback(async () => { + if (threadRenameTarget === null) { + return; + } + const committed = await renameThread( + scopeThreadRef(threadRenameTarget.environmentId, threadRenameTarget.id), + threadRenameTitle, + threadRenameTarget.title, + ); + if (committed) { + closeThreadRenameDialog(); + } + }, [closeThreadRenameDialog, renameThread, threadRenameTarget, threadRenameTitle]); + + const handleThreadContextMenu = useCallback( + async (thread: SidebarThreadSummary, position: { x: number; y: number }) => { + const api = readLocalApi(); + if (!api) { + return; + } + + const threadRef = scopeThreadRef(thread.environmentId, thread.id); + const threadKey = scopedThreadKey(threadRef); + const supportsSettlement = + serverConfigsRef.current.get(thread.environmentId)?.environment.capabilities + .threadSettlement === true; + const supportsSnooze = + serverConfigsRef.current.get(thread.environmentId)?.environment.capabilities + .threadSnooze === true; + const isSettled = settledThreadKeysRef.current.has(threadKey); + // Snooze classification uses a real clock (wake times are + // second-precise) and presets resolve at menu-open time — both same + // as the sidebar. + const preciseNow = new Date().toISOString(); + const isSnoozed = supportsSnooze && effectiveSnoozed(thread, { now: preciseNow }); + const snoozePresets = resolveSnoozePresets(new Date(), timestampFormat); + const clicked = await api.contextMenu.show( + buildSidebarV2ThreadContextMenuItems({ + branch: thread.branch, + supportsSettlement, + isSettled, + supportsSnooze, + isSnoozed, + canSnoozeNow: canSnooze(thread, { now: preciseNow }), + snoozePresets, + }), + position, + ); + + if (clicked?.startsWith("snooze:")) { + const preset = snoozePresets.find((candidate) => `snooze:${candidate.id}` === clicked); + if (!preset) { + return; + } + const result = await snoozeThread(threadRef, preset.snoozedUntil); + if (result._tag === "Failure") { + reportThreadActionFailure(result, "Failed to snooze thread"); + return; + } + // A snoozed card has no visible change on the board, so the toast is + // the only confirmation — and Undo the escape hatch for a mis-click. + toastManager.add( + stackedThreadToast({ + type: "success", + title: `Snoozed until ${snoozeWakeDescription(preset.snoozedUntil, new Date(), timestampFormat)}`, + timeout: 5_000, + actionProps: { + children: "Undo", + onClick: () => { + void unsnoozeThread(threadRef).then((undoResult) => { + reportThreadActionFailure(undoResult, "Failed to wake thread"); + }); + }, + }, + }), + ); + return; + } + if (clicked === "unsnooze") { + reportThreadActionFailure(await unsnoozeThread(threadRef), "Failed to wake thread"); + return; + } + if (clicked === "new-thread-on-branch") { + // Explicit branch carry-over: reuse the thread's worktree when it + // has one, otherwise its branch on the local checkout. + await handleNewThread(scopeProjectRef(thread.environmentId, thread.projectId), { + branch: thread.branch, + worktreePath: thread.worktreePath, + envMode: thread.worktreePath ? "worktree" : "local", + startFromOrigin: false, + }); + return; + } + if (clicked === "settle" || clicked === "unsettle") { + const result = + clicked === "settle" ? await settleThread(threadRef) : await unsettleThread(threadRef); + reportThreadActionFailure( + result, + clicked === "settle" ? "Failed to settle thread" : "Failed to un-settle thread", + threadRef.environmentId, + ); + return; + } + + if (clicked === "rename") { + setThreadRenameTarget(thread); + setThreadRenameTitle(thread.title); + return; + } + if (clicked === "mark-unread") { + markThreadUnread(threadKey, thread.latestTurn?.completedAt); + return; + } + if (clicked !== "delete") { + return; + } + + reportThreadActionFailure(await confirmAndDeleteThread(threadRef), "Failed to delete thread"); + }, + [ + confirmAndDeleteThread, + handleNewThread, + markThreadUnread, + settleThread, + snoozeThread, + unsettleThread, + unsnoozeThread, + ], + ); + + const showThreadContextMenu = useCallback( + (thread: SidebarThreadSummary, position: { x: number; y: number }) => { + void settlePromise(() => handleThreadContextMenu(thread, position)).then((result) => { + if (result._tag === "Success") { + return; + } + const error = squashAtomCommandFailure(result); + toastManager.add( + stackedThreadToast({ + type: "error", + title: "Thread action failed", + description: error instanceof Error ? error.message : "An error occurred.", + }), + ); + }); + }, + [handleThreadContextMenu], + ); + + const projectFilterItems = useMemo( + () => [ + { value: BOARD_PROJECT_FILTER_ALL, label: "All projects" }, + ...envFilteredProjectSnapshots.map((snapshot) => ({ + value: snapshot.projectKey, + label: snapshot.displayName, + })), + ], + [envFilteredProjectSnapshots], + ); + const selectedFilterValue = + storedProjectFilter !== null && + envFilteredProjectSnapshots.some((snapshot) => snapshot.projectKey === storedProjectFilter) + ? storedProjectFilter + : BOARD_PROJECT_FILTER_ALL; + const selectedFilterSnapshot = + selectedFilterValue === BOARD_PROJECT_FILTER_ALL + ? null + : (envFilteredProjectSnapshots.find( + (snapshot) => snapshot.projectKey === selectedFilterValue, + ) ?? null); + + return ( + <> + {/* .workspace-topbar pins the header to --workspace-topbar-height so the + floating sidebar toggle (absolutely positioned in that same band) + stays vertically aligned with the title at every breakpoint. */} +
    + Board +
    + + +
    +
    + +
    +
    +
    + {BOARD_COLUMN_IDS.map((columnId) => { + const items = columnId === "settled" ? settledTail.visibleItems : columns[columnId]; + return ( + + {items.map((item) => { + const renderCard = (thread: SidebarThreadSummary) => { + const gitContext = getThreadGitContext(thread); + const threadKey = scopedThreadKey( + scopeThreadRef(thread.environmentId, thread.id), + ); + return ( + + ); + }; + if (item.kind === "thread") { + return renderCard(item.thread); + } + // buildBoardColumns only emits groups with >= 2 members. + const mostRecentThread = item.threads[0]!; + return ( + + scopeThreadRef(thread.environmentId, thread.id), + )} + worktreePath={mostRecentThread.worktreePath ?? ""} + branch={mostRecentThread.branch} + mostRecentCard={renderCard(mostRecentThread)} + dragClickGuard={dragClickGuard} + > + {item.threads.slice(1).map(renderCard)} + + ); + })} + {columnId === "settled" && settledTail.hiddenThreadCount > 0 ? ( + + ) : null} + + ); + })} +
    +
    + {activeDragId !== null ? ( + + ) : null} +
    + + {activeWorktreeGroup !== null ? ( + + ) : activeThread !== null ? ( + + ) : null} + +     + { + if (!open) { + closeThreadRenameDialog(); + } + }} + > + + + Rename thread + Update the title shown for this thread. + + +
    + Thread title + setThreadRenameTitle(event.target.value)} + onKeyDown={(event) => { + if (event.key === "Enter") { + event.preventDefault(); + void submitThreadRename(); + } + }} + /> +
    +     + + + + +     +     + + ); +} diff --git a/apps/web/src/components/board/BoardWorktreeGroup.test.tsx b/apps/web/src/components/board/BoardWorktreeGroup.test.tsx new file mode 100644 index 000000000000..a1f5f1b67cf2 --- /dev/null +++ b/apps/web/src/components/board/BoardWorktreeGroup.test.tsx @@ -0,0 +1,100 @@ +import { DndContext } from "@dnd-kit/core"; +import { scopeThreadRef } from "@t3tools/client-runtime/environment"; +import { EnvironmentId, ThreadId } from "@t3tools/contracts"; +import type { ReactNode } from "react"; +import { renderToStaticMarkup } from "react-dom/server"; +import { describe, expect, it } from "vite-plus/test"; + +import type { BoardDragClickGuard } from "./BoardDragClickGuard"; +import { BoardWorktreeGroup, BoardWorktreeGroupDragOverlay } from "./BoardWorktreeGroup"; + +const environmentId = EnvironmentId.make("environment-local"); + +const noopDragClickGuard: BoardDragClickGuard = { + startDrag: () => {}, + finishDrag: () => {}, + consumeSuppressedClick: () => false, + dispose: () => {}, +}; + +function renderGroup({ + branch = "t3code/session-dashboard-board", + mostRecentCard =
    , + children =
    , +}: { + branch?: string | null; + mostRecentCard?: ReactNode; + children?: ReactNode; +} = {}): string { + return renderToStaticMarkup( + + + {children} + + , + ); +} + +describe("BoardWorktreeGroup", () => { + it("starts collapsed showing only the most recent card below the toggle", () => { + const markup = renderGroup(); + + expect(markup).toContain('aria-expanded="false"'); + expect(markup).toContain(' +
    + {mostRecentCard} + {expanded ? children : null} +
    + + ); +} + +/** Non-interactive header clone rendered inside the DragOverlay while dragging a group. */ +export function BoardWorktreeGroupDragOverlay({ + worktreePath, + branch, + threadCount, + dropIntent = null, +}: { + worktreePath: string; + branch: string | null; + threadCount: number; + dropIntent?: BoardDropIntent | null; +}) { + const displayLabel = resolveWorktreeGroupLabel(worktreePath, branch); + + return ( + + ); +} diff --git a/apps/web/src/components/board/useBoardVcsStatuses.ts b/apps/web/src/components/board/useBoardVcsStatuses.ts new file mode 100644 index 000000000000..23026da065d8 --- /dev/null +++ b/apps/web/src/components/board/useBoardVcsStatuses.ts @@ -0,0 +1,74 @@ +import { useAtomValue } from "@effect/atom-react"; +import type { EnvironmentId, VcsStatusResult } from "@t3tools/contracts"; +import * as Option from "effect/Option"; +import { AsyncResult, Atom } from "effect/unstable/reactivity"; +import { useMemo, useRef } from "react"; + +import { vcsEnvironment } from "../../state/vcs"; +import { boardGitKey } from "./Board.logic"; + +export interface BoardVcsTarget { + readonly environmentId: EnvironmentId; + readonly cwd: string; +} + +const EMPTY_STATUSES_ATOM = Atom.make( + (): ReadonlyMap => new Map(), +).pipe(Atom.withLabel("web:board-vcs-statuses:empty")); + +/** + * Aggregated list-mode VCS status for the board: shared budgeted remote refresh + * (PR/git stay fresh; no per-row poller). Dedupe by (environmentId, cwd). + */ +export function useBoardVcsStatuses( + targets: ReadonlyArray, +): ReadonlyMap { + // Thread-shell churn hands this hook a fresh input array on every update; + // dedupe into a sorted, identity-stable list so the derived atom below is + // only rebuilt when the (environmentId, cwd) set actually changes. + const previousTargetsRef = useRef>([]); + const dedupedTargets = useMemo(() => { + const byKey = new Map(); + for (const target of targets) { + byKey.set(boardGitKey(target.environmentId, target.cwd), target); + } + const next = [...byKey.entries()].sort(([left], [right]) => + left < right ? -1 : left > right ? 1 : 0, + ); + const previous = previousTargetsRef.current; + if ( + previous.length === next.length && + previous.every(([key], index) => key === next[index]![0]) + ) { + return previous; + } + previousTargetsRef.current = next; + return next; + }, [targets]); + + const statusesAtom = useMemo(() => { + if (dedupedTargets.length === 0) { + return EMPTY_STATUSES_ATOM; + } + return Atom.make( + (get): ReadonlyMap => + new Map( + dedupedTargets.map(([key, target]) => [ + key, + Option.getOrNull( + AsyncResult.value( + get( + vcsEnvironment.listStatus({ + environmentId: target.environmentId, + input: { cwd: target.cwd }, + }), + ), + ), + ), + ]), + ), + ).pipe(Atom.withLabel(`web:board-vcs-statuses:${dedupedTargets.length}`)); + }, [dedupedTargets]); + + return useAtomValue(statusesAtom); +} diff --git a/apps/web/src/components/chat/AiUsageStats.test.tsx b/apps/web/src/components/chat/AiUsageStats.test.tsx new file mode 100644 index 000000000000..52590ea3feeb --- /dev/null +++ b/apps/web/src/components/chat/AiUsageStats.test.tsx @@ -0,0 +1,55 @@ +import type { AiUsageProviderStatus } from "@t3tools/contracts"; +import { renderToStaticMarkup } from "react-dom/server"; +import { describe, expect, it } from "vite-plus/test"; + +import { AiUsageStats } from "./AiUsageStats"; + +/** + * The live `ai-usage` daemon shape for a claude/max plan: plenty of headroom on + * both plan windows, with the extra-usage credit buffer drained and switched + * off. The buffer is only drawn from once 5h/weekly run out, so it must render + * as neutral context — not as "Claude is out". + */ +const claudeWithDrainedExtras: AiUsageProviderStatus = { + provider: "claude", + ok: true, + plan: "max", + stale: true, + windows: [ + { id: "5h", label: "5-hour", percent: 18, resets_at: 1785874200 }, + { id: "weekly", label: "Weekly", percent: 78, resets_at: 1785895200 }, + { + id: "monthly", + label: "Extra usage (off)", + percent: 100, + used: 47.89, + limit: 45, + unit: "€", + resets_at: null, + }, + ], +}; + +const render = (item: AiUsageProviderStatus) => + renderToStaticMarkup(); + +describe("AiUsageStats", () => { + it("does not mark the provider out of limit for a drained extra-usage pool", () => { + const markup = render(claudeWithDrainedExtras); + expect(markup).toContain("Extra usage (off)"); + expect(markup).not.toContain("limit reached"); + expect(markup).not.toContain("bg-destructive"); + }); + + it("still reports a real maxed plan window", () => { + const markup = render({ + ...claudeWithDrainedExtras, + windows: [ + { id: "5h", label: "5-hour", percent: 100 }, + ...claudeWithDrainedExtras.windows.slice(1), + ], + }); + expect(markup).toContain("limit reached"); + expect(markup).toContain("bg-destructive"); + }); +}); diff --git a/apps/web/src/components/chat/AiUsageStats.tsx b/apps/web/src/components/chat/AiUsageStats.tsx new file mode 100644 index 000000000000..4d8e91c7d8d3 --- /dev/null +++ b/apps/web/src/components/chat/AiUsageStats.tsx @@ -0,0 +1,98 @@ +import type { AiUsageProviderStatus } from "@t3tools/contracts"; + +import { + formatPaceNote, + formatResetsIn, + formatWindowValue, + isEnforcedUsageWindow, + usageMarkerForItem, + usageProviderLabel, +} from "../../aiUsageState"; +import { cn } from "~/lib/utils"; + +function barColorClass(percent: number, enforced: boolean): string { + // Extra-usage / credit pools are context, not caps: a full one is neutral. + if (!enforced) return "bg-muted-foreground/40"; + if (percent >= 100) return "bg-destructive"; + if (percent >= 80) return "bg-warning"; + return "bg-muted-foreground/60"; +} + +/** + * Per-provider usage stats: one row per rolling window with its value, reset-in + * time and any pace warning. The default (tooltip) form shows a slim usage bar + * per window; the `compact` form drops the bars and the plain reset lines to + * stay small inside the model-picker menu so it never crowds out the list. + */ +export function AiUsageStats(props: { + item: AiUsageProviderStatus; + className?: string; + compact?: boolean; + nowMs?: number; +}) { + const { item, compact = false } = props; + const marker = usageMarkerForItem(item); + return ( +
    +
    + {usageProviderLabel(item.provider)} + {item.plan ? ( + + {item.plan} + + ) : null} +
    + {item.ok && item.windows.length > 0 ? ( +
    + {item.windows.map((window) => { + const resets = formatResetsIn(window.resets_at, props.nowMs ?? Date.now()); + const pace = formatPaceNote(window); + const enforced = isEnforcedUsageWindow(window); + // In compact mode only surface a sub-line when there's a pace + // warning worth acting on; plain reset times stay in the hover form. + const showSubLine = compact ? Boolean(pace) : Boolean(resets || pace); + return ( +
    +
    + {window.label} + + {formatWindowValue(window)} + +
    + {!compact && typeof window.percent === "number" ? ( +
    +
    +
    + ) : null} + {showSubLine ? ( +
    + {resets ? `resets in ${resets}` : null} + {resets && pace ? " · " : null} + {pace} +
    + ) : null} +
    + ); + })} +
    + ) : ( +
    {item.error ?? "usage unavailable"}
    + )} + {item.stale ? ( +
    stale — showing last known usage
    + ) : null} + {marker.fill === "critical" ? ( +
    limit reached
    + ) : marker.fill === "warn" ? ( +
    close to limit
    + ) : marker.outlookAtRisk ? ( +
    + usable now · weekly on track to overshoot +
    + ) : null} +
    + ); +} diff --git a/apps/web/src/components/chat/ChangedFilesTree.tsx b/apps/web/src/components/chat/ChangedFilesTree.tsx index 5ac9f09613f3..4e5c745d5a8c 100644 --- a/apps/web/src/components/chat/ChangedFilesTree.tsx +++ b/apps/web/src/components/chat/ChangedFilesTree.tsx @@ -27,6 +27,7 @@ export const ChangedFilesCard = memo(function ChangedFilesCard(props: { files: ReadonlyArray; allDirectoriesExpanded: boolean; resolvedTheme: "light" | "dark"; + className?: string; onToggleAllDirectories: () => void; onOpenTurnDiff: (turnId: TurnId, filePath?: string) => void; }) { @@ -35,6 +36,7 @@ export const ChangedFilesCard = memo(function ChangedFilesCard(props: { files, allDirectoriesExpanded, resolvedTheme, + className, onToggleAllDirectories, onOpenTurnDiff, } = props; @@ -43,7 +45,10 @@ export const ChangedFilesCard = memo(function ChangedFilesCard(props: { return (
    void; addDroppedFiles: (files: File[]) => void; insertTextAtEnd: (text: string, options?: { ensureLeadingBoundary?: boolean }) => boolean; + recallQueuedMessage: (text: string) => void; citeAssistantText: ( citation: AssistantCitation, sourceAnchor: AssistantCitationSourceAnchor, @@ -1356,6 +1372,7 @@ export interface ChatComposerProps { // Callbacks onCompactContext: () => void; onSend: (e?: { preventDefault: () => void }, intent?: ComposerSubmissionIntent) => void; + onStartNewThread: () => void; onInterrupt: () => void; onImplementPlanInNewThread: () => void; onRespondToApproval: ( @@ -1388,6 +1405,35 @@ export interface ChatComposerProps { onFileOpen: (attachment: ChatFileAttachment) => void; } +// -------------------------------------------------------------------------- +// Thread/draft-scoped submit history (survives ChatComposer remounts) +// -------------------------------------------------------------------------- + +const composerInputHistoryByTargetKey = new Map(); + +function composerInputHistoryKey(target: ScopedThreadRef | DraftId): string { + if (typeof target === "string") { + return `draft:${target.trim()}`; + } + return scopedThreadKey(target); +} + +function readComposerInputHistory(targetKey: string): ComposerInputHistoryState { + return composerInputHistoryByTargetKey.get(targetKey) ?? EMPTY_COMPOSER_INPUT_HISTORY; +} + +function writeComposerInputHistory(targetKey: string, history: ComposerInputHistoryState): void { + if ( + history.entries.length === 0 && + history.browsingIndex === null && + history.stashedDraft.length === 0 + ) { + composerInputHistoryByTargetKey.delete(targetKey); + return; + } + composerInputHistoryByTargetKey.set(targetKey, history); +} + // -------------------------------------------------------------------------- // Component // -------------------------------------------------------------------------- @@ -1463,6 +1509,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) onPageScrollRelease, onCompactContext, onSend, + onStartNewThread, onInterrupt, onImplementPlanInNewThread, onRespondToApproval, @@ -1691,6 +1738,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) // Instance-aware projection of the wire provider list. One entry per // configured instance (default built-in + any custom `providerInstances.*`), // sorted default-first per driver kind for a stable picker order. + const aiUsageSnapshot = useAiUsageSnapshot(environmentId); const providerInstanceEntries = useMemo>( () => sortProviderInstanceEntries( @@ -1923,6 +1971,10 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) // ------------------------------------------------------------------ // Composer-local state // ------------------------------------------------------------------ + const composerInputHistoryKeyForTarget = composerInputHistoryKey(composerDraftTarget); + const composerInputHistoryRef = useRef( + readComposerInputHistory(composerInputHistoryKeyForTarget), + ); const [composerCursor, setComposerCursor] = useState(() => collapseExpandedComposerCursor(prompt, prompt.length), ); @@ -2001,6 +2053,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) * the next draft. */ const pendingImageCompressionsRef = useRef>(new Map()); + const imageFileInputRef = useRef(null); // ------------------------------------------------------------------ // Derived: composer send state @@ -2063,6 +2116,13 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) } if (composerTrigger.kind === "slash-command") { const builtInSlashCommandItems = [ + { + id: "slash:new", + type: "slash-command", + command: "new", + label: "/new", + description: "Start a new thread in this worktree or directory", + }, { id: "slash:model", type: "slash-command", @@ -2303,14 +2363,17 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) ], ); const collapsedComposerPrimaryActionDisabled = - phase === "running" || - isSendBusy || isSendDisabled || - isConnecting || - noProviderAvailable || projectSelectionRequired || - environmentUnavailable !== null || - !composerSendState.hasSendableContent; + shouldDisableCollapsedComposerSubmitAction({ + isRunning: phase === "running", + isSendBusy, + isConnecting, + hasSendableContent: + !noProviderAvailable && + environmentUnavailable === null && + composerSendState.hasSendableContent, + }); const collapsedComposerPrimaryActionLabel = "Send message"; const showMobilePendingAnswerActions = isMobileViewport && !isComposerCollapsedMobile && pendingPrimaryAction !== null; @@ -2408,6 +2471,31 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) // ------------------------------------------------------------------ // Sync refs back to parent // ------------------------------------------------------------------ + // Prompt history is scoped per draft/thread. On switch: persist the previous + // target's history, restore any stashed draft if mid-browse, then load the next. + const previousComposerDraftTargetRef = useRef(composerDraftTarget); + const previousComposerInputHistoryKeyRef = useRef(composerInputHistoryKeyForTarget); + useLayoutEffect(() => { + const previousKey = previousComposerInputHistoryKeyRef.current; + const previousTarget = previousComposerDraftTargetRef.current; + if (previousKey === composerInputHistoryKeyForTarget) return; + + let previousHistory = composerInputHistoryRef.current; + if (previousHistory.browsingIndex !== null) { + setComposerDraftPrompt(previousTarget, previousHistory.stashedDraft); + previousHistory = { + entries: previousHistory.entries, + browsingIndex: null, + stashedDraft: "", + }; + } + writeComposerInputHistory(previousKey, previousHistory); + + previousComposerInputHistoryKeyRef.current = composerInputHistoryKeyForTarget; + previousComposerDraftTargetRef.current = composerDraftTarget; + composerInputHistoryRef.current = readComposerInputHistory(composerInputHistoryKeyForTarget); + }, [composerDraftTarget, composerInputHistoryKeyForTarget, setComposerDraftPrompt]); + useEffect(() => { promptRef.current = prompt; setComposerCursor((existing) => clampCollapsedComposerCursor(prompt, existing)); @@ -2879,6 +2967,17 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) return; } if (item.type === "slash-command") { + if (item.command === "new") { + const applied = applyPromptReplacement(trigger.rangeStart, trigger.rangeEnd, "", { + expectedText: snapshot.value.slice(trigger.rangeStart, trigger.rangeEnd), + focusEditorAfterReplace: false, + }); + if (applied) { + setComposerHighlightedItemId(null); + onStartNewThread(); + } + return; + } if (item.command === "model") { const applied = applyPromptReplacement(trigger.rangeStart, trigger.rangeEnd, "", { expectedText: snapshot.value.slice(trigger.rangeStart, trigger.rangeEnd), @@ -2951,6 +3050,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) [ applyPromptReplacement, handleInteractionModeChange, + onStartNewThread, planModeUiEnabled, onUsageLimitsCommand, resolveActiveComposerTrigger, @@ -3025,6 +3125,31 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) showPlanFollowUpPrompt, ]); + const applyComposerHistoryValue = useCallback( + (nextValue: string) => { + promptRef.current = nextValue; + setPrompt(nextValue); + const nextCursor = clampCollapsedComposerCursor(nextValue, nextValue.length); + setComposerCursor(nextCursor); + setComposerTrigger( + detectComposerTrigger(nextValue, expandCollapsedComposerCursor(nextValue, nextCursor)), + ); + setComposerHighlightedItemId(null); + queueMicrotask(() => { + composerEditorRef.current?.focusAt(nextCursor); + }); + }, + [promptRef, setPrompt], + ); + + const persistComposerInputHistory = useCallback( + (nextHistory: ComposerInputHistoryState) => { + composerInputHistoryRef.current = nextHistory; + writeComposerInputHistory(composerInputHistoryKeyForTarget, nextHistory); + }, + [composerInputHistoryKeyForTarget], + ); + const submitComposer = useCallback( (event?: { preventDefault: () => void }, intent: ComposerSubmissionIntent = "foreground") => { if (noProviderAvailable || isSendDisabled) { @@ -3047,6 +3172,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) }); return; } + const submitted = promptRef.current; const submission = submitComposerDraft({ prompt: promptRef.current, submissionTarget: activePendingProgress ? "pending-user-input" : "provider-turn", @@ -3061,6 +3187,13 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) }); setComposerSubmissionError(submission.validationMessage); if (!submission.didDispatch) return; + // Only a prompt that actually went out belongs in the input history; a + // rejected one stays in the composer for the user to fix. + if (submitted.trim().length > 0 && !activePendingProgress && !isComposerApprovalState) { + persistComposerInputHistory( + pushComposerInputHistory(composerInputHistoryRef.current, submitted), + ); + } if (shouldBlurMobileComposerOnSubmit()) { blurMobileComposerAfterSend(); } @@ -3070,9 +3203,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) activePendingProgress, attachmentTargetKey, blurMobileComposerAfterSend, + isComposerApprovalState, isSendDisabled, noProviderAvailable, onSend, + persistComposerInputHistory, promptRef, shouldBlurMobileComposerOnSubmit, ], @@ -4525,6 +4660,12 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) removeComposerImageFromDraft(imageId); }; + const onImageFileInputChange = (event: React.ChangeEvent) => { + const files = Array.from(event.target.files ?? []); + event.target.value = ""; + void addComposerAttachments(files); + }; + // ------------------------------------------------------------------ // Callbacks: paste / drag // ------------------------------------------------------------------ @@ -4746,6 +4887,15 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) focusComposer(); }, insertTextAtEnd: insertComposerTextAtEnd, + recallQueuedMessage: (text: string) => { + const history = recallComposerInputHistory( + composerInputHistoryRef.current, + text, + promptRef.current, + ); + persistComposerInputHistory(history); + applyComposerHistoryValue(text); + }, citeAssistantText: (citation, sourceAnchor) => insertComposerText( formatAssistantCitationForComposer(citation, citation.comment), @@ -4818,24 +4968,31 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) composerEditorRef.current?.focusAt(nextCollapsedCursor); }); }, - getSendContext: () => ({ - prompt: promptRef.current, - images: composerImagesRef.current, - files: composerFilesRef.current, - terminalContexts: composerTerminalContextsRef.current, - elementContexts: composerElementContextsRef.current, - previewAnnotations: composerPreviewAnnotations, - reviewComments: composerReviewComments, - selectedPromptEffort, - selectedModelOptionsForDispatch, - selectedModelSelection, - providerAvailable: !noProviderAvailable && providerSendBlockReason === null, - selectedProvider, - selectedModel, - selectedProviderModels, - interactionMode, - interactionModeEnabled: planModeUiEnabled, - }), + getSendContext: () => { + // Store writes from the native file picker are synchronous, while the + // effect that mirrors them into refs runs after React commits. Read the + // store at submit time so a quick tap after closing iOS' picker cannot + // send the previous attachment list. + const latestDraft = getComposerDraft(composerDraftTarget); + return { + prompt: promptRef.current, + images: latestDraft?.images ?? composerImagesRef.current, + files: latestDraft?.files ?? composerFilesRef.current, + terminalContexts: latestDraft?.terminalContexts ?? composerTerminalContextsRef.current, + elementContexts: latestDraft?.elementContexts ?? composerElementContextsRef.current, + previewAnnotations: latestDraft?.previewAnnotations ?? composerPreviewAnnotations, + reviewComments: latestDraft?.reviewComments ?? composerReviewComments, + selectedPromptEffort, + selectedModelOptionsForDispatch, + selectedModelSelection, + providerAvailable: !noProviderAvailable && providerSendBlockReason === null, + selectedProvider, + selectedModel, + selectedProviderModels, + interactionMode, + interactionModeEnabled: planModeUiEnabled, + }; + }, validateProviderInput: (providerInput: string) => { const validationMessage = getComposerSubmissionValidationMessage({ prompt: promptRef.current, @@ -4851,6 +5008,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) activeThread, addComposerAttachments, composerDraftTarget, + getComposerDraft, composerCursor, composerTerminalContexts, insertComposerDraftTerminalContext, @@ -4870,6 +5028,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) pendingUserInputs.length, projectSelectionRequired, applyPromptReplacement, + applyComposerHistoryValue, isComposerModelPickerOpen, openModelPicker, readComposerSnapshot, @@ -4877,6 +5036,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) selectedModelOptionsForDispatch, selectedModelSelection, noProviderAvailable, + persistComposerInputHistory, providerSendBlockReason, selectedPromptEffort, selectedProvider, @@ -4959,6 +5119,17 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) className="mx-auto w-full min-w-0 max-w-3xl" data-chat-composer-form="true" > + {/* Keep this above the collapsed/expanded mobile branches. Opening the + native iOS picker blurs and collapses the composer; remounting the + input before `change` arrives discards the selected files. */} + {composerControlsInStrip && restingControlsHost ? createPortal(
    { const primaryEnvironmentId = EnvironmentId.make("environment-primary"); @@ -62,6 +84,175 @@ describe("shouldShowOpenInPicker", () => { }); }); +describe("shouldOfferRemoteVscodeOpen", () => { + it("offers remote open for a named project when the local picker is hidden", () => { + expect( + shouldOfferRemoteVscodeOpen({ + activeProjectName: "codething-mvp", + showOpenInPicker: false, + }), + ).toBe(true); + }); + + it("never offers remote open when the local OpenInPicker is shown", () => { + expect( + shouldOfferRemoteVscodeOpen({ + activeProjectName: "codething-mvp", + showOpenInPicker: true, + }), + ).toBe(false); + }); + + it("never offers remote open without an active project", () => { + expect( + shouldOfferRemoteVscodeOpen({ + activeProjectName: undefined, + showOpenInPicker: false, + }), + ).toBe(false); + }); +}); + +describe("resolveRemoteVscodeOpenTarget", () => { + const environmentId = EnvironmentId.make("environment-remote"); + + it("uses the environment label instead of a paired HTTP gateway", () => { + const entry: ConnectionCatalogEntry = { + target: new BearerConnectionTarget({ + environmentId, + label: "remote-vm", + connectionId: "bearer:remote-vm", + }), + profile: Option.some( + new BearerConnectionProfile({ + connectionId: "bearer:remote-vm", + environmentId, + label: "remote-vm", + httpBaseUrl: "http://gateway.example.test:8080/", + wsBaseUrl: "ws://gateway.example.test:8080/", + }), + ), + }; + + expect( + resolveRemoteVscodeOpenTarget({ + entry, + cwd: "/home/tester/projects/example", + }), + ).toEqual({ + authority: "remote-vm", + uri: "vscode://vscode-remote/ssh-remote+remote-vm/home/tester/projects/example?windowId=_blank", + }); + }); + + it("uses the stored SSH profile user and host when present", () => { + const entry: ConnectionCatalogEntry = { + target: new SshConnectionTarget({ + environmentId, + label: "remote-host", + connectionId: "ssh:remote-host", + }), + profile: Option.some( + new SshConnectionProfile({ + connectionId: "ssh:remote-host", + environmentId, + label: "remote-host", + target: { + alias: "remote-host", + hostname: "remote.example.test", + username: "tester", + port: null, + }, + }), + ), + }; + + expect( + resolveRemoteVscodeOpenTarget({ + entry, + cwd: "/home/tester/project with spaces", + }), + ).toEqual({ + authority: "tester@remote.example.test", + uri: "vscode://vscode-remote/ssh-remote+tester%40remote.example.test/home/tester/project%20with%20spaces?windowId=_blank", + }); + }); + + it("returns null for non-absolute cwd, missing entry, or empty hostname", () => { + expect( + resolveRemoteVscodeOpenTarget({ + entry: null, + cwd: "/home/tester/projects/example", + }), + ).toBeNull(); + expect( + resolveRemoteVscodeOpenTarget({ + entry: { + target: new BearerConnectionTarget({ + environmentId, + label: "remote-vm", + connectionId: "bearer:remote-vm", + }), + profile: Option.none(), + }, + cwd: "/home/tester/projects/example", + }), + ).toBeNull(); + expect( + resolveRemoteVscodeOpenTarget({ + entry: { + target: new BearerConnectionTarget({ + environmentId, + label: "remote-vm", + connectionId: "bearer:remote-vm", + }), + profile: Option.some( + new BearerConnectionProfile({ + connectionId: "bearer:remote-vm", + environmentId, + label: "remote-vm", + httpBaseUrl: "http://gateway.example.test:8080/", + wsBaseUrl: "ws://gateway.example.test:8080/", + }), + ), + }, + cwd: "relative/path", + }), + ).toBeNull(); + }); +}); + +describe("ChatHeader remote Open in VS Code surface (anti stack-drop)", () => { + it("still wires the remote control through the pure gate into header JSX", () => { + // Pure helpers alone are not enough: #154 proved stack recovery can keep + // resolveRemoteVscodeOpenTarget while deleting the button. These markers + // must remain co-located in ChatHeader.tsx. + expect(chatHeaderSource).toContain("shouldOfferRemoteVscodeOpen"); + expect(chatHeaderSource).toContain("resolveRemoteVscodeOpenTarget"); + expect(chatHeaderSource).toContain("remoteVscodeTarget"); + expect(chatHeaderSource).toContain("Open in VS Code Remote SSH on"); + expect(chatHeaderSource).toContain("Open VS Code Remote SSH:"); + expect(chatHeaderSource).toContain("shell.openExternal"); + expect(chatHeaderSource).toContain("VisualStudioCode"); + }); +}); + +describe("ChatHeader AI usage + host resources surface (anti stack-drop)", () => { + it("still wires conversation-level usage status and host resource gauges", () => { + // Stack product rejoins have previously re-landed pure helpers + settings + // HostResourceStatus while dropping the thread-header surfaces. Keep the + // JSX markers co-located with the pure gates so that cannot pass silently. + expect(chatHeaderSource).toContain("useAiUsageSnapshot"); + expect(chatHeaderSource).toContain("resolveDriverUsage"); + expect(chatHeaderSource).toContain('aria-label="provider usage status"'); + expect(chatHeaderSource).toContain("AiUsageStats"); + expect(chatHeaderSource).toContain("HostResourceStatus"); + expect(chatHeaderSource).toContain("isLocalConnectionTarget"); + expect(chatHeaderSource).toContain("activeThreadDriverKind"); + expect(chatHeaderSource).toContain("activeThreadModel"); + }); +}); + describe("resolveRenameCommit", () => { it("commits a trimmed changed title", () => { expect(resolveRenameCommit({ title: " New title ", originalTitle: "Old" })).toEqual({ diff --git a/apps/web/src/components/chat/ChatHeader.tsx b/apps/web/src/components/chat/ChatHeader.tsx index fbebc323a950..7894e00b922e 100644 --- a/apps/web/src/components/chat/ChatHeader.tsx +++ b/apps/web/src/components/chat/ChatHeader.tsx @@ -2,11 +2,14 @@ import { type EnvironmentId, type EditorId, type ProjectScript, + type ProviderDriverKind, type ResolvedKeybindingsConfig, type ThreadId, } from "@t3tools/contracts"; import { scopeThreadRef } from "@t3tools/client-runtime/environment"; +import type { ConnectionCatalogEntry } from "@t3tools/client-runtime/connection"; import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; +import * as Option from "effect/Option"; import { isAtomCommandInterrupted, squashAtomCommandFailure, @@ -27,13 +30,14 @@ import { isTrailingDoubleClick } from "../Sidebar.logic"; import { type DraftId } from "~/composerDraftStore"; import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; import { toastManager } from "../ui/toast"; +import { AiUsageStats } from "./AiUsageStats"; import ProjectScriptsControl, { type NewProjectScriptInput, type ProjectScriptActionResult, } from "../ProjectScriptsControl"; import { OpenInPicker } from "./OpenInPicker"; import { useRemoteOpenState, type RemoteOpenMode } from "../../remoteOpen"; -import { usePrimaryEnvironmentId } from "../../state/environments"; +import { useEnvironment, usePrimaryEnvironmentId } from "../../state/environments"; import { useT3ProjectFileScripts } from "~/hooks/useT3ProjectFileScripts"; import { useThreadActionMenu } from "~/hooks/useThreadActionMenu"; import { readLocalApi } from "~/localApi"; @@ -47,6 +51,12 @@ import { WorkspaceBreadcrumbSeparator, } from "../WorkspaceBreadcrumb"; import { cn } from "~/lib/utils"; +import { Button } from "../ui/button"; +import { VisualStudioCode } from "../Icons"; +import { useAiUsageSnapshot } from "../../hooks/useAiUsageSnapshot"; +import { resolveDriverUsage, usageDotFillClass, usageDotRingColor } from "../../aiUsageState"; +import { HostResourceStatus } from "../HostResourceStatus"; +import { isLocalConnectionTarget } from "~/connection/desktopLocal"; interface ChatHeaderProps { activeThreadEnvironmentId: EnvironmentId; @@ -63,7 +73,11 @@ interface ChatHeaderProps { availableEditors: ReadonlyArray; rightPanelOpen: boolean; gitCwd: string | null; - readonly onOpenPullRequest?: ((number: number) => void) | undefined; + isPreparingWorktree?: boolean; + /** For showing usage dot on the active thread's model at conversation level. */ + activeThreadDriverKind?: ProviderDriverKind | null; + activeThreadModel?: string | null; + readonly onOpenPullRequest?: ((number: number, repository?: string | null) => void) | undefined; onNewThreadInProject: () => void; onOpenProjectSettings?: (() => void) | undefined; onRunProjectScript: (script: ProjectScript) => void; @@ -118,6 +132,61 @@ export function shouldShowOpenInPicker(input: { return input.remoteOpenMode !== "local-exec"; } +/** + * Remote Open-in-VS-Code is mutually exclusive with the local OpenInPicker: + * only offer it for a named project when the local picker is hidden (non-primary + * environments). Pure gate so stack recovery cannot keep the URI helper while + * dropping the product surface without a failing unit test. + */ +export function shouldOfferRemoteVscodeOpen(input: { + readonly activeProjectName: string | undefined; + readonly showOpenInPicker: boolean; +}): boolean { + return Boolean(input.activeProjectName) && !input.showOpenInPicker; +} + +function encodeRemotePath(path: string): string { + return path.split("/").map(encodeURIComponent).join("/"); +} + +export function resolveRemoteVscodeOpenTarget(input: { + readonly entry: ConnectionCatalogEntry | null; + readonly cwd: string | null; +}): { readonly authority: string; readonly uri: string } | null { + if (!input.cwd || !input.cwd.startsWith("/")) return null; + const entry = input.entry; + if (!entry) return null; + + let hostname: string | null = null; + let username: string | null = null; + + if ( + entry.target._tag === "SshConnectionTarget" && + Option.isSome(entry.profile) && + entry.profile.value._tag === "SshConnectionProfile" + ) { + hostname = entry.profile.value.target.hostname; + username = entry.profile.value.target.username ?? username; + } else if ( + entry.target._tag === "BearerConnectionTarget" && + Option.isSome(entry.profile) && + entry.profile.value._tag === "BearerConnectionProfile" + ) { + // The HTTP endpoint may be a gateway on a different machine. Remote-SSH must target + // the environment itself, not the transport endpoint used to reach its T3 server. + hostname = entry.profile.value.label.trim() || entry.target.label.trim() || null; + } + + if (!hostname) return null; + const authority = username ? `${username}@${hostname}` : hostname; + // `windowId=_blank` focuses the window that already has this remote folder open, otherwise opens a + // new one — instead of replacing whatever window is currently focused. + const uri = `vscode://vscode-remote/ssh-remote+${encodeURIComponent(authority)}${encodeRemotePath( + input.cwd, + )}?windowId=_blank`; + return { authority, uri }; +} + export const ChatHeader = memo(function ChatHeader({ activeThreadEnvironmentId, activeThreadId, @@ -132,6 +201,9 @@ export const ChatHeader = memo(function ChatHeader({ availableEditors, rightPanelOpen, gitCwd, + isPreparingWorktree = false, + activeThreadDriverKind = null, + activeThreadModel = null, onOpenPullRequest, onNewThreadInProject, onOpenProjectSettings, @@ -156,6 +228,7 @@ export const ChatHeader = memo(function ChatHeader({ }); }, [panelAnimationDurationMs, panelAnimationsActive]); const primaryEnvironmentId = usePrimaryEnvironmentId(); + const activeEnvironment = useEnvironment(activeThreadEnvironmentId); const activeProjectName = activeProject?.title; const activeProjectCwd = activeProject?.workspaceRoot ?? null; const fileScripts = useT3ProjectFileScripts( @@ -169,6 +242,29 @@ export const ChatHeader = memo(function ChatHeader({ primaryEnvironmentId, remoteOpenMode: remoteOpenState.mode, }); + const remoteVscodeTarget = useMemo( + () => + shouldOfferRemoteVscodeOpen({ activeProjectName, showOpenInPicker }) + ? resolveRemoteVscodeOpenTarget({ + entry: activeEnvironment?.entry ?? null, + cwd: openInCwd, + }) + : null, + [activeEnvironment?.entry, activeProjectName, openInCwd, showOpenInPicker], + ); + const openRemoteVscode = useCallback(() => { + if (!remoteVscodeTarget) return; + void readLocalApi()?.shell.openExternal(remoteVscodeTarget.uri); + }, [remoteVscodeTarget]); + + const aiUsageSnapshot = useAiUsageSnapshot(activeThreadEnvironmentId); + const headerUsage = useMemo( + () => resolveDriverUsage(aiUsageSnapshot, activeThreadDriverKind, activeThreadModel), + [aiUsageSnapshot, activeThreadDriverKind, activeThreadModel], + ); + const headerDotClass = headerUsage ? usageDotFillClass(headerUsage.marker) : undefined; + const headerRingColor = headerUsage ? usageDotRingColor(headerUsage.marker) : undefined; + const activeThreadRef = useMemo( () => scopeThreadRef(activeThreadEnvironmentId, activeThreadId), [activeThreadEnvironmentId, activeThreadId], @@ -400,6 +496,45 @@ export const ChatHeader = memo(function ChatHeader({ )} + {headerDotClass && headerUsage ? ( + + + } + /> + + + + + ) : headerDotClass ? ( + + ) : null} +
    )} + {remoteVscodeTarget && ( + + + + )} {activeProjectName && ( diff --git a/apps/web/src/components/chat/ComposerBannerStack.tsx b/apps/web/src/components/chat/ComposerBannerStack.tsx index c540613b009c..e79a6e246ab8 100644 --- a/apps/web/src/components/chat/ComposerBannerStack.tsx +++ b/apps/web/src/components/chat/ComposerBannerStack.tsx @@ -2,6 +2,7 @@ import { InfoIcon } from "lucide-react"; import { useEffect, useId, useLayoutEffect, useRef, useState, type ReactNode } from "react"; import { cn } from "~/lib/utils"; +import { ErrorDetailText } from "../ui/errorDetailText"; import { Button } from "../ui/button"; import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover"; import { ComposerBanner, type ComposerBannerVariant } from "./ComposerBanner"; @@ -286,7 +287,11 @@ function ComposerBannerStackAlert({ {item.description ? ( <> - {item.description} + {item.variant === "error" && typeof item.description === "string" ? ( + + ) : ( + item.description + )} - {item.description} + {item.variant === "error" && typeof item.description === "string" ? ( + + ) : ( + item.description + )} diff --git a/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx b/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx index 45ef93568cf6..79b733ac074a 100644 --- a/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx +++ b/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx @@ -7,6 +7,29 @@ const stageArtworkState = vi.hoisted(() => ({ variant: null as "nightly" | "dev" | null, })); +describe("shouldDisableCollapsedComposerSubmitAction", () => { + it("keeps the collapsed mobile submit button disabled while a turn is running", () => { + expect( + shouldDisableCollapsedComposerSubmitAction({ + isRunning: true, + isSendBusy: false, + isConnecting: false, + hasSendableContent: true, + }), + ).toBe(true); + }); + + it("enables the collapsed mobile submit button once the thread is idle", () => { + expect( + shouldDisableCollapsedComposerSubmitAction({ + isRunning: false, + isSendBusy: false, + isConnecting: false, + hasSendableContent: true, + }), + ).toBe(false); + }); +}); vi.mock("~/hooks/useSettings", () => ({ useEnvironmentIdentificationMode: () => stageArtworkState.mode, })); @@ -15,7 +38,10 @@ vi.mock("../SidebarStageBackdrop", () => ({ useSidebarStageBackdropVariant: (enabled = true) => (enabled ? stageArtworkState.variant : null), })); -import { ComposerPrimaryActions } from "./ComposerPrimaryActions"; +import { + ComposerPrimaryActions, + shouldDisableCollapsedComposerSubmitAction, +} from "./ComposerPrimaryActions"; function renderPendingActions(isRunning: boolean) { return renderToStaticMarkup( diff --git a/apps/web/src/components/chat/ComposerPrimaryActions.tsx b/apps/web/src/components/chat/ComposerPrimaryActions.tsx index 91c54b75ed03..fe63450caf01 100644 --- a/apps/web/src/components/chat/ComposerPrimaryActions.tsx +++ b/apps/web/src/components/chat/ComposerPrimaryActions.tsx @@ -37,6 +37,14 @@ interface ComposerPrimaryActionsProps { onImplementPlanInNewThread: () => void; } +export const shouldDisableCollapsedComposerSubmitAction = (input: { + isRunning: boolean; + isSendBusy: boolean; + isConnecting: boolean; + hasSendableContent: boolean; +}): boolean => + input.isRunning || input.isSendBusy || input.isConnecting || !input.hasSendableContent; + const formatPendingPrimaryActionLabel = (input: { compact: boolean; isLastQuestion: boolean; diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts index 0c5e53261b4f..a3ab26b3f370 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts @@ -18,10 +18,16 @@ import { import * as Option from "effect/Option"; import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity"; import { + clearSteerTimelineBoundaryStore, + observeSteerTextBoundary, +} from "@t3tools/shared/steerTimeline"; +import { + collapseConsecutiveDuplicateAssistantEntries, computeStableMessagesTimelineRows, computeMessageDurationStart, deriveMessagesTimelineRows, deriveMessagesTimelineRowsWithState, + interleaveTimelineEntriesForSteeredTurn, liveWorkEntryLabel, normalizeCompactToolLabel, resolveAssistantMessageCopyState, @@ -36,6 +42,7 @@ import { createMessageAttachmentPreviewProjector, deriveTimelineEntries, deriveTimelineEntriesWithState, + type TimelineEntry, type WorkLogEntry, type TimelineEntriesProjection, } from "../../session-logic"; @@ -409,6 +416,8 @@ describe("streaming row projection", () => { ], proposedPlans: [], activities: [], + queuedMessages: [], + pendingTurnStart: null, checkpoints: history.map(({ checkpoint }) => checkpoint), session: null, }; @@ -805,6 +814,29 @@ describe("work entry labels", () => { }); }, ); + + it("gives a completed browser group its own count and summary icon category", () => { + const rows = deriveMessagesTimelineRows({ + timelineEntries: [ + { + id: "browser-entry", + kind: "work", + createdAt: entry.createdAt, + entry: { + ...entry, + itemType: "mcp_tool_call", + toolLifecycleStatus: "completed", + toolData: { server: "t3-code", tool: "preview_click" }, + }, + }, + ], + isWorking: false, + activeTurnStartedAt: null, + turnDiffSummaries: [], + supportsConversationRollback: false, + }); + expect(rows).toMatchObject([{ kind: "work" }]); + }); }); describe("shouldPreserveAssistantLineBreaks", () => { @@ -1121,6 +1153,69 @@ describe("deriveMessagesTimelineRows", () => { ]); }); + it("summarizes a tool run after commentary starts a new run", () => { + const rows = deriveMessagesTimelineRows({ + timelineEntries: [ + { + id: "completed-command-entry", + kind: "work", + createdAt: "2026-01-01T00:00:05Z", + entry: { + id: "completed-command", + createdAt: "2026-01-01T00:00:05Z", + turnId: "turn-1" as never, + label: "Ran rg", + command: "rg toolCall", + requestKind: "command", + tone: "tool" as const, + toolLifecycleStatus: "completed" as const, + }, + }, + { + id: "assistant-commentary-entry", + kind: "message", + createdAt: "2026-01-01T00:00:06Z", + message: { + id: "assistant-commentary" as never, + role: "assistant", + text: "Checking another thing.", + turnId: "turn-1" as never, + createdAt: "2026-01-01T00:00:06Z", + updatedAt: "2026-01-01T00:00:06Z", + streaming: false, + }, + }, + { + id: "running-command-entry", + kind: "work", + createdAt: "2026-01-01T00:00:07Z", + entry: { + id: "running-command", + createdAt: "2026-01-01T00:00:07Z", + turnId: "turn-1" as never, + label: "Running tests", + command: "vp test run", + requestKind: "command", + tone: "tool" as const, + toolLifecycleStatus: "inProgress" as const, + }, + }, + ], + latestTurn: { + turnId: "turn-1" as never, + state: "running", + startedAt: "2026-01-01T00:00:00Z", + completedAt: null, + }, + isWorking: true, + activeTurnStartedAt: "2026-01-01T00:00:00Z", + turnDiffSummaries: [], + supportsConversationRollback: false, + }); + + expect(rows.map((row) => row.kind)).toEqual(["working", "work", "message", "work-live"]); + }); + it("only enables assistant copy for the terminal assistant message in a turn", () => { const rows = deriveMessagesTimelineRows({ timelineEntries: [ @@ -1358,6 +1453,15 @@ describe("deriveMessagesTimelineRows", () => { const collapsedRows = deriveMessagesTimelineRows({ timelineEntries, + latestTurn: { + turnId: "turn-1" as never, + state: "completed", + startedAt: "2026-01-01T00:00:00Z", + completedAt: "2026-01-01T00:00:22Z", + // The projection can retain the first commentary message here. The + // later assistant message must remain visible as the actual final. + assistantMessageId: "assistant-thought" as never, + }, isWorking: false, activeTurnStartedAt: null, turnDiffSummaries: [], @@ -1399,6 +1503,115 @@ describe("deriveMessagesTimelineRows", () => { ).toBeDefined(); }); + it("keeps a queue-drain final below the fold when the message turnId was flipped", () => { + const rows = deriveMessagesTimelineRows({ + timelineEntries: [ + { + id: "user-1", + kind: "message", + createdAt: "2026-01-01T00:00:00Z", + message: { + id: "user-1" as never, + role: "user" as const, + text: "Change the icons.", + turnId: null, + createdAt: "2026-01-01T00:00:00Z", + updatedAt: "2026-01-01T00:00:00Z", + streaming: false, + }, + }, + { + id: "assistant-status", + kind: "message", + createdAt: "2026-01-01T00:00:05Z", + message: { + id: "assistant-status" as never, + role: "assistant" as const, + text: "Replacing the segment bar…", + turnId: "turn-1" as never, + createdAt: "2026-01-01T00:00:05Z", + updatedAt: "2026-01-01T00:00:05Z", + streaming: false, + }, + }, + { + id: "work-1", + kind: "work", + createdAt: "2026-01-01T00:00:10Z", + entry: { + id: "work-1", + createdAt: "2026-01-01T00:00:10Z", + turnId: "turn-1" as never, + label: "Changed files", + tone: "tool" as const, + }, + }, + { + id: "assistant-final-misstamped", + kind: "message", + createdAt: "2026-01-01T00:00:20Z", + message: { + id: "assistant-final-misstamped" as never, + role: "assistant" as const, + text: "Done. No more segment bar.", + turnId: "turn-2" as never, + createdAt: "2026-01-01T00:00:20Z", + updatedAt: "2026-01-01T00:00:20Z", + streaming: false, + }, + }, + { + id: "user-2", + kind: "message", + createdAt: "2026-01-01T00:00:20Z", + message: { + id: "user-2" as never, + role: "user" as const, + text: "About the queue?", + turnId: null, + createdAt: "2026-01-01T00:00:20Z", + updatedAt: "2026-01-01T00:00:20Z", + streaming: false, + }, + }, + { + id: "assistant-next", + kind: "message", + createdAt: "2026-01-01T00:00:28Z", + message: { + id: "assistant-next" as never, + role: "assistant" as const, + text: "Queue is chips now.", + turnId: "turn-2" as never, + createdAt: "2026-01-01T00:00:28Z", + updatedAt: "2026-01-01T00:00:30Z", + streaming: false, + }, + }, + ], + isWorking: false, + activeTurnStartedAt: null, + turnDiffSummaries: [], + supportsConversationRollback: false, + latestTurn: { + turnId: "turn-2" as never, + state: "completed", + startedAt: "2026-01-01T00:00:20Z", + completedAt: "2026-01-01T00:00:30Z", + assistantMessageId: "assistant-next" as never, + }, + }); + + const ids = rows.map((row) => row.id); + expect(ids).toContain("turn-fold:turn-1"); + expect(ids).toContain("assistant-final-misstamped"); + expect(ids.indexOf("assistant-final-misstamped")).toBeGreaterThan( + ids.indexOf("turn-fold:turn-1"), + ); + expect(ids).not.toContain("assistant-status"); + expect(ids).not.toContain("work-1"); + }); + it("keeps a tool group after the terminal response visible when the turn is folded", () => { const turnId = TurnId.make("turn-1"); const timelineEntries = [ @@ -1898,7 +2111,7 @@ describe("deriveMessagesTimelineRows", () => { expect(rows.some((row) => row.kind === "turn-fold")).toBe(false); expect(rows.filter((row) => row.id === "working-indicator-row")).toHaveLength(1); - expect(rows.findIndex((row) => row.id === "working-indicator-row")).toBeLessThan( + expect(rows.findIndex((row) => row.id === "working-indicator-row")).toBeGreaterThan( rows.findIndex((row) => row.id === "old-work-entry"), ); expect(rows.find((row) => row.id === "working-indicator-row")).toMatchObject({ @@ -2622,6 +2835,301 @@ describe("deriveMessagesTimelineRows", () => { }); }); + it("keeps a clarifying-question exchange out of the collapsed work group", () => { + const userInput = { + requestId: "req-1", + answered: true, + questions: [ + { + id: "Approach?", + header: "Approach", + question: "Approach?", + multiSelect: false, + options: [{ label: "Ship it", description: "Merge as-is" }], + selectedLabels: ["Ship it"], + }, + ], + }; + const rows = deriveMessagesTimelineRows({ + timelineEntries: [ + { + id: "work-entry-1", + kind: "work" as const, + createdAt: "2026-01-01T00:00:01Z", + entry: { + id: "work-1", + createdAt: "2026-01-01T00:00:01Z", + label: "read", + tone: "tool" as const, + }, + }, + { + id: "user-input-entry", + kind: "work" as const, + createdAt: "2026-01-01T00:00:02Z", + entry: { + id: "user-input-1", + createdAt: "2026-01-01T00:00:02Z", + label: "Question: Approach", + tone: "info" as const, + userInput, + }, + }, + { + id: "work-entry-2", + kind: "work" as const, + createdAt: "2026-01-01T00:00:03Z", + entry: { + id: "work-2", + createdAt: "2026-01-01T00:00:03Z", + label: "edit", + tone: "tool" as const, + }, + }, + ], + isWorking: false, + activeTurnStartedAt: null, + turnDiffSummaries: [], + supportsConversationRollback: false, + }); + + expect(rows.map((row) => row.id)).toEqual(["work-entry-1", "user-input-entry", "work-entry-2"]); + expect(rows.find((row) => row.kind === "user-input")).toMatchObject({ userInput }); + }); + + it("keeps a clarifying-question exchange visible after its turn folds", () => { + const rows = deriveMessagesTimelineRows({ + timelineEntries: [ + { + id: "user-entry", + kind: "message" as const, + createdAt: "2026-01-01T00:00:00Z", + message: { + id: "user-1" as never, + role: "user" as const, + text: "ship the fix", + turnId: null, + createdAt: "2026-01-01T00:00:00Z", + updatedAt: "2026-01-01T00:00:00Z", + streaming: false, + }, + }, + { + id: "work-entry-1", + kind: "work" as const, + createdAt: "2026-01-01T00:00:05Z", + entry: { + id: "work-1", + createdAt: "2026-01-01T00:00:05Z", + turnId: "turn-1" as never, + label: "Ran command", + tone: "tool" as const, + }, + }, + { + id: "user-input-entry", + kind: "work" as const, + createdAt: "2026-01-01T00:00:08Z", + entry: { + id: "user-input-1", + createdAt: "2026-01-01T00:00:08Z", + turnId: "turn-1" as never, + label: "Question: Approach", + tone: "info" as const, + userInput: { + requestId: "req-1", + answered: true, + questions: [ + { + id: "Approach?", + header: "Approach", + question: "Approach?", + multiSelect: false, + options: [{ label: "Ship it", description: "Merge as-is" }], + selectedLabels: ["Ship it"], + }, + ], + }, + }, + }, + { + id: "assistant-final-entry", + kind: "message" as const, + createdAt: "2026-01-01T00:00:20Z", + message: { + id: "assistant-final" as never, + role: "assistant" as const, + text: "Shipped", + turnId: "turn-1" as never, + createdAt: "2026-01-01T00:00:20Z", + updatedAt: "2026-01-01T00:00:22Z", + streaming: false, + }, + }, + ], + isWorking: false, + activeTurnStartedAt: null, + turnDiffSummaries: [], + supportsConversationRollback: false, + }); + + expect(rows.map((row) => row.id)).toEqual([ + "user-entry", + "turn-fold:turn-1", + "user-input-entry", + "assistant-final-entry", + ]); + }); + + it("interleaves steer user messages between pre-steer and post-steer turn output", () => { + clearSteerTimelineBoundaryStore(); + const boundaryStore = new Map(); + // Observe the assistant text as it existed when the steer arrived. + // Production timeline entry ids match message ids (see deriveTimelineEntries). + observeSteerTextBoundary( + "active-assistant", + "steer-user", + "Tracing timeline ordering.".length, + boundaryStore, + ); + + const timelineEntries = [ + { + id: "settled-summary", + kind: "message" as const, + createdAt: "2026-01-01T00:00:30Z", + message: { + id: "settled-summary" as never, + role: "assistant" as const, + text: "Submit latch fix summary.", + turnId: "turn-0" as never, + createdAt: "2026-01-01T00:00:30Z", + updatedAt: "2026-01-01T00:00:40Z", + streaming: false, + }, + }, + { + id: "turn-start-user", + kind: "message" as const, + createdAt: "2026-01-01T00:01:00Z", + message: { + id: "turn-start-user" as never, + role: "user" as const, + text: "run my build/deploy script", + turnId: null, + createdAt: "2026-01-01T00:01:00Z", + updatedAt: "2026-01-01T00:01:00Z", + streaming: false, + }, + }, + { + id: "active-assistant", + kind: "message" as const, + createdAt: "2026-01-01T00:01:05Z", + message: { + id: "active-assistant" as never, + role: "assistant" as const, + text: "Tracing timeline ordering. Comparing solutions after the steer.", + turnId: "turn-1" as never, + createdAt: "2026-01-01T00:01:05Z", + updatedAt: "2026-01-01T00:09:00Z", + streaming: true, + }, + }, + { + id: "active-work", + kind: "work" as const, + createdAt: "2026-01-01T00:07:00Z", + entry: { + id: "active-work", + createdAt: "2026-01-01T00:07:00Z", + turnId: "turn-1" as never, + label: "Searched codebase", + tone: "tool" as const, + }, + }, + { + id: "steer-user", + kind: "message" as const, + createdAt: "2026-01-01T00:08:30Z", + message: { + id: "steer-user" as never, + role: "user" as const, + text: "how does our solution compare?", + turnId: null, + createdAt: "2026-01-01T00:08:30Z", + updatedAt: "2026-01-01T00:08:30Z", + streaming: false, + }, + }, + { + id: "post-steer-work", + kind: "work" as const, + createdAt: "2026-01-01T00:08:45Z", + entry: { + id: "post-steer-work", + createdAt: "2026-01-01T00:08:45Z", + turnId: "turn-1" as never, + label: "Compared solutions", + tone: "tool" as const, + }, + }, + ]; + + const interleaved = interleaveTimelineEntriesForSteeredTurn(timelineEntries, { + boundaryStore, + }); + + expect( + interleaved.map((entry) => ({ + id: entry.id, + text: entry.kind === "message" ? entry.message.text : undefined, + })), + ).toEqual([ + { id: "settled-summary", text: "Submit latch fix summary." }, + { id: "turn-start-user", text: "run my build/deploy script" }, + { id: "active-assistant::pre", text: "Tracing timeline ordering." }, + { id: "active-work", text: undefined }, + { id: "steer-user", text: "how does our solution compare?" }, + { + id: "active-assistant::after::steer-user", + text: " Comparing solutions after the steer.", + }, + { id: "post-steer-work", text: undefined }, + ]); + + clearSteerTimelineBoundaryStore(); + observeSteerTextBoundary("active-assistant", "steer-user", "Tracing timeline ordering.".length); + + const rows = deriveMessagesTimelineRows({ + timelineEntries, + latestTurn: { + turnId: "turn-1" as never, + state: "running", + startedAt: "2026-01-01T00:01:00Z", + completedAt: null, + }, + runningTurnId: "turn-1" as never, + isWorking: true, + activeTurnStartedAt: "2026-01-01T00:01:00Z", + turnDiffSummaries: [], + supportsConversationRollback: false, + }); + + expect(rows.map((row) => row.id)).toEqual([ + "settled-summary", + "turn-start-user", + "active-assistant::pre", + "active-work", + "steer-user", + "working-indicator-row", + "active-assistant::after::steer-user", + "live-activity-row", + ]); + + clearSteerTimelineBoundaryStore(); + }); + it("deduplicates integration sources and uses the first source icon for the group", () => { const chromeSource = { key: "browser-use:chrome", @@ -3069,3 +3577,73 @@ describe("computeStableMessagesTimelineRows", () => { expect(reordered.result).toEqual([initial.result[1], initial.result[0]]); }); }); + +describe("collapseConsecutiveDuplicateAssistantEntries", () => { + const turnId = TurnId.make("turn-1"); + + function assistantEntry( + id: string, + text: string, + createdAt: string, + ): Extract { + return { + id, + kind: "message", + createdAt, + message: { + id: MessageId.make(id), + role: "assistant", + text, + turnId, + streaming: false, + createdAt, + updatedAt: createdAt, + }, + }; + } + + function workEntry(id: string, createdAt: string): Extract { + return { + id, + kind: "work", + createdAt, + entry: { + id, + createdAt, + turnId, + label: "Ran command", + command: "echo hi", + tone: "tool", + }, + }; + } + + it("drops a status twin that reappears after tools (Grok sandwich)", () => { + const statusA = + "Aligning Bauhaus with Standard: skip label creation when nothing is still initial."; + const statusB = "Validation passed. Booting e2e."; + const collapsed = collapseConsecutiveDuplicateAssistantEntries([ + assistantEntry("a1", statusA, "2026-07-21T00:00:01Z"), + workEntry("w1", "2026-07-21T00:00:02Z"), + assistantEntry("a2", statusA, "2026-07-21T00:00:03Z"), + assistantEntry("a3", statusB, "2026-07-21T00:00:04Z"), + workEntry("w2", "2026-07-21T00:00:05Z"), + assistantEntry("a4", statusB, "2026-07-21T00:00:06Z"), + ]); + + expect( + collapsed + .filter((entry) => entry.kind === "message") + .map((entry) => (entry.kind === "message" ? entry.message.text : "")), + ).toEqual([statusA, statusB]); + expect(collapsed.map((entry) => entry.id)).toEqual(["a1", "w1", "a3", "w2"]); + }); + + it("keeps distinct consecutive assistant statuses", () => { + const collapsed = collapseConsecutiveDuplicateAssistantEntries([ + assistantEntry("a1", "first", "2026-07-21T00:00:01Z"), + assistantEntry("a2", "second", "2026-07-21T00:00:02Z"), + ]); + expect(collapsed.map((entry) => entry.id)).toEqual(["a1", "a2"]); + }); +}); diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts index 866cbd0201b5..11b531b7c373 100644 --- a/apps/web/src/components/chat/MessagesTimeline.logic.ts +++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts @@ -16,6 +16,12 @@ export { normalizeCompactToolLabel, toolGroupAction, } from "@t3tools/client-runtime/work-log/presentation"; +import { + compareSteerTimelineSortable, + findMidTurnSteerUserIds, + splitAssistantTextAtSteers, + type SteerTimelineBoundaryStore, +} from "@t3tools/shared/steerTimeline"; import { formatDuration, inferCheckpointTurnCountByTurnId, @@ -26,6 +32,7 @@ import { workLogEntryIsToolLike, type TimelineEntry, type WorkLogEntry, + type WorkLogUserInput, } from "../../session-logic"; import { type ChatMessage, type ProposedPlan, type TurnDiffSummary } from "../../types"; import { type MessageId, type OrchestrationLatestTurn, type TurnId } from "@t3tools/contracts"; @@ -302,7 +309,10 @@ export interface TimelineDurationMessage { export type TimelineLatestTurn = Pick< OrchestrationLatestTurn, "turnId" | "state" | "startedAt" | "completedAt" ->; +> & { + /** When set, preferred terminal assistant for this turn (fold / copy meta). */ + readonly assistantMessageId?: MessageId | null; +}; const LIVE_ACTIVITY_ROW_ID = "live-activity-row"; @@ -380,6 +390,13 @@ export type MessagesTimelineRow = createdAt: string; proposedPlan: ProposedPlan; } + | { + kind: "user-input"; + id: string; + createdAt: string; + entry: WorkLogEntry; + userInput: WorkLogUserInput; + } | { kind: "working"; id: string; @@ -456,7 +473,10 @@ export function resolveAssistantMessageCopyState({ }; } -function deriveTerminalAssistantMessageIds(timelineEntries: ReadonlyArray) { +function deriveTerminalAssistantMessageIds( + timelineEntries: ReadonlyArray, + preferredTerminalMessageIdByTurn: ReadonlyMap = new Map(), +) { const lastAssistantMessageIdByResponseKey = new Map(); let nullTurnResponseIndex = 0; @@ -479,6 +499,17 @@ function deriveTerminalAssistantMessageIds(timelineEntries: ReadonlyArray entry.kind === "message" && entry.message.id === messageId, + ); + if (exists) { + lastAssistantMessageIdByResponseKey.set(`turn:${turnId}`, messageId); + } + } + return new Set(lastAssistantMessageIdByResponseKey.values()); } @@ -623,15 +654,64 @@ function deriveTurnFolds(input: { } group.entries.push(entry); if (entry.kind === "message") { - if (input.terminalAssistantMessageIds.has(entry.message.id)) { - group.terminalEntry = entry; - } if (entry.message.streaming) { group.hasStreamingMessage = true; } } } + // Queue-drain / turn flip can stamp the previous turn's final assistant + // message with the *next* turn id at the same timestamp as the next user + // message. Re-home those orphans so the fold keeps the real final visible. + const userCreatedAts = input.timelineEntries + .filter( + (entry): entry is Extract => + entry.kind === "message" && entry.message.role === "user", + ) + .map((entry) => entry.createdAt); + const orderedTurns = [...groupsByTurnId.entries()].sort((left, right) => { + const leftAt = left[1].entries[0]?.createdAt ?? left[1].startBoundary ?? ""; + const rightAt = right[1].entries[0]?.createdAt ?? right[1].startBoundary ?? ""; + return leftAt.localeCompare(rightAt); + }); + for (let index = 1; index < orderedTurns.length; index += 1) { + const previous = orderedTurns[index - 1]; + const current = orderedTurns[index]; + if (!previous || !current) continue; + const [, previousGroup] = previous; + const [, currentGroup] = current; + const previousLastAt = + previousGroup.entries.at(-1)?.createdAt ?? previousGroup.startBoundary ?? null; + if (previousLastAt === null) continue; + const nextUserAt = userCreatedAts.find((createdAt) => createdAt >= previousLastAt) ?? null; + if (nextUserAt === null) continue; + const firstAssistantIndex = currentGroup.entries.findIndex( + (entry) => entry.kind === "message" && entry.message.role === "assistant", + ); + if (firstAssistantIndex < 0) continue; + const firstAssistant = currentGroup.entries[firstAssistantIndex]; + if (!firstAssistant || firstAssistant.kind !== "message") continue; + // True first tokens of the next turn always land *after* that user message. + if (firstAssistant.createdAt > nextUserAt) continue; + currentGroup.entries.splice(firstAssistantIndex, 1); + previousGroup.entries.push(firstAssistant); + } + + // Resolve terminal after re-homing: the last assistant in the group is the + // real final (status lines are earlier). latestTurn.assistantMessageId can + // still point at the first commentary message, so it must not override the + // chronological final. + for (const group of groupsByTurnId.values()) { + group.terminalEntry = null; + let lastAssistant: Extract | null = null; + for (const entry of group.entries) { + if (entry.kind === "message" && entry.message.role === "assistant") { + lastAssistant = entry; + } + } + group.terminalEntry = lastAssistant; + } + const foldsByAnchorEntryId = new Map(); for (const [turnId, group] of groupsByTurnId) { if (input.unfoldedTurnIds.has(turnId)) { @@ -663,6 +743,11 @@ function deriveTurnFolds(input: { if (entry.kind === "work" && entry.entry.agentSpawn !== undefined) { continue; } + // A clarifying question and its answer record a decision the user made; + // keep them readable once the turn settles instead of folding them away. + if (entry.kind === "work" && entry.entry.userInput !== undefined) { + continue; + } hiddenEntryIds.add(entry.id); } if (hiddenEntryIds.size === 0) { @@ -722,6 +807,198 @@ function deriveTurnFolds(input: { return foldsByAnchorEntryId; } +function timelineEntryBelongsToTurn(entry: TimelineEntry, turnId: TurnId): boolean { + if (entry.kind === "work") { + return entry.entry.turnId === turnId; + } + if (entry.kind === "message" && entry.message.role !== "user") { + return entry.message.turnId === turnId; + } + if (entry.kind === "proposed-plan") { + return entry.proposedPlan.turnId === turnId; + } + return false; +} + +function collectTimelineTurnIds(timelineEntries: ReadonlyArray): TurnId[] { + const turnIds: TurnId[] = []; + const seen = new Set(); + for (const entry of timelineEntries) { + const turnId = + entry.kind === "work" + ? entry.entry.turnId + : entry.kind === "proposed-plan" + ? entry.proposedPlan.turnId + : entry.kind === "message" + ? entry.message.turnId + : null; + if (turnId == null || seen.has(String(turnId))) { + continue; + } + seen.add(String(turnId)); + turnIds.push(turnId); + } + return turnIds; +} + +/** + * Cursor/Codex steer while a turn is running reuses the active turn id and + * keeps appending assistant deltas to an early message row. Chronological sort + * alone parks that whole bubble above later steer user messages; the previous + * "move steers above the turn" workaround parked them before *all* turn work. + * + * Instead, interleave by `createdAt` and split assistant text at client-observed + * boundaries so steers sit between pre- and post-steer content (and between + * tools that started before/after the steer). + */ +export function interleaveTimelineEntriesForSteeredTurn( + timelineEntries: ReadonlyArray, + input: { + /** When set, only this turn is expanded. When omitted, every turn with steers is. */ + readonly unsettledTurnId?: TurnId | null; + readonly boundaryStore?: SteerTimelineBoundaryStore; + } = {}, +): TimelineEntry[] { + const turnIds = + input.unsettledTurnId !== undefined && input.unsettledTurnId !== null + ? [input.unsettledTurnId] + : collectTimelineTurnIds(timelineEntries); + + const steersByTurnId = new Map< + string, + ReadonlyArray<{ readonly id: string; readonly createdAt: string }> + >(); + const steerIdSet = new Set(); + + for (const turnId of turnIds) { + const steers = findMidTurnSteerUserIds({ + items: timelineEntries.map((entry) => ({ + id: entry.id, + createdAt: entry.createdAt, + isUser: entry.kind === "message" && entry.message.role === "user", + belongsToActiveTurn: timelineEntryBelongsToTurn(entry, turnId), + })), + }); + if (steers.length === 0) { + continue; + } + steersByTurnId.set(String(turnId), steers); + for (const steer of steers) { + steerIdSet.add(steer.id); + } + } + + if (steersByTurnId.size === 0) { + return [...timelineEntries].toSorted((left, right) => + left.createdAt.localeCompare(right.createdAt), + ); + } + + const expanded: Array = []; + + for (const entry of timelineEntries) { + if ( + entry.kind === "message" && + entry.message.role === "assistant" && + entry.message.turnId !== null + ) { + const steers = steersByTurnId.get(String(entry.message.turnId)); + if (steers !== undefined && steers.length > 0) { + const segments = splitAssistantTextAtSteers({ + assistantMessageId: entry.message.id, + assistantCreatedAt: entry.message.createdAt, + text: entry.message.text, + streaming: entry.message.streaming, + steers, + ...(input.boundaryStore !== undefined ? { boundaryStore: input.boundaryStore } : {}), + }); + + for (const segment of segments) { + expanded.push({ + id: segment.segmentId, + kind: "message", + createdAt: segment.sortAt, + sortRank: segment.sortRank, + message: { + ...entry.message, + text: segment.text, + streaming: segment.streaming, + // Segment sort key — keeps fold/duration helpers aligned with display order. + createdAt: segment.sortAt, + updatedAt: segment.streaming ? entry.message.updatedAt : segment.sortAt, + }, + }); + } + continue; + } + } + + expanded.push({ + ...entry, + sortRank: steerIdSet.has(entry.id) ? 1 : 0, + }); + } + + return expanded.toSorted((left, right) => + compareSteerTimelineSortable( + { id: left.id, sortAt: left.createdAt, sortRank: left.sortRank }, + { id: right.id, sortAt: right.createdAt, sortRank: right.sortRank }, + ), + ); +} + +/** @deprecated Use {@link interleaveTimelineEntriesForSteeredTurn}. */ +export const reorderTimelineEntriesForSteeredTurn = ( + timelineEntries: ReadonlyArray, + input: { + readonly unsettledTurnId?: TurnId | null; + readonly isWorking?: boolean; + readonly boundaryStore?: SteerTimelineBoundaryStore; + }, +): TimelineEntry[] => + interleaveTimelineEntriesForSteeredTurn(timelineEntries, { + ...(input.unsettledTurnId !== undefined ? { unsettledTurnId: input.unsettledTurnId } : {}), + ...(input.boundaryStore !== undefined ? { boundaryStore: input.boundaryStore } : {}), + }); + +/** + * Collapse assistant bubbles that re-surface the same body after tool activity + * within a turn. Grok multi-step ACP has been observed to re-emit the prior + * status line as a new message id after tools (A → tools → A → B); keep the + * first status and drop the twin so the timeline reads A → tools → B. + */ +export function collapseConsecutiveDuplicateAssistantEntries( + entries: ReadonlyArray, +): TimelineEntry[] { + const result: TimelineEntry[] = []; + for (const entry of entries) { + if (entry.kind !== "message" || entry.message.role !== "assistant") { + result.push(entry); + continue; + } + // Walk back across pure work rows so A → tools → A is detected. + let lookback = result.length - 1; + while (lookback >= 0 && result[lookback]?.kind === "work") { + lookback -= 1; + } + const priorAssistant = lookback >= 0 ? result[lookback] : undefined; + if ( + priorAssistant?.kind === "message" && + priorAssistant.message.role === "assistant" && + priorAssistant.message.turnId !== null && + priorAssistant.message.turnId === entry.message.turnId && + priorAssistant.message.text.replace(/\s+/g, " ").trim() === + entry.message.text.replace(/\s+/g, " ").trim() && + entry.message.text.trim().length > 0 + ) { + // Drop this later twin; keep the earlier status and intervening tools. + continue; + } + result.push(entry); + } + return result; +} + /** * When a settled turn ends with tool calls after its terminal text, treat the * text and tools as one visual response. The message metadata becomes the @@ -870,10 +1147,26 @@ export function deriveMessagesTimelineRows(input: { : {}, }); const nextRows: MessagesTimelineRow[] = []; + // Always expand steers for every turn that has them (live + settled). The + // boundary store freezes pre-steer text on first observation so post-steer + // tokens keep rendering after the steer once the turn settles. + const displayTimelineEntries = collapseConsecutiveDuplicateAssistantEntries( + interleaveTimelineEntriesForSteeredTurn(input.timelineEntries), + ); const durationStartByMessageId = computeMessageDurationStart( - input.timelineEntries.flatMap((entry) => (entry.kind === "message" ? [entry.message] : [])), + displayTimelineEntries.flatMap((entry) => (entry.kind === "message" ? [entry.message] : [])), + ); + const preferredTerminalMessageIdByTurn = new Map(); + if (input.latestTurn?.assistantMessageId != null) { + preferredTerminalMessageIdByTurn.set( + input.latestTurn.turnId, + input.latestTurn.assistantMessageId, + ); + } + const terminalAssistantMessageIds = deriveTerminalAssistantMessageIds( + displayTimelineEntries, + preferredTerminalMessageIdByTurn, ); - const terminalAssistantMessageIds = deriveTerminalAssistantMessageIds(input.timelineEntries); const unsettledTurnId = deriveUnsettledTurnId( input.latestTurn ?? null, input.runningTurnId ?? null, @@ -884,7 +1177,7 @@ export function deriveMessagesTimelineRows(input: { isWorking: input.isWorking, }); const foldsByAnchorEntryId = deriveTurnFolds({ - timelineEntries: input.timelineEntries, + timelineEntries: displayTimelineEntries, terminalAssistantMessageIds, latestTurn: input.latestTurn ?? null, unfoldedTurnIds: activeVisualResponseTurnIds, @@ -898,10 +1191,18 @@ export function deriveMessagesTimelineRows(input: { } } - let activeTurnHeaderIndex = input.timelineEntries.length; + let activeTurnHeaderIndex = displayTimelineEntries.length; if (input.isWorking) { - const latestUserMessageIndex = lastUserMessageIndex(input.timelineEntries); - activeTurnHeaderIndex = latestUserMessageIndex + 1; + const latestUserMessageIndex = lastUserMessageIndex(displayTimelineEntries); + const firstOwnedAfterUser = + unsettledTurnId === null + ? -1 + : displayTimelineEntries.findIndex( + (entry, index) => + index > latestUserMessageIndex && timelineEntryTurnId(entry) === unsettledTurnId, + ); + activeTurnHeaderIndex = + firstOwnedAfterUser >= 0 ? firstOwnedAfterUser : latestUserMessageIndex + 1; } const entryBelongsToActiveTurn = (entry: TimelineEntry, index: number) => input.isWorking && @@ -913,8 +1214,8 @@ export function deriveMessagesTimelineRows(input: { entry.toolLifecycleStatus === "inProgress" && entry.turnId === unsettledTurnId; const activeToolEntries: Array> = []; - for (let index = input.timelineEntries.length - 1; index >= activeTurnHeaderIndex; index -= 1) { - const entry = input.timelineEntries[index]!; + for (let index = displayTimelineEntries.length - 1; index >= activeTurnHeaderIndex; index -= 1) { + const entry = displayTimelineEntries[index]!; if ( !entryBelongsToActiveTurn(entry, index) || entry.kind !== "work" || @@ -995,8 +1296,8 @@ export function deriveMessagesTimelineRows(input: { ); }; - for (let index = 0; index < input.timelineEntries.length; index += 1) { - const timelineEntry = input.timelineEntries[index]; + for (let index = 0; index < displayTimelineEntries.length; index += 1) { + const timelineEntry = displayTimelineEntries[index]; if (!timelineEntry) { continue; } @@ -1043,6 +1344,20 @@ export function deriveMessagesTimelineRows(input: { } if (timelineEntry.kind === "work") { + // Clarifying-question exchanges are conversation, not tool noise: they get + // their own row so neither work-group collapsing nor a turn fold hides them. + const userInput = timelineEntry.entry.userInput; + if (userInput) { + nextRows.push({ + kind: "user-input", + id: timelineEntry.id, + createdAt: timelineEntry.createdAt, + entry: timelineEntry.entry, + userInput, + }); + continue; + } + if (timelineEntry.entry.agentSpawn !== undefined || timelineEntry.entry.tone === "error") { nextRows.push({ kind: "work", @@ -1055,11 +1370,12 @@ export function deriveMessagesTimelineRows(input: { } const groupedEntries = [timelineEntry.entry]; let cursor = index + 1; - while (cursor < input.timelineEntries.length) { - const nextEntry = input.timelineEntries[cursor]; + while (cursor < displayTimelineEntries.length) { + const nextEntry = displayTimelineEntries[cursor]; if ( !nextEntry || nextEntry.kind !== "work" || + nextEntry.entry.userInput !== undefined || nextEntry.entry.agentSpawn !== undefined || nextEntry.entry.sourceActivityKind === "context-compaction" || nextEntry.entry.tone === "error" || @@ -1386,6 +1702,9 @@ function isRowUnchanged(a: MessagesTimelineRow, b: MessagesTimelineRow): boolean ); } + case "user-input": + return Equal.equals(a.userInput, (b as typeof a).userInput); + case "work-toggle": { const bw = b as typeof a; return ( diff --git a/apps/web/src/components/chat/MessagesTimeline.test.tsx b/apps/web/src/components/chat/MessagesTimeline.test.tsx index 07252d6ab7fb..562c646eedd7 100644 --- a/apps/web/src/components/chat/MessagesTimeline.test.tsx +++ b/apps/web/src/components/chat/MessagesTimeline.test.tsx @@ -18,6 +18,7 @@ vi.mock("@legendapp/list/react", async () => { const LegendList = (props: { data: Array<{ id: string }>; + extraData?: unknown; keyExtractor: (item: { id: string }) => string; renderItem: (args: { item: { id: string } }) => ReactNode; ListHeaderComponent?: ReactNode; @@ -46,7 +47,13 @@ vi.mock("@legendapp/list/react", async () => { return (
    { ? props.maintainScrollAtEnd.on?.layout : undefined } - data-maintain-visible-content-position={ - typeof props.maintainVisibleContentPosition === "object" - ? "object" - : props.maintainVisibleContentPosition - } data-maintain-visible-content-position-data={ typeof props.maintainVisibleContentPosition === "object" ? props.maintainVisibleContentPosition.data @@ -1016,7 +1018,22 @@ describe("MessagesTimeline", () => { expect(markup).toContain('data-user-message-footer="true"'); }); - it("does not render collapse controls for short user messages", () => { + it("disables end maintenance after the user scrolls away", async () => { + const { MessagesTimeline } = await import("./MessagesTimeline"); + const markup = renderToStaticMarkup( + , + ); + + expect(markup).not.toContain('data-maintain-scroll-at-end="enabled"'); + expect(markup).toContain('data-maintain-visible-content-position="object"'); + }); + + it("does not render collapse controls for short user messages", async () => { + const { MessagesTimeline } = await import("./MessagesTimeline"); const markup = renderToStaticMarkup( { expect(markup).toContain("Compacted context 899K → 19K tokens"); }); + it("renders a clarifying question with the answer it received", () => { + const markup = renderToStaticMarkup( + , + ); + + expect(markup).toContain("Approach"); + expect(markup).toContain("How should we proceed?"); + expect(markup).toContain("Iterate"); + expect(markup).toContain("Show options"); + // The chosen answer reads on its own; alternatives stay behind the toggle. + expect(markup).not.toContain("Another review round"); + }); + + it("marks an unanswered clarifying question as awaiting a reply", () => { + const markup = renderToStaticMarkup( + , + ); + + expect(markup).toContain("Awaiting your answer"); + expect(markup).not.toContain("Work Log"); + }); + it("summarizes changed files in one line", () => { const markup = renderToStaticMarkup( { expect(markup).toContain("text-destructive"); }); + it("renders no load-earlier control when no older turns remain", async () => { + const { MessagesTimeline } = await import("./MessagesTimeline"); + const markup = renderToStaticMarkup( + , + ); + expect(markup).not.toContain("Load earlier turns"); + }); + + it("renders the load-earlier header when older turns exist", async () => { + const { MessagesTimeline } = await import("./MessagesTimeline"); + const markup = renderToStaticMarkup( + {} }} + />, + ); + expect(markup).toContain("Load earlier turns"); + + const loadingMarkup = renderToStaticMarkup( + {} }} + />, + ); + expect(loadingMarkup).toContain("Loading earlier turns"); + }); + it("only withholds an expanded tool-call label click while text is selected", async () => { vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true); vi.stubGlobal("requestAnimationFrame", () => 0); diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx index e2c3b6520de1..a5da763bee30 100644 --- a/apps/web/src/components/chat/MessagesTimeline.tsx +++ b/apps/web/src/components/chat/MessagesTimeline.tsx @@ -241,6 +241,8 @@ interface TimelineRowActivityState { isCompacting: boolean; isRevertingCheckpoint: boolean; latestTurnId: TurnId | null; + /** Current plan step label for the working row, when the turn has a plan. */ + workingStepLabel: string | null; } const TimelineRowCtx = createContext(null!); @@ -322,6 +324,7 @@ interface MessagesTimelineProps { agentPanelModel?: AgentPanelModel; onOpenAgents?: () => void; isWorking: boolean; + workingStepLabel?: string | null; isPreparingWorktree?: boolean; isCompacting?: boolean; activeTurnStartedAt: string | null; @@ -384,6 +387,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({ citationHistoryLoading = false, onCiteAssistantText, isWorking, + workingStepLabel = null, isPreparingWorktree = false, isCompacting = false, activeTurnStartedAt, @@ -824,15 +828,27 @@ export const MessagesTimeline = memo(function MessagesTimeline({ isCompacting, isRevertingCheckpoint, latestTurnId: latestTurn?.turnId ?? null, + workingStepLabel, }), - [isCompacting, isRevertingCheckpoint, isWorking, isPreparingWorktree, latestTurn?.turnId], + [ + isCompacting, + isRevertingCheckpoint, + isWorking, + isPreparingWorktree, + latestTurn?.turnId, + workingStepLabel, + ], ); // Stable renderItem — no closure deps. Row components read shared state // from TimelineRowCtx, which propagates through LegendList's memo. const renderItem = useCallback( ({ item }: { item: MessagesTimelineRow }) => ( -
    +
    ), @@ -870,7 +886,11 @@ export const MessagesTimeline = memo(function MessagesTimeline({ ref={listRef} data={rows} - extraData={`${listIdentityKey}:${rows.length}`} + // LegendList can retain a mounted container's previous child while + // anchored end-space is recomputed around a newly inserted turn. + // Include the thread identity so a huge-thread switch does not keep + // the previous pane's mounted children. + extraData={{ identity: listIdentityKey, rows }} keyExtractor={keyExtractor} getItemType={getItemType} renderItem={renderItem} @@ -1244,6 +1264,10 @@ function TimelineMinimapNavigationButton({ type TimelineWorkEntry = Extract["groupedEntries"][number]; type TimelineRow = MessagesTimelineRow; +type TimelineUserInputQuestion = Extract< + MessagesTimelineRow, + { kind: "user-input" } +>["userInput"]["questions"][number]; const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: TimelineRow }) { const isExpandedToolGroup = row.kind === "work" && row.isExpandedToolGroup; @@ -1300,6 +1324,7 @@ const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: Time ) : null} {row.kind === "assistant-meta" ? : null} {row.kind === "proposed-plan" ? : null} + {row.kind === "user-input" ? : null} {row.kind === "working" ? : null} {row.kind === "thinking" ? : null}
    @@ -1785,41 +1810,6 @@ function ProposedPlanTimelineRow({ ); } -function WorkingTimelineRow({ row }: { row: Extract }) { - const { isCompacting, isPreparingWorktree } = use(TimelineRowActivityCtx); - return ( -
    -
    - - {isPreparingWorktree ? ( - <> - Setting up worktree… - Setting up worktree… - - ) : isCompacting ? ( - <> - - - - - - ) : row.createdAt ? ( - <> - Working for - - ) : ( - "Working..." - )} - -
    -
    - ); -} - function ThinkingTimelineRow() { const { isCompacting, isPreparingWorktree } = use(TimelineRowActivityCtx); // Reserve the activity row during setup so the handoff keeps the same height. @@ -2292,6 +2282,151 @@ function WorkGroupToggleTimelineRow({ ); } +function WorkingTimelineRow({ row }: { row: Extract }) { + const { isCompacting, isPreparingWorktree, workingStepLabel } = use(TimelineRowActivityCtx); + return ( +
    +
    + + {isPreparingWorktree ? ( + <> + Setting up worktree… + Setting up worktree… + + ) : isCompacting ? ( + <> + + + + + + ) : row.createdAt ? ( + <> + Working for + + ) : ( + "Working..." + )} + + {!isPreparingWorktree && !isCompacting && workingStepLabel ? ( + · {workingStepLabel} + ) : null} +
    +
    + ); +} + +/** + * A clarifying-question round trip: what the agent asked and what the user + * picked. The interactive prompt lives in the composer, so this row is the + * thread's only lasting record of the exchange. + */ +const UserInputTimelineRow = memo(function UserInputTimelineRow({ + row, +}: { + row: Extract; +}) { + const [showOptions, setShowOptions] = useState(false); + const { userInput } = row; + const hasUnpickedOptions = userInput.questions.some( + (question) => question.options.length > question.selectedLabels.length, + ); + + return ( +
    + {userInput.questions.map((question, index) => ( +
    0 && "mt-3 border-t border-border/40 pt-3")}> +
    + + + {question.header} + +
    +

    {question.question}

    + + {showOptions && question.options.length > 0 ? ( +
      + {question.options.map((option) => { + const picked = question.selectedLabels.includes(option.label); + return ( +
    • + {option.label} + {option.description && option.description !== option.label ? ( + {option.description} + ) : null} +
      • + ); + })} +
    + ) : null} +
    + ))} + {hasUnpickedOptions ? ( + + ) : null} +
    + ); +}); + +function UserInputAnswer({ + answered, + question, +}: { + answered: boolean; + question: TimelineUserInputQuestion; +}) { + const { selectedLabels, customAnswer } = question; + + if (selectedLabels.length === 0 && !customAnswer) { + return ( +

    + {answered ? "No answer recorded" : "Awaiting your answer"} +

    + ); + } + + return ( +
    + {selectedLabels.map((label) => ( +

    + + {label} +

    + ))} + {customAnswer ? ( +

    + + {customAnswer} +

    + ) : null} +
    + ); +} + /** Subscribes directly to the UI state store for expand/collapse state, * so toggling re-renders only this component — not the entire list. */ const AssistantChangedFilesSection = memo(function AssistantChangedFilesSection({ diff --git a/apps/web/src/components/chat/ModelPickerContent.tsx b/apps/web/src/components/chat/ModelPickerContent.tsx index 63dea7844c46..a7ce86883f45 100644 --- a/apps/web/src/components/chat/ModelPickerContent.tsx +++ b/apps/web/src/components/chat/ModelPickerContent.tsx @@ -1,5 +1,6 @@ import { ANTIGRAVITY_DEFAULT_MODEL, + type AiUsageSnapshot, type ProviderInstanceId, type ProviderDriverKind, type ResolvedKeybindingsConfig, @@ -46,6 +47,8 @@ import { type ProviderInstanceEntry, } from "../../providerInstances"; import { providerModelKey, sortProviderModelItems } from "../../modelOrdering"; +import { resolveDriverUsages } from "../../aiUsageState"; +import { AiUsageStats } from "./AiUsageStats"; type ModelPickerItem = { slug: string; @@ -138,6 +141,8 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: { * for the locked-mode header. */ instanceEntries: ReadonlyArray; + /** Latest AI-usage snapshot for rail markers + per-provider stats. */ + usageSnapshot?: AiUsageSnapshot | null; keybindings?: ResolvedKeybindingsConfig; /** * Model options per instance. Keyed by `ProviderInstanceId` so the @@ -379,6 +384,12 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: { return [...available, ...disabled]; }, [instanceEntries, isLocked, matchesLockedProvider]); const showSidebar = !isSearching && sidebarInstanceEntries.length > 0; + const selectedUsages = useMemo(() => { + const usageInstanceId = + selectedInstanceId === "favorites" ? props.activeInstanceId : selectedInstanceId; + const entry = entryByInstanceId.get(usageInstanceId); + return resolveDriverUsages(props.usageSnapshot, entry?.driverKind ?? null); + }, [entryByInstanceId, props.activeInstanceId, props.usageSnapshot, selectedInstanceId]); const instanceOrder = useMemo( () => instanceEntries.map((entry) => entry.instanceId), [instanceEntries], @@ -738,6 +749,9 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: { selectedInstanceId={selectedInstanceId} onSelectInstance={handleSelectInstance} instanceEntries={sidebarInstanceEntries} + usageSnapshot={props.usageSnapshot ?? null} + activeInstanceId={props.activeInstanceId} + activeModel={props.model} showFavorites {...(selectableUnavailableInstanceIds ? { selectableUnavailableInstanceIds } : {})} {...(lockedDisabledInstanceIds @@ -949,6 +963,18 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: { No models found )} + {!isSearching && selectedUsages.length > 0 ? ( +
    + {selectedUsages.map((usage) => ( + + ))} +
    + ) : null}
    diff --git a/apps/web/src/components/chat/ModelPickerSidebar.tsx b/apps/web/src/components/chat/ModelPickerSidebar.tsx index dd53270268ba..ed0d48df1234 100644 --- a/apps/web/src/components/chat/ModelPickerSidebar.tsx +++ b/apps/web/src/components/chat/ModelPickerSidebar.tsx @@ -1,9 +1,15 @@ -import { type ProviderInstanceId } from "@t3tools/contracts"; -import { memo, useLayoutEffect, useRef, useState } from "react"; +import { type AiUsageSnapshot, type ProviderInstanceId } from "@t3tools/contracts"; +import { memo, useLayoutEffect, useMemo, useRef, useState } from "react"; import { SparklesIcon, StarIcon } from "lucide-react"; import { ProviderInstanceIcon } from "./ProviderInstanceIcon"; import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; import { cn } from "~/lib/utils"; +import { + resolveDriverUsage, + usageDotFillClass, + usageDotRingColor, + usageRank, +} from "../../aiUsageState"; import { isProviderInstancePickerReady, shouldShowInstanceBadge, @@ -63,11 +69,33 @@ export const ModelPickerSidebar = memo(function ModelPickerSidebar(props: { * instances are never flagged — the user just made them). */ newBadgeInstanceIds?: ReadonlySet; + /** Latest AI-usage snapshot for status dots + best-to-use-now ordering. */ + usageSnapshot?: AiUsageSnapshot | null; + /** The composer's active instance + model, so its dot reflects the live + * sub-provider (e.g. z.ai overriding opencode-go). */ + activeInstanceId?: ProviderInstanceId; + activeModel?: string; }) { const handleSelect = (instanceId: ProviderInstanceId | "favorites") => { props.onSelectInstance(instanceId); }; const showFavorites = props.showFavorites ?? true; + // Order the rail best-to-use-now first (the daemon's ranking). Unmapped + // providers keep their relative order via the stable sort tie-break. Locked + // mode already sorts available-first, so leave that ordering untouched. + const usageSnapshot = props.usageSnapshot ?? null; + const orderedInstanceEntries = useMemo(() => { + if (usageSnapshot === null || !usageSnapshot.available) return props.instanceEntries; + return props.instanceEntries + .map((entry, index) => ({ entry, index })) + .sort((a, b) => { + const rankDelta = + usageRank(usageSnapshot, a.entry.driverKind, undefined) - + usageRank(usageSnapshot, b.entry.driverKind, undefined); + return rankDelta !== 0 ? rankDelta : a.index - b.index; + }) + .map(({ entry }) => entry); + }, [props.instanceEntries, usageSnapshot]); const [hoveredInstanceId, setHoveredInstanceId] = useState(null); const sidebarContentRef = useRef(null); const [selectedIndicatorTop, setSelectedIndicatorTop] = useState(null); @@ -134,8 +162,19 @@ export const ModelPickerSidebar = memo(function ModelPickerSidebar(props: { ) : null} {/* Instance buttons (one per configured instance — built-in + custom) */} - {props.instanceEntries.map((entry) => { + {orderedInstanceEntries.map((entry) => { const isUnavailable = !isProviderInstancePickerReady(entry); + // The active instance resolves against its live model so z.ai + // overrides opencode-go; others fall back to the driver default. + const entryModelSlug = + entry.instanceId === props.activeInstanceId ? props.activeModel : undefined; + const usageMarker = resolveDriverUsage( + usageSnapshot, + entry.driverKind, + entryModelSlug, + )?.marker; + const usageDotClass = usageMarker ? usageDotFillClass(usageMarker) : undefined; + const usageRingColor = usageMarker ? usageDotRingColor(usageMarker) : undefined; const isContextDisabled = props.disabledInstanceIds?.has(entry.instanceId) ?? false; const unavailableSelectionIsReachable = props.selectableUnavailableInstanceIds?.has(entry.instanceId) ?? false; @@ -197,6 +236,8 @@ export const ModelPickerSidebar = memo(function ModelPickerSidebar(props: { {...(entry.accentColor ? { badgeClassName: "h-3 min-w-3 px-0.5 text-[7px]" } : {})} + {...(usageDotClass ? { statusDotClassName: usageDotClass } : {})} + {...(usageRingColor ? { statusDotRingColor: usageRingColor } : {})} /> {showNewBadge ? ( diff --git a/apps/web/src/components/chat/OpenInPicker.test.ts b/apps/web/src/components/chat/OpenInPicker.test.ts new file mode 100644 index 000000000000..7a57c0a12ed7 --- /dev/null +++ b/apps/web/src/components/chat/OpenInPicker.test.ts @@ -0,0 +1,38 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { resolveDesktopEditorUri } from "./OpenInPicker"; + +describe("resolveDesktopEditorUri", () => { + it("builds a vscode://file URL for VS Code", () => { + expect(resolveDesktopEditorUri("vscode", "/home/tester/projects/example")).toBe( + "vscode://file/home/tester/projects/example?windowId=_blank", + ); + }); + + it("builds a vscode-insiders://file URL for VS Code Insiders", () => { + expect(resolveDesktopEditorUri("vscode-insiders", "/home/tester/project")).toBe( + "vscode-insiders://file/home/tester/project?windowId=_blank", + ); + }); + + it("builds a cursor://file URL for Cursor", () => { + expect(resolveDesktopEditorUri("cursor", "/home/tester/project")).toBe( + "cursor://file/home/tester/project?windowId=_blank", + ); + }); + + it("encodes path segments with spaces and reserved characters", () => { + expect(resolveDesktopEditorUri("vscode", "/home/tester/project with spaces")).toBe( + "vscode://file/home/tester/project%20with%20spaces?windowId=_blank", + ); + }); + + it("returns null for editors without a URL scheme", () => { + expect(resolveDesktopEditorUri("vscodium", "/home/tester/project")).toBeNull(); + expect(resolveDesktopEditorUri("zed", "/home/tester/project")).toBeNull(); + }); + + it("returns null for a non-absolute path", () => { + expect(resolveDesktopEditorUri("vscode", "relative/path")).toBeNull(); + }); +}); diff --git a/apps/web/src/components/chat/OpenInPicker.tsx b/apps/web/src/components/chat/OpenInPicker.tsx index 9f8e81bdba67..7da65d05f0eb 100644 --- a/apps/web/src/components/chat/OpenInPicker.tsx +++ b/apps/web/src/components/chat/OpenInPicker.tsx @@ -1,24 +1,71 @@ import { buildRemoteOpenUrl, EditorId, - type EnvironmentId, + EnvironmentId, + OpenWithEntry as OpenWithEntrySchema, + PRIMARY_LOCAL_ENVIRONMENT_ID, + type OpenWithDirectoryMode, + type OpenWithEntry, + type OpenWithEntryKind, + type OpenWithEntryPresentation, + type OpenWithEntryRef, type ResolvedKeybindingsConfig, } from "@t3tools/contracts"; -import { memo, useCallback, useEffect, useMemo } from "react"; -import { isOpenFavoriteEditorShortcut, shortcutLabelForCommand } from "../../keybindings"; -import { usePreferredEditor } from "../../editorPreferences"; +import * as Schema from "effect/Schema"; +import { + AppWindowIcon, + ChevronDownIcon, + Code2Icon, + FolderClosedIcon, + PlusIcon, + SettingsIcon, + SquareTerminalIcon, + Trash2Icon, + TriangleAlertIcon, +} from "lucide-react"; +import { memo, useCallback, useEffect, useId, useMemo, useState, type FormEvent } from "react"; + +import { readLegacyPreferredEditor } from "../../editorPreferences"; import { editorLabelForPlatform } from "../../editorLabels"; +import { isOpenFavoriteEditorShortcut, shortcutLabelForCommand } from "../../keybindings"; import { - openRemoteEditorUrl, - useRemoteCapableEditors, - useRemoteOpenHint, - useRemoteOpenState, -} from "../../remoteOpen"; -import { useEnvironment } from "../../state/environments"; -import { ChevronDownIcon, FolderClosedIcon } from "lucide-react"; + mergeOpenWithOptions, + nextOpenWithEntryId, + refForOpenWithOption, + resolveEffectiveOpenWith, + type OpenWithOption, +} from "../../openWith"; +import { useClientSettings, useUpdateClientSettings } from "../../hooks/useSettings"; +import { ensureLocalApi, readLocalApi } from "../../localApi"; +import { openRemoteEditorUrl, useRemoteOpenState } from "../../remoteOpen"; +import { usePrimaryEnvironmentId } from "../../state/environments"; +import { shellEnvironment } from "../../state/shell"; +import { useAtomCommand } from "../../state/use-atom-command"; +import { + AlertDialog, + AlertDialogClose, + AlertDialogDescription, + AlertDialogFooter, + AlertDialogHeader, + AlertDialogPopup, + AlertDialogTitle, +} from "../ui/alert-dialog"; import { Button } from "../ui/button"; +import { + Dialog, + DialogDescription, + DialogFooter, + DialogHeader, + DialogPanel, + DialogPopup, + DialogTitle, +} from "../ui/dialog"; import { Group, GroupSeparator } from "../ui/group"; -import { Menu, MenuItem, MenuPopup, MenuShortcut, MenuTrigger } from "../ui/menu"; +import { Input } from "../ui/input"; +import { Label } from "../ui/label"; +import { Menu, MenuItem, MenuPopup, MenuSeparator, MenuShortcut, MenuTrigger } from "../ui/menu"; +import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select"; +import { stackedThreadToast, toastManager } from "../ui/toast"; import { AntigravityIcon, CursorIcon, @@ -44,133 +91,157 @@ import { RustRoverIcon, WebStormIcon, } from "../JetBrainsIcons"; -import { cn } from "~/lib/utils"; -import { shellEnvironment } from "~/state/shell"; -import { useAtomCommand } from "~/state/use-atom-command"; - -type OpenInOption = { - label: string; - Icon: Icon; - value: EditorId; - kind: "brand" | "generic"; +import { cn, isMacPlatform, isWindowsPlatform, randomUUID } from "~/lib/utils"; + +function desktopEditorUrlScheme(editor: EditorId): string | null { + switch (editor) { + case "vscode": + return "vscode"; + case "vscode-insiders": + return "vscode-insiders"; + case "cursor": + return "cursor"; + default: + return null; + } +} + +export function resolveDesktopEditorUri(editor: EditorId, cwd: string): string | null { + const scheme = desktopEditorUrlScheme(editor); + if (!scheme || !cwd.startsWith("/")) return null; + const encodedPath = cwd.split("/").map(encodeURIComponent).join("/"); + return `${scheme}://file${encodedPath}?windowId=_blank`; +} + +type BuiltinPresentation = { + readonly label: string; + readonly Icon: Icon; + readonly value: EditorId; + readonly kind: "brand" | "generic"; }; -const resolveOptions = (platform: string, availableEditors: ReadonlyArray) => { - const baseOptions: ReadonlyArray> = [ - { - Icon: CursorIcon, - value: "cursor", - kind: "brand", - }, - { - Icon: TraeIcon, - value: "trae", - kind: "brand", - }, - { - Icon: KiroIcon, - value: "kiro", - kind: "brand", - }, - { - Icon: VisualStudioCode, - value: "vscode", - kind: "brand", - }, - { - Icon: VisualStudioCodeInsiders, - value: "vscode-insiders", - kind: "brand", - }, - { - Icon: VSCodium, - value: "vscodium", - kind: "brand", - }, - { - Icon: Zed, - value: "zed", - kind: "brand", - }, - { - Icon: AntigravityIcon, - value: "antigravity", - kind: "brand", - }, - { - Icon: IntelliJIdeaIcon, - value: "idea", - kind: "brand", - }, - { - Icon: AquaIcon, - value: "aqua", - kind: "brand", - }, - { - Icon: CLionIcon, - value: "clion", - kind: "brand", - }, - { - Icon: DataGripIcon, - value: "datagrip", - kind: "brand", - }, - { - Icon: DataSpellIcon, - value: "dataspell", - kind: "brand", - }, - { - Icon: GoLandIcon, - value: "goland", - kind: "brand", - }, - { - Icon: PhpStormIcon, - value: "phpstorm", - kind: "brand", - }, - { - Icon: PyCharmIcon, - value: "pycharm", - kind: "brand", - }, - { - Icon: RiderIcon, - value: "rider", - kind: "brand", - }, - { - Icon: RubyMineIcon, - value: "rubymine", - kind: "brand", - }, - { - Icon: RustRoverIcon, - value: "rustrover", - kind: "brand", - }, - { - Icon: WebStormIcon, - value: "webstorm", - kind: "brand", - }, - { - Icon: FolderClosedIcon, - value: "file-manager", - kind: "generic", - }, - ]; - const availableEditorSet = new Set(availableEditors); - return baseOptions - .filter((option) => availableEditorSet.has(option.value)) - .map((option) => ({ ...option, label: editorLabelForPlatform(option.value, platform) })); +const BUILTIN_PRESENTATIONS: readonly BuiltinPresentation[] = [ + { label: "Cursor", Icon: CursorIcon, value: "cursor", kind: "brand" }, + { label: "Trae", Icon: TraeIcon, value: "trae", kind: "brand" }, + { label: "Kiro", Icon: KiroIcon, value: "kiro", kind: "brand" }, + { label: "VS Code", Icon: VisualStudioCode, value: "vscode", kind: "brand" }, + { + label: "VS Code Insiders", + Icon: VisualStudioCodeInsiders, + value: "vscode-insiders", + kind: "brand", + }, + { label: "VSCodium", Icon: VSCodium, value: "vscodium", kind: "brand" }, + { label: "Zed", Icon: Zed, value: "zed", kind: "brand" }, + { label: "Antigravity", Icon: AntigravityIcon, value: "antigravity", kind: "brand" }, + { label: "IntelliJ IDEA", Icon: IntelliJIdeaIcon, value: "idea", kind: "brand" }, + { label: "Aqua", Icon: AquaIcon, value: "aqua", kind: "brand" }, + { label: "CLion", Icon: CLionIcon, value: "clion", kind: "brand" }, + { label: "DataGrip", Icon: DataGripIcon, value: "datagrip", kind: "brand" }, + { label: "DataSpell", Icon: DataSpellIcon, value: "dataspell", kind: "brand" }, + { label: "GoLand", Icon: GoLandIcon, value: "goland", kind: "brand" }, + { label: "PhpStorm", Icon: PhpStormIcon, value: "phpstorm", kind: "brand" }, + { label: "PyCharm", Icon: PyCharmIcon, value: "pycharm", kind: "brand" }, + { label: "Rider", Icon: RiderIcon, value: "rider", kind: "brand" }, + { label: "RubyMine", Icon: RubyMineIcon, value: "rubymine", kind: "brand" }, + { label: "RustRover", Icon: RustRoverIcon, value: "rustrover", kind: "brand" }, + { label: "WebStorm", Icon: WebStormIcon, value: "webstorm", kind: "brand" }, + { label: "File Manager", Icon: FolderClosedIcon, value: "file-manager", kind: "generic" }, +]; + +const DESKTOP_PRIMARY_ENVIRONMENT_ID = EnvironmentId.make(PRIMARY_LOCAL_ENVIRONMENT_ID); + +const builtinPresentationById = new Map(BUILTIN_PRESENTATIONS.map((entry) => [entry.value, entry])); +const decodeOpenWithEntry = Schema.decodeUnknownSync(OpenWithEntrySchema); + +type ArgumentRow = { readonly id: string; readonly value: string }; +const makeArgumentRow = (value = ""): ArgumentRow => ({ id: randomUUID(), value }); + +const OPEN_WITH_KIND_LABELS: Record = { + editor: "Editor", + terminal: "Terminal", + "file-manager": "File manager", + other: "Other", }; -function getOpenInIconClass(kind: OpenInOption["kind"]) { - return cn(kind === "brand" ? "text-foreground opacity-100" : "text-muted-foreground"); +const DIRECTORY_MODE_LABELS: Record = { + "open-target": "Open target", + "working-directory": "Working directory", + "custom-arguments": "Custom arguments", +}; + +function categoryIcon(kind: OpenWithEntryKind): Icon { + if (kind === "editor") return Code2Icon; + if (kind === "terminal") return SquareTerminalIcon; + if (kind === "file-manager") return FolderClosedIcon; + return AppWindowIcon; +} + +function CustomIcon({ + entry, + presentation, + className, +}: { + entry: OpenWithEntry; + presentation: OpenWithEntryPresentation | null; + className?: string; +}) { + if (presentation?.iconDataUrl) { + return ; + } + const FallbackIcon = categoryIcon(entry.kind); + return
    + ); +}); diff --git a/apps/web/src/components/chat/ThreadErrorBanner.tsx b/apps/web/src/components/chat/ThreadErrorBanner.tsx index 29a6a6db1846..8bad53b50c46 100644 --- a/apps/web/src/components/chat/ThreadErrorBanner.tsx +++ b/apps/web/src/components/chat/ThreadErrorBanner.tsx @@ -1,8 +1,8 @@ import { memo } from "react"; import { Alert, AlertAction, AlertDescription } from "../ui/alert"; import { Button } from "../ui/button"; +import { ErrorDetailText } from "../ui/errorDetailText"; import { CircleAlertIcon, XIcon } from "lucide-react"; -import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; export function getThreadErrorBannerKey(threadKey: string, error: string | null): string | null { return error === null ? null : `${threadKey}\u0000${error}`; @@ -50,13 +50,8 @@ export const ThreadErrorBanner = memo(function ThreadErrorBanner({ data-variant="error" > - - - }>{error} - - {error} - - + + {onDismiss && ( diff --git a/apps/web/src/components/chat/TraitsPicker.tsx b/apps/web/src/components/chat/TraitsPicker.tsx index 47ce59efde52..da5146bb0b4a 100644 --- a/apps/web/src/components/chat/TraitsPicker.tsx +++ b/apps/web/src/components/chat/TraitsPicker.tsx @@ -593,14 +593,7 @@ export const TraitsPicker = memo(function TraitsPicker({ Fast mode on diff --git a/apps/web/src/components/chat/queuedAttachmentRecall.test.ts b/apps/web/src/components/chat/queuedAttachmentRecall.test.ts new file mode 100644 index 000000000000..81f646f2c9db --- /dev/null +++ b/apps/web/src/components/chat/queuedAttachmentRecall.test.ts @@ -0,0 +1,155 @@ +import { PROVIDER_SEND_TURN_MAX_ATTACHMENTS } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + describeQueuedAttachmentCapacity, + formatMissingAttachmentsError, + recallQueuedAttachments, + type RecallableQueuedAttachment, +} from "./queuedAttachmentRecall"; + +const attachment = ( + overrides: Partial = {}, +): RecallableQueuedAttachment => ({ + id: "attachment-1", + name: "screenshot.png", + mimeType: "image/png", + sizeBytes: 4, + ...overrides, +}); + +const deps = (overrides: Partial[1]> = {}) => ({ + urlById: new Map([["attachment-1", "https://assets.test/attachment-1"]]), + fetchBlob: async () => new Blob(["png!"], { type: "image/png" }), + createObjectUrl: (file: File) => `blob:${file.name}`, + ...overrides, +}); + +describe("recallQueuedAttachments", () => { + it("rebuilds a composer image with the bytes fetched back", async () => { + const result = await recallQueuedAttachments([attachment()], deps()); + + expect(result.missing).toEqual([]); + expect(result.images).toHaveLength(1); + const image = result.images[0]!; + expect(image.type).toBe("image"); + expect(image.name).toBe("screenshot.png"); + expect(image.mimeType).toBe("image/png"); + expect(image.sizeBytes).toBe(4); + expect(image.previewUrl).toBe("blob:screenshot.png"); + expect(image.file).toBeInstanceOf(File); + expect(await image.file.text()).toBe("png!"); + }); + + it("gives the recalled draft a fresh id so it outlives the removed queue entry", async () => { + const result = await recallQueuedAttachments([attachment()], deps()); + + expect(result.images[0]!.id).not.toBe("attachment-1"); + }); + + it("fetches each attachment from its own signed url", async () => { + const requested: string[] = []; + const result = await recallQueuedAttachments( + [attachment(), attachment({ id: "attachment-2", name: "diagram.png" })], + deps({ + urlById: new Map([ + ["attachment-1", "https://assets.test/one"], + ["attachment-2", "https://assets.test/two"], + ]), + fetchBlob: async (url: string) => { + requested.push(url); + return new Blob(["x"], { type: "image/png" }); + }, + }), + ); + + expect(requested).toEqual(["https://assets.test/one", "https://assets.test/two"]); + expect(result.images.map((image) => image.name)).toEqual(["screenshot.png", "diagram.png"]); + }); + + it("reports an attachment whose url has not resolved instead of dropping it silently", async () => { + const result = await recallQueuedAttachments([attachment()], deps({ urlById: new Map() })); + + expect(result.images).toEqual([]); + expect(result.missing).toEqual(["screenshot.png"]); + }); + + it("keeps the readable attachments when one fetch fails", async () => { + const result = await recallQueuedAttachments( + [attachment(), attachment({ id: "attachment-2", name: "broken.png" })], + deps({ + urlById: new Map([ + ["attachment-1", "https://assets.test/one"], + ["attachment-2", "https://assets.test/two"], + ]), + fetchBlob: async (url: string) => { + if (url.endsWith("two")) throw new Error("gone"); + return new Blob(["x"], { type: "image/png" }); + }, + }), + ); + + expect(result.images.map((image) => image.name)).toEqual(["screenshot.png"]); + expect(result.missing).toEqual(["broken.png"]); + }); + + it("falls back to the blob's own type when the queued mime type is empty", async () => { + const result = await recallQueuedAttachments( + [attachment({ mimeType: "" })], + deps({ fetchBlob: async () => new Blob(["x"], { type: "image/webp" }) }), + ); + + expect(result.images[0]!.mimeType).toBe("image/webp"); + }); + + it("returns nothing for a queued message with no attachments", async () => { + const result = await recallQueuedAttachments([], deps()); + + expect(result).toEqual({ images: [], missing: [] }); + }); +}); + +describe("formatMissingAttachmentsError", () => { + it("stays silent when everything was restored", () => { + expect(formatMissingAttachmentsError([])).toBeNull(); + }); + + it("names the single attachment that was left behind", () => { + expect(formatMissingAttachmentsError(["screenshot.png"])).toBe( + "'screenshot.png' could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.", + ); + }); + + it("counts them once several were left behind", () => { + expect(formatMissingAttachmentsError(["a.png", "b.png"])).toBe( + "2 attachments could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.", + ); + }); +}); + +describe("describeQueuedAttachmentCapacity", () => { + it("allows an edit that fits in the composer", () => { + expect(describeQueuedAttachmentCapacity(3, 2)).toBeNull(); + }); + + it("allows an edit that exactly fills the remaining room", () => { + expect(describeQueuedAttachmentCapacity(3, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 3)).toBeNull(); + }); + + it("refuses an edit that would overflow, rather than restoring only some pictures", () => { + const message = describeQueuedAttachmentCapacity(3, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 2); + + expect(message).toContain(`${PROVIDER_SEND_TURN_MAX_ATTACHMENTS}-image limit`); + expect(message).toContain("Remove some images from the composer first."); + }); + + it("says image, singular, for one attachment", () => { + expect(describeQueuedAttachmentCapacity(1, PROVIDER_SEND_TURN_MAX_ATTACHMENTS)).toContain( + "bring back 1 image,", + ); + }); + + it("never blocks a message with no attachments", () => { + expect(describeQueuedAttachmentCapacity(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS)).toBeNull(); + }); +}); diff --git a/apps/web/src/components/chat/queuedAttachmentRecall.ts b/apps/web/src/components/chat/queuedAttachmentRecall.ts new file mode 100644 index 000000000000..e994c6091087 --- /dev/null +++ b/apps/web/src/components/chat/queuedAttachmentRecall.ts @@ -0,0 +1,114 @@ +import { PROVIDER_SEND_TURN_MAX_ATTACHMENTS } from "@t3tools/contracts"; + +import type { ComposerImageAttachment } from "../../composerDraftStore"; +import { randomUUID } from "../../lib/utils"; + +/** + * Rebuilding composer attachments when a queued message is edited. + * + * A queued message's attachments name bytes the server holds — `{id, name, + * mimeType, sizeBytes}` and nothing more. The composer needs the bytes + * themselves (`File` + an object URL), so recalling a queued message for + * editing has to fetch each attachment back through its signed asset URL. + * + * Callers must do this *before* removing the queued message. The removal is + * what makes the edit destructive: once the queued entry is gone, its + * attachment files are pruned server-side and a failed fetch has no second + * chance — so a caller that cannot restore everything must leave the message + * queued rather than remove it. + */ + +export interface RecallableQueuedAttachment { + readonly id: string; + readonly name: string; + readonly mimeType: string; + readonly sizeBytes: number; +} + +export interface QueuedAttachmentRecallResult { + readonly images: ReadonlyArray; + /** Attachments whose bytes could not be fetched back, by display name. */ + readonly missing: ReadonlyArray; +} + +export interface QueuedAttachmentRecallDeps { + /** Signed asset URL for an attachment id, when one has resolved yet. */ + readonly urlById: ReadonlyMap; + readonly fetchBlob: (url: string) => Promise; + readonly createObjectUrl: (file: File) => string; +} + +export const defaultFetchAttachmentBlob = async (url: string): Promise => { + const response = await fetch(url); + if (!response.ok) { + throw new Error(`Attachment request failed with status ${response.status}.`); + } + return await response.blob(); +}; + +/** + * Fetches every queued attachment back into a composer-ready image. Failures + * are collected rather than thrown so the caller sees the whole picture at + * once: because removing the queued message prunes its files, a caller that + * cannot restore everything must abandon the edit rather than restore part. + */ +export const recallQueuedAttachments = async ( + attachments: ReadonlyArray, + deps: QueuedAttachmentRecallDeps, +): Promise => { + const images: ComposerImageAttachment[] = []; + const missing: string[] = []; + + for (const attachment of attachments) { + const url = deps.urlById.get(attachment.id); + if (!url) { + missing.push(attachment.name); + continue; + } + try { + const blob = await deps.fetchBlob(url); + // A fresh id keeps the recalled draft independent of the queued entry + // that is about to be removed, matching how pasted images are staged. + const file = new File([blob], attachment.name, { + type: attachment.mimeType || blob.type, + }); + images.push({ + type: "image", + id: randomUUID(), + name: attachment.name, + mimeType: file.type, + sizeBytes: file.size, + previewUrl: deps.createObjectUrl(file), + file, + }); + } catch { + missing.push(attachment.name); + } + } + + return { images, missing }; +}; + +export const formatMissingAttachmentsError = (missing: ReadonlyArray): string | null => { + if (missing.length === 0) return null; + return missing.length === 1 + ? `'${missing[0]}' could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.` + : `${missing.length} attachments could not be loaded, so the message is still queued. Try again — if it keeps failing, the image is no longer on the server and the message has to be sent or replaced as it is.`; +}; + +/** + * Refuses the edit up front when the composer has no room for the queued + * message's pictures. Restoring only some of them would drop the rest for good, + * since removing the queued message deletes its attachment files server-side. + */ +export const describeQueuedAttachmentCapacity = ( + queuedCount: number, + draftImageCount: number, +): string | null => { + if (queuedCount === 0) return null; + const capacity = Math.max(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - draftImageCount); + if (queuedCount <= capacity) return null; + return `Editing this message would bring back ${queuedCount} image${ + queuedCount === 1 ? "" : "s" + }, past the ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS}-image limit. Remove some images from the composer first.`; +}; diff --git a/apps/web/src/components/cloud/cloudEnvironmentConnectionPresentation.test.ts b/apps/web/src/components/cloud/cloudEnvironmentConnectionPresentation.test.ts index 654c2462a6f0..7fda1a2889d3 100644 --- a/apps/web/src/components/cloud/cloudEnvironmentConnectionPresentation.test.ts +++ b/apps/web/src/components/cloud/cloudEnvironmentConnectionPresentation.test.ts @@ -32,14 +32,13 @@ describe("saved cloud environment connection presentation", () => { ), ).toEqual({ buttonLabel: "Reconnecting…", - statusText: - "Failed to connect. Reconnecting... Reason: Relay environment endpoint is unavailable.", + statusText: "Reconnecting… · Relay environment endpoint is unavailable", tone: "connecting", }); }); it.each([ - ["error", "Connection failed", "Connection failed. Reason: Access denied.", "error"], + ["error", "Connection failed", "Connection failed · Access denied", "error"], ["offline", "Offline", "Offline", "idle"], ["available", "Not connected", "Available", "idle"], ] as const)( diff --git a/apps/web/src/components/desktopUpdate.toast.tsx b/apps/web/src/components/desktopUpdate.toast.tsx index 0c4991c17250..eb264de800c6 100644 --- a/apps/web/src/components/desktopUpdate.toast.tsx +++ b/apps/web/src/components/desktopUpdate.toast.tsx @@ -21,31 +21,6 @@ export async function openDesktopUpdateReleaseNotes( toastManager.add({ type: "error", title: "Unable to open release notes" }); } -function ReleaseNotesLink({ - shell, - releaseUrl, -}: { - shell: DesktopUpdateShell; - releaseUrl: string; -}) { - return ( - - ); -} - export function showDesktopUpdateDownloadedToast( shell: DesktopUpdateShell, state: DesktopUpdateState, @@ -57,7 +32,22 @@ export function showDesktopUpdateDownloadedToast( description: ( <> Restart the app from the update button to install it. - {releaseUrl ? : null} + {releaseUrl ? ( + + ) : null} ), }); diff --git a/apps/web/src/components/files/fileEditorHighlight.test.ts b/apps/web/src/components/files/fileEditorHighlight.test.ts index 39624d953c09..7954a919f1e0 100644 --- a/apps/web/src/components/files/fileEditorHighlight.test.ts +++ b/apps/web/src/components/files/fileEditorHighlight.test.ts @@ -229,6 +229,7 @@ describe("editable file highlighting", () => { it.each([1, 60])( "ignores a dispatched highlight after %i Enter edits and highlights the new version", + { timeout: 60_000 }, async (count) => { const oldResponse = await nextResponse(); for (let index = 0; index < count; index += 1) append("\n"); diff --git a/apps/web/src/components/files/fileEditorLanguageReadiness.test.ts b/apps/web/src/components/files/fileEditorLanguageReadiness.test.ts index 520c0fa82d0e..52253d6c27d6 100644 --- a/apps/web/src/components/files/fileEditorLanguageReadiness.test.ts +++ b/apps/web/src/components/files/fileEditorLanguageReadiness.test.ts @@ -40,6 +40,7 @@ const source = "export const View = () =>
    Ready
    ;"; let pool: WorkerPoolManager; let renderer: FileRenderer; let terminationPromises: Promise[]; +let animationFrames: Set>; class WorkerTransport { private readonly worker = new NodeWorkerThreads.Worker( @@ -96,10 +97,19 @@ function firstEnter(highlighter: DiffsHighlighter, file: FileContents, language: beforeEach(async () => { terminationPromises = []; - vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => - setImmediate(() => callback(0)), - ); - vi.stubGlobal("cancelAnimationFrame", clearImmediate); + animationFrames = new Set(); + vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => { + const frame = setImmediate(() => { + animationFrames.delete(frame); + callback(0); + }); + animationFrames.add(frame); + return frame; + }); + vi.stubGlobal("cancelAnimationFrame", (frame: ReturnType) => { + animationFrames.delete(frame); + clearImmediate(frame); + }); vi.stubGlobal("window", { matchMedia: () => ({ matches: true }) }); await disposeHighlighter(); pool = new WorkerPoolManager( @@ -116,6 +126,9 @@ afterEach(async () => { pool?.terminate(); await Promise.all(terminationPromises); await disposeHighlighter(); + // Pool termination can queue a final broadcast after its workers have exited. + for (const frame of animationFrames) clearImmediate(frame); + animationFrames.clear(); vi.unstubAllGlobals(); }); diff --git a/apps/web/src/components/files/projectFilesQueryState.ts b/apps/web/src/components/files/projectFilesQueryState.ts index a12772920956..7d6d8c807119 100644 --- a/apps/web/src/components/files/projectFilesQueryState.ts +++ b/apps/web/src/components/files/projectFilesQueryState.ts @@ -186,7 +186,7 @@ export function useProjectFileQuery( relativePath !== null && (isWorkspaceImagePreviewPath(relativePath) || isWorkspaceVideoPreviewPath(relativePath)); const atom = - enabled && !isMedia + enabled && relativePath !== null && !isMedia ? getProjectFileQueryAtom(environmentId, cwd, relativePath) : EMPTY_PROJECT_FILE_QUERY_ATOM; const result = useAtomValue(atom); diff --git a/apps/web/src/components/identity/IdentityAvatar.tsx b/apps/web/src/components/identity/IdentityAvatar.tsx new file mode 100644 index 000000000000..ab0527a12259 --- /dev/null +++ b/apps/web/src/components/identity/IdentityAvatar.tsx @@ -0,0 +1,45 @@ +import { identityAvatar } from "@t3tools/shared/identityAvatar"; +import { cn } from "~/lib/utils"; + +export function IdentityAvatar(props: { + readonly personId?: string | null | undefined; + readonly username?: string | null | undefined; + readonly name?: string | null | undefined; + readonly size?: "micro" | "sm" | "md"; + readonly className?: string; + readonly highlighted?: boolean; + /** `null` suppresses the native title when a parent owns richer tooltip content. */ + readonly title?: string | null; +}) { + const model = identityAvatar({ + personId: props.personId, + username: props.username, + name: props.name, + }); + const sizeClass = + props.size === "md" + ? "size-7 text-[11px]" + : props.size === "sm" + ? "size-6 text-[10px]" + : "size-3.5 text-[8px]"; + + const title = props.title === null ? undefined : (props.title ?? model.label); + + return ( + + {model.initials} + + ); +} diff --git a/apps/web/src/components/identity/IdentityClaimGate.tsx b/apps/web/src/components/identity/IdentityClaimGate.tsx new file mode 100644 index 000000000000..11710c4556e3 --- /dev/null +++ b/apps/web/src/components/identity/IdentityClaimGate.tsx @@ -0,0 +1,377 @@ +import { + filterPeopleForTypeahead, + identityClaimRequired, +} from "@t3tools/client-runtime/state/identity"; +import { + IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS, + IdentityUsername, + type EnvironmentId, + type IdentityPersonPublic, +} from "@t3tools/contracts"; +import { useEffect, useMemo, useState } from "react"; + +import { useActiveEnvironmentId } from "../../state/entities"; +import { useEnvironments, usePrimaryEnvironmentId } from "../../state/environments"; +import { identityEnvironment } from "../../state/identity"; +import { useEnvironmentQuery } from "../../state/query"; +import { useAtomCommand } from "../../state/use-atom-command"; +import { Button } from "../ui/button"; +import { Input } from "../ui/input"; +import { IdentityAvatar } from "./IdentityAvatar"; + +/** + * Force-open the claim modal (e.g. after a dispatch error). Optionally target + * the environment that rejected the operate (critical for multi-env: primary + * smart has no map while secondary t3vm requires claim). + */ +let forceClaimOpen = false; +let forceClaimEnvironmentId: EnvironmentId | null = null; +const forceClaimListeners = new Set<() => void>(); + +export function requestIdentityClaimGate(environmentId?: EnvironmentId | null): void { + forceClaimOpen = true; + forceClaimEnvironmentId = environmentId ?? null; + for (const listener of forceClaimListeners) { + listener(); + } +} + +function useForceClaimState(): { + readonly open: boolean; + readonly environmentId: EnvironmentId | null; +} { + const [state, setState] = useState({ + open: forceClaimOpen, + environmentId: forceClaimEnvironmentId, + }); + useEffect(() => { + const listener = () => + setState({ open: forceClaimOpen, environmentId: forceClaimEnvironmentId }); + forceClaimListeners.add(listener); + return () => { + forceClaimListeners.delete(listener); + }; + }, []); + return state; +} + +function clearForceClaimOpen(): void { + forceClaimOpen = false; + forceClaimEnvironmentId = null; + for (const listener of forceClaimListeners) { + listener(); + } +} + +/** + * Full-screen "Who are you?" gate when *any* connected environment has a + * closed identity map and this auth session has not claimed there yet. + * + * Multi-env: primary may be smart (no map) while secondary is t3vm (map on). + * Gate every environment that requires a claim, not only primary/active. + */ +export function IdentityClaimGate() { + const activeEnvironmentId = useActiveEnvironmentId(); + const primaryEnvironmentId = usePrimaryEnvironmentId(); + const { environments } = useEnvironments(); + const force = useForceClaimState(); + + const orderedEnvironmentIds = useMemo(() => { + const ids: EnvironmentId[] = []; + const add = (id: EnvironmentId | null | undefined) => { + if (id !== null && id !== undefined && !ids.includes(id)) { + ids.push(id); + } + }; + // Forced env first so settle/send errors open the right dialog. + add(force.environmentId); + add(activeEnvironmentId); + add(primaryEnvironmentId); + for (const environment of environments) { + add(environment.environmentId); + } + return ids; + }, [activeEnvironmentId, environments, force.environmentId, primaryEnvironmentId]); + + if (orderedEnvironmentIds.length === 0) { + return null; + } + + // One gate body per env (hooks). Only the first that needs claim / force + // renders a modal (others return null). + return ( + <> + {orderedEnvironmentIds.map((environmentId) => { + const label = + environments.find((env) => env.environmentId === environmentId)?.label ?? null; + const forceOpen = + force.open && (force.environmentId === null || force.environmentId === environmentId); + return ( + + ); + })} + + ); +} + +function IdentityClaimGateForEnvironment(props: { + readonly environmentId: EnvironmentId; + readonly environmentLabel: string | null; + readonly forceOpen: boolean; +}) { + const target = useMemo( + () => ({ environmentId: props.environmentId, input: {} as const }), + [props.environmentId], + ); + const snapshotQuery = useEnvironmentQuery(identityEnvironment.snapshot(target)); + const claimQuery = useEnvironmentQuery(identityEnvironment.sessionClaim(target)); + const claimCommand = useAtomCommand(identityEnvironment.claim, { + label: "identity-claim", + reportFailure: true, + }); + + const needsClaim = identityClaimRequired(snapshotQuery.data, claimQuery.data); + const [query, setQuery] = useState(""); + const [error, setError] = useState(null); + const [submitting, setSubmitting] = useState(false); + + const suggestions = useMemo(() => { + if (!snapshotQuery.data) return [] as ReadonlyArray; + return filterPeopleForTypeahead( + snapshotQuery.data.people, + query, + IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS, + ); + }, [query, snapshotQuery.data]); + + // Show when: map requires claim, or user forced open after a dispatch error. + // Keep showing while loading if forceOpen (so the error path isn't silent). + const showGate = + needsClaim || + (props.forceOpen && (needsClaim || snapshotQuery.isPending || snapshotQuery.data !== null)) || + (props.forceOpen && snapshotQuery.error !== null); + + if (!showGate) { + return null; + } + + // Still loading map/claim — block operate with a clear panel, not a toast. + if (snapshotQuery.isPending && snapshotQuery.data === null) { + return ( +
    +
    +

    + Checking identity… +

    +

    + Loading this server’s identity map before you can send turns. +

    +
    +
    + ); + } + + if (snapshotQuery.error !== null && snapshotQuery.data === null) { + return ( +
    +
    +

    + Could not load identity +

    +

    {snapshotQuery.error}

    +
    + +
    +
    +
    + ); + } + + if (!snapshotQuery.data?.enabled) { + // Map off on *this* env (e.g. smart). Do NOT clear forceOpen — a sibling + // env (t3vm) may still need the claim dialog. + return null; + } + + if (!needsClaim) { + // Already claimed on this env; clear force only when we targeted it. + if (props.forceOpen) clearForceClaimOpen(); + return null; + } + + const snapshot = snapshotQuery.data; + const envLabel = props.environmentLabel?.trim() || "this environment"; + + const submitUsername = async (username: string) => { + const normalized = username.trim().toLowerCase(); + if (normalized.length === 0) { + setError("Type your username, then pick a match from the list."); + return; + } + const exact = snapshot.people.find((person) => person.username === normalized); + if (!exact) { + setError("That identity is not on this server’s map. Keep typing to see matches."); + return; + } + setSubmitting(true); + setError(null); + try { + const result = await claimCommand({ + environmentId: props.environmentId, + input: { + username: IdentityUsername.make(exact.username), + method: "typeahead", + }, + }); + if (result._tag === "Failure") { + setError("Could not claim identity on this server."); + return; + } + claimQuery.refresh(); + snapshotQuery.refresh(); + clearForceClaimOpen(); + } catch (cause) { + setError(cause instanceof Error ? cause.message : "Could not claim identity."); + } finally { + setSubmitting(false); + } + }; + + return ( +
    +
    +

    + Shared environment · {envLabel} +

    +

    + Who are you? +

    +

    + {envLabel} uses a closed identity + map. Type at least {IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS} characters of your username (for + example pat + …), then choose a match. Free-form names are not allowed. +

    + + + { + setQuery(event.currentTarget.value); + setError(null); + }} + onKeyDown={(event) => { + if (event.key === "Enter") { + event.preventDefault(); + void submitUsername(query); + } + }} + /> + + {suggestions.length > 0 ? ( +
      + {suggestions.map((person) => ( +
    • + +
      • + ))} +
    + ) : query.trim().length >= IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS ? ( +

    No map matches for that query.

    + ) : ( +

    + Type {IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS}+ characters to search the map ( + {snapshot.people.length} people listed). +

    + )} + + {error ?

    {error}

    : null} + +
    + +
    +
    +
    + ); +} + +/** Detect dispatch / operate failures that mean the user must claim. */ +export function isIdentityClaimRequiredMessage(message: string | null | undefined): boolean { + if (!message) return false; + const lower = message.toLowerCase(); + return ( + lower.includes("identity_claim_required") || + lower.includes("choose who you are") || + lower.includes("identity claim") + ); +} diff --git a/apps/web/src/components/identity/ParticipantStack.logic.test.ts b/apps/web/src/components/identity/ParticipantStack.logic.test.ts new file mode 100644 index 000000000000..2f9e4af99ba0 --- /dev/null +++ b/apps/web/src/components/identity/ParticipantStack.logic.test.ts @@ -0,0 +1,28 @@ +import { IdentityUsername, PersonId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; +import { participantDisplayLabel } from "./ParticipantStack.logic"; + +describe("participantDisplayLabel", () => { + it("shows all devices for one person in first-seen order", () => { + expect( + participantDisplayLabel({ + personId: PersonId.make("patroza"), + username: IdentityUsername.make("patroza"), + firstChannel: "desktop", + channels: ["desktop", "discord"], + firstParticipatedAt: "2026-07-30T12:00:00.000Z", + }), + ).toBe("patroza@desktop,discord"); + }); + + it("supports summaries persisted before channel lists were added", () => { + expect( + participantDisplayLabel({ + personId: PersonId.make("patroza"), + username: IdentityUsername.make("patroza"), + firstChannel: "discord", + firstParticipatedAt: "2026-07-30T12:00:00.000Z", + }), + ).toBe("patroza@discord"); + }); +}); diff --git a/apps/web/src/components/identity/ParticipantStack.logic.ts b/apps/web/src/components/identity/ParticipantStack.logic.ts new file mode 100644 index 000000000000..0a2a90248106 --- /dev/null +++ b/apps/web/src/components/identity/ParticipantStack.logic.ts @@ -0,0 +1,7 @@ +import type { ThreadParticipantSummary } from "@t3tools/contracts"; + +export function participantDisplayLabel(person: ThreadParticipantSummary): string { + const channels = + person.channels ?? (person.firstChannel === undefined ? [] : [person.firstChannel]); + return channels.length === 0 ? person.username : `${person.username}@${channels.join(",")}`; +} diff --git a/apps/web/src/components/identity/ParticipantStack.tsx b/apps/web/src/components/identity/ParticipantStack.tsx new file mode 100644 index 000000000000..472f389ce468 --- /dev/null +++ b/apps/web/src/components/identity/ParticipantStack.tsx @@ -0,0 +1,183 @@ +import { useAtomValue } from "@effect/atom-react"; +import { + claimPersonIdForEnvironment, + isClaimedNonStarterParticipant, +} from "@t3tools/client-runtime/state/identity"; +import type { ThreadParticipantSummary } from "@t3tools/contracts"; +import { identityClaimPersonIdByEnvironmentAtom } from "../../state/identity"; +import { IdentityAvatar } from "./IdentityAvatar"; +import { participantDisplayLabel } from "./ParticipantStack.logic"; +import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; +import { cn } from "~/lib/utils"; + +/** + * Creator face + +N extras for thread list rows. + * Hover/focus expands remaining participants (design: participant stack). + */ +export function ParticipantStack(props: { + readonly environmentId: string; + readonly participants: ReadonlyArray; + readonly channel?: string | null | undefined; + readonly className?: string | undefined; + /** + * When false the stack is inert: no tab stop and no tooltip trigger. Drag + * clones are `aria-hidden`, and a focusable element inside one is reachable + * by keyboard while being hidden from assistive technology. + */ + readonly interactive?: boolean | undefined; +}) { + const people = props.participants; + const claimPersonIdByEnvironment = useAtomValue(identityClaimPersonIdByEnvironmentAtom); + const claimPersonId = claimPersonIdForEnvironment( + claimPersonIdByEnvironment, + props.environmentId, + ); + const youParticipated = isClaimedNonStarterParticipant({ + claimPersonId, + participants: people, + }); + if (people.length === 0) return null; + + const lead = people[0]!; + const extras = people.slice(1); + const label = + extras.length === 0 + ? `Started by ${lead.username}` + : `Started by ${lead.username}, ${extras.length} other participant${extras.length === 1 ? "" : "s"}`; + const accessibleLabel = youParticipated ? `${label}. You participated` : label; + + const stack = ( + + + + + + {extras.length > 0 ? ( + + +{extras.length} + + ) : null} + + ); + + return ( + + + + {people.map((person) => ( + + + + {participantDisplayLabel(person)} + {person.personId === claimPersonId ? ( + · You + ) : null} + + + ))} + + + ); +} + +export function SourceChannelGlyph(props: { + readonly channel: string | null | undefined; + readonly overlay?: boolean; + readonly className?: string | undefined; +}) { + if (!props.channel) return null; + const short = + props.channel === "desktop" + ? "D" + : props.channel === "web" + ? "W" + : props.channel === "mobile" + ? "M" + : props.channel === "discord" + ? "Δ" + : props.channel === "jira" + ? "J" + : props.channel === "github" + ? "G" + : props.channel.slice(0, 1).toUpperCase(); + return ( + + {short} + + ); +} + +/** + * Optional identity metadata for a thread row. It belongs after the flexible + * title so identity-capable and identity-unavailable hosts keep the same title + * alignment and row geometry. + */ +export function ThreadIdentityMark(props: { + readonly environmentId: string; + readonly originChannel?: string | null | undefined; + readonly participants?: ReadonlyArray | null | undefined; + readonly className?: string | undefined; + /** Pass false inside an aria-hidden clone; see {@link ParticipantStack}. */ + readonly interactive?: boolean | undefined; +}) { + const participants = props.participants ?? []; + const channel = props.originChannel ?? participants[0]?.firstChannel ?? null; + if (participants.length === 0) { + return ; + } + return ( + + ); +} diff --git a/apps/web/src/components/listEnvironmentFilter.test.ts b/apps/web/src/components/listEnvironmentFilter.test.ts new file mode 100644 index 000000000000..8306e08a8995 --- /dev/null +++ b/apps/web/src/components/listEnvironmentFilter.test.ts @@ -0,0 +1,112 @@ +import { EnvironmentId } from "@t3tools/contracts"; +import * as Schema from "effect/Schema"; +import { describe, expect, it } from "vite-plus/test"; + +import { + DEFAULT_HIDE_SETTLED_PROJECTS, + DEFAULT_HIDE_SETTLED_RECENT, + DEFAULT_SIDEBAR_OWNERSHIP_FILTER, + DEFAULT_SIDEBAR_V2_SETTLED_RECENCY_HEADERS, + DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED, + DEFAULT_WEB_LIST_MODE, + DEFAULT_WEB_THREAD_GROUPING, + LIST_HIDE_SETTLED_PROJECTS_STORAGE_KEY, + LIST_HIDE_SETTLED_RECENT_STORAGE_KEY, + parseSidebarOwnershipFilter, + SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY, + SIDEBAR_V2_SETTLED_RECENCY_HEADERS_STORAGE_KEY, + SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY, + WebListModeSchema, + defaultThreadGroupingFromLegacyModeStorage, + isAllEnvironmentsSelected, + matchesEnvironmentFilter, + resolveSelectedEnvironmentIds, + toggleEnvironmentId, + usesFlatThreadGrouping, + usesProjectThreadGrouping, +} from "./listEnvironmentFilter"; + +const envA = EnvironmentId.make("environment-a"); +const envB = EnvironmentId.make("environment-b"); +const decodeListMode = Schema.decodeUnknownSync(WebListModeSchema); + +describe("list environment multi-select", () => { + it("treats an empty selection as all environments", () => { + expect(matchesEnvironmentFilter(envA, [])).toBe(true); + expect(isAllEnvironmentsSelected([])).toBe(true); + }); + + it("starts a singleton selection when toggling from empty (all)", () => { + expect(toggleEnvironmentId([], envA)).toEqual([envA]); + }); + + it("adds and removes ids without collapsing back to empty until last deselect", () => { + expect(toggleEnvironmentId([envA], envB)).toEqual([envA, envB]); + expect(toggleEnvironmentId([envA, envB], envA)).toEqual([envB]); + }); + + it("drops selected ids that are no longer available", () => { + expect(resolveSelectedEnvironmentIds([envA, envB], new Set([envA]))).toEqual([envA]); + expect(resolveSelectedEnvironmentIds([], new Set([envA]))).toEqual([]); + }); +}); + +describe("threads list mode and grouping prefs", () => { + it("maps legacy recent/projects mode values onto the combined Threads surface", () => { + expect(decodeListMode("threads")).toBe("threads"); + expect(decodeListMode("board")).toBe("board"); + expect(decodeListMode("recent")).toBe("threads"); + expect(decodeListMode("projects")).toBe("threads"); + expect(DEFAULT_WEB_LIST_MODE).toBe("threads"); + }); + + it("migrates unset grouping from legacy mode storage", () => { + expect(defaultThreadGroupingFromLegacyModeStorage('"recent"')).toBe("recency"); + expect(defaultThreadGroupingFromLegacyModeStorage('"projects"')).toBe("project"); + expect(defaultThreadGroupingFromLegacyModeStorage(null)).toBe(DEFAULT_WEB_THREAD_GROUPING); + expect(DEFAULT_WEB_THREAD_GROUPING).toBe("project"); + }); + + it("classifies project vs flat groupings for hide-settled / shelf behavior", () => { + expect(usesProjectThreadGrouping("project")).toBe(true); + expect(usesProjectThreadGrouping("recency")).toBe(false); + expect(usesFlatThreadGrouping("recency")).toBe(true); + expect(usesFlatThreadGrouping("none")).toBe(true); + expect(usesFlatThreadGrouping("project")).toBe(false); + }); +}); + +describe("hide-settled and Sidebar V2 settled shelf defaults", () => { + it("hides settled by default on recency/none and shows them on project groups", () => { + expect(DEFAULT_HIDE_SETTLED_RECENT).toBe(true); + expect(DEFAULT_HIDE_SETTLED_PROJECTS).toBe(false); + expect(LIST_HIDE_SETTLED_RECENT_STORAGE_KEY).toBe("t3code:list:hide-settled-recent:v1"); + expect(LIST_HIDE_SETTLED_PROJECTS_STORAGE_KEY).toBe("t3code:list:hide-settled-projects:v1"); + }); + + it("keeps V2 settled recency headers and expanded shelf as defaults", () => { + expect(DEFAULT_SIDEBAR_V2_SETTLED_RECENCY_HEADERS).toBe(true); + expect(DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED).toBe(true); + expect(SIDEBAR_V2_SETTLED_RECENCY_HEADERS_STORAGE_KEY).toBe( + "t3code:sidebar-v2:settled-recency-headers:v1", + ); + expect(SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY).toBe( + "t3code:sidebar-v2:settled-shelf-expanded:v1", + ); + }); +}); + +describe("sidebar ownership filter prefs", () => { + it("defaults to Mine and shares storage key across v1/v2", () => { + expect(DEFAULT_SIDEBAR_OWNERSHIP_FILTER).toBe("mine"); + expect(SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY).toBe("t3.sidebar.ownershipFilter"); + }); + + it("parses stored values and falls back to Mine", () => { + expect(parseSidebarOwnershipFilter("any")).toBe("any"); + expect(parseSidebarOwnershipFilter("mine")).toBe("mine"); + expect(parseSidebarOwnershipFilter("theirs")).toBe("theirs"); + expect(parseSidebarOwnershipFilter(null)).toBe("mine"); + expect(parseSidebarOwnershipFilter("nope")).toBe("mine"); + }); +}); diff --git a/apps/web/src/components/listEnvironmentFilter.ts b/apps/web/src/components/listEnvironmentFilter.ts new file mode 100644 index 000000000000..a5a6f9af21ca --- /dev/null +++ b/apps/web/src/components/listEnvironmentFilter.ts @@ -0,0 +1,200 @@ +import type { EnvironmentId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; +import * as SchemaTransformation from "effect/SchemaTransformation"; + +/** + * Multi-select environment filter shared by Threads and Board. + * Empty selection means all environments. + */ +export function matchesEnvironmentFilter( + environmentId: EnvironmentId, + selectedEnvironmentIds: readonly EnvironmentId[], +): boolean { + return selectedEnvironmentIds.length === 0 || selectedEnvironmentIds.includes(environmentId); +} + +export function isAllEnvironmentsSelected( + selectedEnvironmentIds: readonly EnvironmentId[], +): boolean { + return selectedEnvironmentIds.length === 0; +} + +export function isEnvironmentSelected( + selectedEnvironmentIds: readonly EnvironmentId[], + environmentId: EnvironmentId, +): boolean { + return selectedEnvironmentIds.length === 0 || selectedEnvironmentIds.includes(environmentId); +} + +export function toggleEnvironmentId( + selectedEnvironmentIds: readonly EnvironmentId[], + environmentId: EnvironmentId, +): readonly EnvironmentId[] { + if (selectedEnvironmentIds.length === 0) { + return [environmentId]; + } + if (selectedEnvironmentIds.includes(environmentId)) { + return selectedEnvironmentIds.filter((id) => id !== environmentId); + } + return [...selectedEnvironmentIds, environmentId]; +} + +export function resolveSelectedEnvironmentIds( + selectedEnvironmentIds: readonly EnvironmentId[], + availableEnvironmentIds: ReadonlySet, +): readonly EnvironmentId[] { + if (selectedEnvironmentIds.length === 0) return selectedEnvironmentIds; + const next = selectedEnvironmentIds.filter((id) => availableEnvironmentIds.has(id)); + return next.length === selectedEnvironmentIds.length ? selectedEnvironmentIds : next; +} + +/** Main list surface: combined thread list vs Board. */ +export type WebListMode = "threads" | "board"; + +export const WEB_LIST_MODES = ["threads", "board"] as const satisfies readonly WebListMode[]; + +export const WEB_LIST_MODE_LABELS: Record = { + threads: "Threads", + board: "Board", +}; + +export function isWebListMode(value: unknown): value is WebListMode { + return value === "threads" || value === "board"; +} + +/** + * How the Threads list is organized. Shared by classic sidebar and Sidebar V2 + * (`LIST_THREAD_GROUPING_STORAGE_KEY`) so Recent / project / none stay aligned + * across the beta toggle. + * + * - `recency`: activity order + day buckets on the active list + * - `project`: classic nests by project; V2 exposes Default and keeps upstream order + * - `none`: activity order, flat (no day headers) + * + * Full compatibility contract: docs/sidebar-v2.md. Custom user groups are + * intentionally out of scope for the first cut. + */ +export type WebThreadGrouping = "recency" | "project" | "none"; + +export const WEB_THREAD_GROUPINGS = [ + "recency", + "project", + "none", +] as const satisfies readonly WebThreadGrouping[]; + +export const WEB_THREAD_GROUPING_LABELS: Record = { + recency: "Group by recency", + // `project` is the persisted legacy value. In Sidebar V1 it still renders + // project groups; Sidebar V2 interprets it as untouched upstream ordering. + project: "Group by default", + none: "Group by nothing", +}; + +export function isWebThreadGrouping(value: unknown): value is WebThreadGrouping { + return value === "recency" || value === "project" || value === "none"; +} + +export const LIST_ENVIRONMENT_FILTER_STORAGE_KEY = "t3code:list:environment-filter:v1"; +/** Persists surface mode. Legacy values `recent` / `projects` decode as `threads`. */ +export const LIST_MODE_STORAGE_KEY = "t3code:list:mode:v1"; +export const LIST_THREAD_GROUPING_STORAGE_KEY = "t3code:list:thread-grouping:v1"; +/** Sidebar Threads project scope; Board keeps its own storage key. */ +export const LIST_PROJECT_FILTER_STORAGE_KEY = "t3code:list:project-filter:v1"; +export const LIST_PROJECT_FILTER_ALL = "all"; +/** + * Per organization: when true, settled threads leave the main list. + * Classic recency/none shelves them in a collapsible Settled section (like V2); + * project groups still omit them from each project’s thread list. + * Recency/none default to hide (cleaner inbox); project groups default to show. + */ +export const LIST_HIDE_SETTLED_RECENT_STORAGE_KEY = "t3code:list:hide-settled-recent:v1"; +export const LIST_HIDE_SETTLED_PROJECTS_STORAGE_KEY = "t3code:list:hide-settled-projects:v1"; +export const DEFAULT_HIDE_SETTLED_RECENT = true; +export const DEFAULT_HIDE_SETTLED_PROJECTS = false; + +/** + * Mine / Theirs ownership filter shared by Sidebar v1 and v2 (and the same + * localStorage keys so switching sidebars keeps the selection). + * Default is Mine so the inbox focuses on work you started or joined. + */ +export const SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY = "t3.sidebar.ownershipFilter"; +export const SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY = "t3.sidebar.ownershipRelation"; +export type SidebarOwnershipFilter = "any" | "mine" | "theirs"; +export const DEFAULT_SIDEBAR_OWNERSHIP_FILTER: SidebarOwnershipFilter = "mine"; +export const SIDEBAR_OWNERSHIP_FILTERS = ["any", "mine", "theirs"] as const; +export const SIDEBAR_OWNERSHIP_FILTER_LABELS: Record = { + any: "Anyone", + mine: "Mine", + theirs: "Theirs", +}; +export const SIDEBAR_OWNERSHIP_RELATIONS = ["both", "created", "participated"] as const; +export const SIDEBAR_OWNERSHIP_RELATION_LABELS = { + both: "Created or participated", + created: "Created", + participated: "Participated", +} as const; + +export function parseSidebarOwnershipFilter( + raw: string | null | undefined, +): SidebarOwnershipFilter { + if (raw === "any" || raw === "mine" || raw === "theirs") return raw; + return DEFAULT_SIDEBAR_OWNERSHIP_FILTER; +} + +/** Sidebar V2: show Last Hour / Yesterday / … under Settled when multi-bucket. */ +export const SIDEBAR_V2_SETTLED_RECENCY_HEADERS_STORAGE_KEY = + "t3code:sidebar-v2:settled-recency-headers:v1"; +export const DEFAULT_SIDEBAR_V2_SETTLED_RECENCY_HEADERS = true; +/** Sidebar V2: settled shelf expanded vs collapsed (persists last toggle). */ +export const SIDEBAR_V2_SETTLED_SHELF_EXPANDED_STORAGE_KEY = + "t3code:sidebar-v2:settled-shelf-expanded:v1"; +export const DEFAULT_SIDEBAR_V2_SETTLED_SHELF_EXPANDED = true; + +/** Persisted env multi-select; empty array means all environments. */ +export const ListEnvironmentFilterSchema = Schema.Array(Schema.String); +export type ListEnvironmentFilterStored = typeof ListEnvironmentFilterSchema.Type; +export const EMPTY_LIST_ENVIRONMENT_FILTER: ListEnvironmentFilterStored = []; + +/** Persisted single project key, or null for all projects. */ +export const ListProjectFilterSchema = Schema.NullOr(Schema.String); +export type ListProjectFilterStored = typeof ListProjectFilterSchema.Type; + +export const ListHideSettledSchema = Schema.Boolean; + +/** Accepts legacy `recent` / `projects` and maps them to the combined Threads surface. */ +const WebListModeStored = Schema.Literals(["threads", "board", "recent", "projects"]); +export const WebListModeSchema = WebListModeStored.pipe( + Schema.decodeTo( + Schema.Literals(["threads", "board"]), + SchemaTransformation.transformOrFail({ + decode: (value) => + Effect.succeed(value === "board" ? ("board" as const) : ("threads" as const)), + encode: (value) => Effect.succeed(value), + }), + ), +); +export const DEFAULT_WEB_LIST_MODE: WebListMode = "threads"; + +export const WebThreadGroupingSchema = Schema.Literals(["recency", "project", "none"]); +export const DEFAULT_WEB_THREAD_GROUPING: WebThreadGrouping = "project"; + +/** + * When the grouping key is unset, map the legacy mode string so users who lived + * in Recent keep day buckets and Projects users keep project groups. + */ +export function defaultThreadGroupingFromLegacyModeStorage( + rawModeStorageValue: string | null, +): WebThreadGrouping { + if (rawModeStorageValue === '"recent"') return "recency"; + if (rawModeStorageValue === '"projects"') return "project"; + return DEFAULT_WEB_THREAD_GROUPING; +} + +export function usesProjectThreadGrouping(grouping: WebThreadGrouping): boolean { + return grouping === "project"; +} + +export function usesFlatThreadGrouping(grouping: WebThreadGrouping): boolean { + return grouping === "recency" || grouping === "none"; +} diff --git a/apps/web/src/components/ownershipFilter.test.ts b/apps/web/src/components/ownershipFilter.test.ts new file mode 100644 index 000000000000..32aad244d8d0 --- /dev/null +++ b/apps/web/src/components/ownershipFilter.test.ts @@ -0,0 +1,98 @@ +import { EnvironmentId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { buildOwnershipPredicate, type OwnershipFilterableThread } from "./ownershipFilter"; + +const environmentId = EnvironmentId.make("environment-local"); +const me = "person-me"; +const them = "person-them"; +const claims: ReadonlyMap = new Map([[environmentId, me]]); + +function thread( + originPersonId: string | null, + participantPersonIds: readonly string[] = [], +): OwnershipFilterableThread { + return { + environmentId, + originSource: { personId: originPersonId }, + participantSummaries: participantPersonIds.map((personId) => ({ personId })), + }; +} + +describe("buildOwnershipPredicate", () => { + it("keeps only my threads under mine", () => { + const predicate = buildOwnershipPredicate({ + claimPersonIdByEnvironment: claims, + mode: "mine", + relation: "both", + }); + + expect(predicate(thread(me))).toBe(true); + expect(predicate(thread(them, [me]))).toBe(true); + expect(predicate(thread(them))).toBe(false); + }); + + it("keeps only other people's threads under theirs", () => { + const predicate = buildOwnershipPredicate({ + claimPersonIdByEnvironment: claims, + mode: "theirs", + relation: "both", + }); + + expect(predicate(thread(them))).toBe(true); + expect(predicate(thread(me))).toBe(false); + }); + + it("keeps everything under any", () => { + const predicate = buildOwnershipPredicate({ + claimPersonIdByEnvironment: claims, + mode: "any", + relation: "both", + }); + + expect(predicate(thread(me))).toBe(true); + expect(predicate(thread(them))).toBe(true); + }); + + it("honours the created-only relation", () => { + const predicate = buildOwnershipPredicate({ + claimPersonIdByEnvironment: claims, + mode: "mine", + relation: "created", + }); + + expect(predicate(thread(me))).toBe(true); + // Participating is not creating. + expect(predicate(thread(them, [me]))).toBe(false); + }); + + it("reads attributed work as someone else's when the environment has no claim", () => { + // An environment with no identity claim (smart has no map while t3vm does) + // cannot match anyone, so attributed threads fall to Theirs. + const mine = buildOwnershipPredicate({ + claimPersonIdByEnvironment: undefined, + mode: "mine", + relation: "both", + }); + const theirs = buildOwnershipPredicate({ + claimPersonIdByEnvironment: undefined, + mode: "theirs", + relation: "both", + }); + + expect(mine(thread(them))).toBe(false); + expect(theirs(thread(them))).toBe(true); + }); + + it("keeps fully unattributed threads under mine", () => { + // Local work carries no person at all; hiding it under the default filter + // would empty the board for anyone not using identity claims. + const predicate = buildOwnershipPredicate({ + claimPersonIdByEnvironment: claims, + mode: "mine", + relation: "both", + }); + + expect(predicate(thread(null))).toBe(true); + }); +}); diff --git a/apps/web/src/components/ownershipFilter.ts b/apps/web/src/components/ownershipFilter.ts new file mode 100644 index 000000000000..191a46a39b36 --- /dev/null +++ b/apps/web/src/components/ownershipFilter.ts @@ -0,0 +1,140 @@ +/** + * The Mine / Theirs ownership filter, shared across every thread surface. + * + * The selection is a single user-level preference — "whose work am I looking + * at" — not a per-surface one, so the Sidebar and the Board read and write the + * same two keys and update together while both are on screen. + * + * The values are persisted as bare strings rather than JSON, which predates + * `useLocalStorage`'s codec. Re-encoding them would silently reset every + * existing selection back to the default, so this subscribes to the same + * change channel `useLocalStorage` uses while keeping the raw format. + * + * @module ownershipFilter + */ +import { + DEFAULT_OWNERSHIP_RELATION, + isOwnershipRelation, + threadMatchesMine, + claimPersonIdForEnvironment, + type OwnershipRelation, +} from "@t3tools/client-runtime/state/identity"; +import type { EnvironmentId } from "@t3tools/contracts"; +import { useCallback, useSyncExternalStore } from "react"; + +import { + dispatchLocalStorageChange, + LOCAL_STORAGE_CHANGE_EVENT, + type LocalStorageChangeDetail, +} from "~/hooks/useLocalStorage"; +import { + DEFAULT_SIDEBAR_OWNERSHIP_FILTER, + parseSidebarOwnershipFilter, + SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY, + SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY, + type SidebarOwnershipFilter, +} from "./listEnvironmentFilter"; + +function readRaw(key: string): string | null { + try { + return window.localStorage.getItem(key); + } catch { + return null; + } +} + +function writeRaw(key: string, value: string) { + try { + window.localStorage.setItem(key, value); + } catch { + // A storage failure must not take the menu down with it; the selection + // simply does not survive a reload. + } + dispatchLocalStorageChange(key); +} + +function subscribeToKey(key: string) { + return (onStoreChange: () => void) => { + const handleStorage = (event: StorageEvent) => { + if (event.key === key) onStoreChange(); + }; + const handleLocal = (event: CustomEvent) => { + if (event.detail.key === key) onStoreChange(); + }; + window.addEventListener("storage", handleStorage); + window.addEventListener(LOCAL_STORAGE_CHANGE_EVENT, handleLocal as EventListener); + return () => { + window.removeEventListener("storage", handleStorage); + window.removeEventListener(LOCAL_STORAGE_CHANGE_EVENT, handleLocal as EventListener); + }; + }; +} + +const subscribeToMode = subscribeToKey(SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY); +const subscribeToRelation = subscribeToKey(SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY); +const readMode = () => readRaw(SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY); +const readRelation = () => readRaw(SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY); +// Server render has no storage; both fall back to the documented defaults. +const readNothing = () => null; + +export interface OwnershipFilterState { + readonly mode: SidebarOwnershipFilter; + readonly relation: OwnershipRelation; + readonly setMode: (mode: SidebarOwnershipFilter) => void; + readonly setRelation: (relation: OwnershipRelation) => void; +} + +/** Reads the shared ownership selection and keeps every subscriber in step. */ +export function useOwnershipFilter(): OwnershipFilterState { + const rawMode = useSyncExternalStore(subscribeToMode, readMode, readNothing); + const rawRelation = useSyncExternalStore(subscribeToRelation, readRelation, readNothing); + + const setMode = useCallback((next: SidebarOwnershipFilter) => { + writeRaw(SIDEBAR_OWNERSHIP_FILTER_STORAGE_KEY, next); + }, []); + const setRelation = useCallback((next: OwnershipRelation) => { + writeRaw(SIDEBAR_OWNERSHIP_RELATION_STORAGE_KEY, next); + }, []); + + return { + mode: + rawMode === null ? DEFAULT_SIDEBAR_OWNERSHIP_FILTER : parseSidebarOwnershipFilter(rawMode), + relation: isOwnershipRelation(rawRelation) ? rawRelation : DEFAULT_OWNERSHIP_RELATION, + setMode, + setRelation, + }; +} + +const EMPTY_CLAIMS: ReadonlyMap = new Map(); + +/** The shape every thread surface already has to hand. */ +export interface OwnershipFilterableThread { + readonly environmentId: EnvironmentId; + readonly originSource?: { readonly personId?: string | null } | null | undefined; + readonly participantSummaries?: ReadonlyArray<{ readonly personId: string }> | undefined; +} + +/** + * Builds the ownership predicate once for a list pass. + * + * Every surface that lists threads must filter through this rather than + * re-deriving the call: the Board shipped without it and silently showed + * everyone's threads while the Sidebar beside it was filtered to Mine. + */ +export function buildOwnershipPredicate(input: { + readonly claimPersonIdByEnvironment: ReadonlyMap | undefined; + readonly mode: SidebarOwnershipFilter; + readonly relation: OwnershipRelation; +}): (thread: OwnershipFilterableThread) => boolean { + const claims = input.claimPersonIdByEnvironment ?? EMPTY_CLAIMS; + return (thread) => + threadMatchesMine({ + claimPersonId: claimPersonIdForEnvironment(claims, thread.environmentId), + originPersonId: thread.originSource?.personId ?? null, + participantPersonIds: (thread.participantSummaries ?? []).map( + (participant) => participant.personId, + ), + mode: input.mode, + relation: input.relation, + }); +} diff --git a/apps/web/src/components/preview/PreviewAutomationHosts.tsx b/apps/web/src/components/preview/PreviewAutomationHosts.tsx index d1fc12821730..84ef2b6fc600 100644 --- a/apps/web/src/components/preview/PreviewAutomationHosts.tsx +++ b/apps/web/src/components/preview/PreviewAutomationHosts.tsx @@ -30,7 +30,7 @@ import { updatePreviewServerSnapshot, } from "~/previewStateStore"; import { selectThreadPreviewMiniPlayer, usePreviewMiniPlayerStore } from "~/previewMiniPlayerStore"; -import { resolveBrowserNavigationTarget } from "~/browser/browserTargetResolver"; +import { resolveNavigableUrl } from "~/browser/browserTargetResolver"; import { readActiveBrowserRecordingTargets, startBrowserRecording, @@ -58,6 +58,7 @@ import { useAtomCommand } from "~/state/use-atom-command"; import { previewBridge } from "./previewBridge"; import { + PreviewAutomationNavigationTimeoutError, PreviewAutomationOperationError, PreviewAutomationOverlayTimeoutError, PreviewAutomationRecordingNotActiveError, @@ -71,10 +72,7 @@ import { shouldAutoShowPreviewForAutomationUse, shouldOpenPreviewMiniPlayer, } from "./previewAutomationOpenReadiness"; -import { - assertPreviewRuntimeCurrent, - waitForNavigationReadiness, -} from "./previewNavigationReadiness"; +import { assertPreviewRuntimeCurrent } from "./previewNavigationReadiness"; import { createPreviewAutomationRequestConsumerAtom } from "./previewAutomationRequestConsumer"; import { createPreviewAutomationClientId } from "./previewAutomationClientId"; import { @@ -84,17 +82,6 @@ import { } from "./previewAutomationTarget"; import { resolveHostWaitBudgetMs, waitForHostReadiness } from "./previewAutomationHostBudget"; import { isPreviewViewportReady } from "./previewViewportReadiness"; -import { shouldRollbackPreviewViewport } from "./previewViewportRollback"; - -const PREVIEW_PRESENTATION_SETTLE_TIMEOUT_MS = 500; - -const waitForPreviewPresentation = async (runtimeTabId: string): Promise => { - const deadline = Date.now() + PREVIEW_PRESENTATION_SETTLE_TIMEOUT_MS; - while (Date.now() <= deadline) { - if (useBrowserSurfaceStore.getState().byTabId[runtimeTabId]?.visible) return; - await new Promise((resolve) => window.setTimeout(resolve, 16)); - } -}; const waitForDesktopOverlay = async ( threadRef: ScopedThreadRef, @@ -125,6 +112,38 @@ const waitForDesktopOverlay = async ( }); }; +const waitForNavigationReadiness = async ( + threadRef: ScopedThreadRef, + requestId: string, + tabId: string, + readiness: PreviewAutomationNavigateInput["readiness"], + timeoutMs: number, +): Promise => { + const targetReadiness = readiness ?? "load"; + if (!previewBridge || targetReadiness === "none") return; + const deadline = Date.now() + timeoutMs; + while (Date.now() <= deadline) { + if (targetReadiness === "domContentLoaded") { + const readyState = await previewBridge.automation.evaluate(tabId, { + expression: "document.readyState", + }); + if (readyState === "interactive" || readyState === "complete") return; + } else { + const status = await previewBridge.automation.status(tabId); + if (!status.loading) return; + } + await new Promise((resolve) => window.setTimeout(resolve, 50)); + } + throw new PreviewAutomationNavigationTimeoutError({ + requestId, + environmentId: threadRef.environmentId, + threadId: threadRef.threadId, + tabId, + readiness: targetReadiness, + timeoutMs, + }); +}; + interface ExecutablePreviewWebview extends Element { readonly executeJavaScript: (code: string, userGesture?: boolean) => Promise; } @@ -157,10 +176,8 @@ const readWebviewViewport = async ( : null; }; -const readRenderedViewport = async ( - runtimeTabId: string, -): Promise => { - const webview = findPreviewWebview(runtimeTabId); +const readRenderedViewport = async (tabId: string): Promise => { + const webview = findPreviewWebview(tabId); if (!webview) return null; return await readWebviewViewport(webview); }; @@ -176,23 +193,19 @@ const readDeclaredViewport = ( }; const waitForRenderedViewport = async ( - threadRef: ScopedThreadRef, tabId: string, - runtimeTabId: string, setting: PreviewViewportSetting, timeoutMs: number, context: { readonly requestId: PreviewAutomationRequest["requestId"]; - readonly operation: PreviewAutomationRequest["operation"]; readonly environmentId: EnvironmentId; readonly threadId: PreviewAutomationRequest["threadId"]; }, ): Promise => { const deadline = Date.now() + timeoutMs; while (Date.now() <= deadline) { - assertPreviewRuntimeCurrent(threadRef, tabId, runtimeTabId, context); try { - const webview = findPreviewWebview(runtimeTabId); + const webview = findPreviewWebview(tabId); const appliedSettingKey = webview?.getAttribute("data-preview-viewport-key") ?? null; const declaredViewport = readDeclaredViewport(webview); const renderedViewport = webview ? await readWebviewViewport(webview) : null; @@ -402,10 +415,7 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId }) case "open": { const input = request.input as PreviewAutomationOpenInput; const resolvedInputUrl = input.url - ? resolveBrowserNavigationTarget(environmentId, { - kind: "url", - url: input.url, - }).resolvedUrl + ? await resolveNavigableUrl(environmentId, { kind: "url", url: input.url }) : undefined; let activeTabId = resolvePreviewAutomationOpenTab( state, @@ -512,22 +522,12 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId }) if (activeSnapshot && previewAutomationOpenNeedsOverlay(input, activeSnapshot)) { await requireReadyTab(); } - if (shouldPresentPreview) { - // React commits the thread-bound surface asynchronously. Settle - // briefly so active-thread opens report visible=true, without - // turning a background thread's offscreen mini player into an - // operation failure. - await waitForPreviewPresentation(activeRuntimeTabId); - } if (reusedExistingTab && resolvedInputUrl && previewBridge) { - assertPreviewRuntimeCurrent(threadRef, activeTabId, activeRuntimeTabId, request); - await previewBridge.navigate(activeRuntimeTabId, resolvedInputUrl); + await previewBridge.navigate(activeTabId, resolvedInputUrl); await waitForNavigationReadiness( threadRef, request.requestId, activeTabId, - activeRuntimeTabId, - request.operation, "load", request.timeoutMs, ); @@ -537,20 +537,18 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId }) case "navigate": { const ready = await requireReadyTab(); const input = request.input as PreviewAutomationNavigateInput; - const resolution = resolveBrowserNavigationTarget( + const resolvedUrl = await resolveNavigableUrl( environmentId, input.target ?? { kind: "url", url: input.url!, }, ); - await ready.bridge.navigate(ready.runtimeTabId, resolution.resolvedUrl); + await ready.bridge.navigate(ready.tabId, resolvedUrl); await waitForNavigationReadiness( threadRef, request.requestId, ready.tabId, - ready.runtimeTabId, - request.operation, input.readiness ?? "load", input.timeoutMs ?? request.timeoutMs, ); @@ -560,76 +558,28 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId }) const ready = await requireReadyTab(); const input = request.input as PreviewAutomationResizeInput; const setting = resolvePreviewViewport(input); - const applied = await runBrowserViewportMutation(ready.runtimeTabId, async () => { - const operationState = assertPreviewRuntimeCurrent( - threadRef, - ready.tabId, - ready.runtimeTabId, - request, - ); - const previousSetting = - operationState.sessions[ready.tabId]?.viewport ?? FILL_PREVIEW_VIEWPORT; - const result = await resize({ - environmentId, - input: { - threadId: request.threadId, - tabId: ready.tabId, - viewport: setting, - }, - }); - if (result._tag === "Failure") { - return raiseAtomCommandFailure(result); - } - updatePreviewServerSnapshot(threadRef, result.value); - return { - previousSetting, - serverEpoch: operationState.serverEpoch, - }; + const result = await resize({ + environmentId, + input: { + threadId: request.threadId, + tabId: ready.tabId, + viewport: setting, + }, }); - let viewport: PreviewRenderedViewportSize; - try { - viewport = await waitForRenderedViewport( - threadRef, - ready.tabId, - ready.runtimeTabId, - setting, - input.timeoutMs ?? request.timeoutMs, - { - requestId: request.requestId, - operation: request.operation, - environmentId, - threadId: request.threadId, - }, - ); - } catch (cause) { - await runBrowserViewportMutation(ready.runtimeTabId, async () => { - const latestState = readThreadPreviewState(threadRef); - const latestSetting = - latestState.sessions[ready.tabId]?.viewport ?? FILL_PREVIEW_VIEWPORT; - if ( - shouldRollbackPreviewViewport( - applied.previousSetting, - setting, - latestSetting, - applied.serverEpoch, - latestState.serverEpoch, - ) - ) { - const rollback = await resize({ - environmentId, - input: { - threadId: request.threadId, - tabId: ready.tabId, - viewport: applied.previousSetting, - }, - }); - if (rollback._tag !== "Failure") { - updatePreviewServerSnapshot(threadRef, rollback.value); - } - } - }); - throw cause; + if (result._tag === "Failure") { + return raiseAtomCommandFailure(result); } + updatePreviewServerSnapshot(threadRef, result.value); + const viewport = await waitForRenderedViewport( + ready.tabId, + setting, + input.timeoutMs ?? request.timeoutMs, + { + requestId: request.requestId, + environmentId, + threadId: request.threadId, + }, + ); return { tabId: ready.tabId, setting, @@ -639,7 +589,7 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId }) case "setColorScheme": { const ready = await requireReadyTab(); const input = request.input as PreviewAutomationSetColorSchemeInput; - await ready.bridge.setColorScheme(ready.runtimeTabId, input.colorScheme); + await ready.bridge.setColorScheme(ready.tabId, input.colorScheme); return { tabId: ready.tabId, colorScheme: input.colorScheme, @@ -647,57 +597,53 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId }) } case "snapshot": { const ready = await requireReadyTab(); - return await ready.bridge.automation.snapshot(ready.runtimeTabId); + return await ready.bridge.automation.snapshot(ready.tabId); } case "click": { const ready = await requireReadyTab(); return await ready.bridge.automation.click( - ready.runtimeTabId, + ready.tabId, request.input as Parameters[1], ); } case "type": { const ready = await requireReadyTab(); return await ready.bridge.automation.type( - ready.runtimeTabId, + ready.tabId, request.input as Parameters[1], ); } case "press": { const ready = await requireReadyTab(); return await ready.bridge.automation.press( - ready.runtimeTabId, + ready.tabId, request.input as Parameters[1], ); } case "scroll": { const ready = await requireReadyTab(); return await ready.bridge.automation.scroll( - ready.runtimeTabId, + ready.tabId, request.input as Parameters[1], ); } case "evaluate": { const ready = await requireReadyTab(); return await ready.bridge.automation.evaluate( - ready.runtimeTabId, + ready.tabId, request.input as Parameters[1], ); } case "waitFor": { const ready = await requireReadyTab(); return await ready.bridge.automation.waitFor( - ready.runtimeTabId, + ready.tabId, request.input as Parameters[1], ); } case "recordingStart": { const ready = await requireReadyTab(); - const startedAt = await startBrowserRecording( - ready.runtimeTabId, - threadRef, - ready.tabId, - ); + const startedAt = await startBrowserRecording(ready.tabId, threadRef); return { tabId: ready.tabId, recording: true, diff --git a/apps/web/src/components/preview/PreviewView.test.tsx b/apps/web/src/components/preview/PreviewView.test.tsx index 2a146834012e..3679eb924b23 100644 --- a/apps/web/src/components/preview/PreviewView.test.tsx +++ b/apps/web/src/components/preview/PreviewView.test.tsx @@ -15,6 +15,12 @@ const mocks = vi.hoisted(() => ({ navigate: vi.fn(async (_tabId: string, _url: string): Promise => undefined), rememberPreviewUrl: vi.fn(), readPreparedConnection: vi.fn(() => ({ httpBaseUrl: "http://172.25.85.75:3773" })), + // Reachability is the resolver's job and is covered by its own tests; here it + // stands in for "whatever the environment says is reachable". + resolveNavigableUrl: vi.fn( + async (_environmentId: string, target: { readonly url?: string }): Promise => + (target.url ?? "").replace("localhost", "172.25.85.75"), + ), submittedUrl: null as ((url: string) => void) | null, emptyStateUrl: null as ((url: string) => void) | null, togglePictureInPicture: null as (() => void) | null, @@ -252,6 +258,10 @@ vi.mock("./AgentBrowserCursor", () => ({ AgentBrowserCursor: () => null })); vi.mock("~/browser/BrowserSurfaceSlot", () => ({ BrowserSurfaceSlot: () => null })); vi.mock("./usePreviewSession", () => ({ usePreviewSession: vi.fn() })); +vi.mock("~/browser/browserTargetResolver", () => ({ + resolveNavigableUrl: mocks.resolveNavigableUrl, +})); + import { PreviewView } from "./PreviewView"; import { toastManager } from "~/components/ui/toast"; import { previewRuntimeTabId } from "~/browser/previewRuntimeTabId"; @@ -329,6 +339,7 @@ describe("PreviewView navigation", () => { mocks.navigate.mockClear(); mocks.rememberPreviewUrl.mockClear(); mocks.readPreparedConnection.mockClear(); + mocks.resolveNavigableUrl.mockClear(); mocks.submittedUrl = null; mocks.emptyStateUrl = null; mocks.togglePictureInPicture = null; @@ -381,13 +392,16 @@ describe("PreviewView navigation", () => { } }); + // A typed localhost URL means "the dev server on the environment host", so it + // goes through the same reachability resolution as a clicked port. Typing it + // used to navigate verbatim, which cannot work from a remote client. it.each([ [ "https://localhost:8000/dashboard?mode=test#top", - "https://localhost:8000/dashboard?mode=test#top", + "https://172.25.85.75:8000/dashboard?mode=test#top", ], - ["localhost:5173/app", "http://localhost:5173/app"], - ])("preserves a direct localhost URL in a WSL environment", async (submitted, expected) => { + ["localhost:5173/app", "http://172.25.85.75:5173/app"], + ])("resolves a submitted localhost URL against the environment", async (submitted, expected) => { renderToStaticMarkup( { ); }); + it("resolves an empty-state localhost server against the environment", async () => { + mocks.showEmptyState = true; + renderToStaticMarkup( + , + ); + + expect(mocks.emptyStateUrl).not.toBeNull(); + mocks.emptyStateUrl?.("http://localhost:5173/app?mode=test#top"); + + await vi.waitFor(() => + expect(mocks.navigate).toHaveBeenCalledWith( + TEST_RUNTIME_TAB_ID, + "http://172.25.85.75:5173/app?mode=test#top", + ), + ); + expect(mocks.rememberPreviewUrl).toHaveBeenCalledWith( + { + environmentId: "environment-1", + threadId: "thread-1", + }, + "http://172.25.85.75:5173/app?mode=test#top", + ); + }); + it("records a history visit with the normalized requested url on submit", async () => { renderToStaticMarkup( { try { const normalized = normalizePreviewUrl(next); - if (await navigateToResolvedUrl(normalized)) { + if ( + await navigateToResolvedUrl( + await resolveNavigableUrl(threadRef.environmentId, { kind: "url", url: normalized }), + ) + ) { recordVisitForThread(threadRef, normalized); } } catch { @@ -222,8 +226,11 @@ export function PreviewView({ const handleOpenServerUrl = useCallback( async (next: string) => { try { - const resolved = resolveDiscoveredServerUrl(threadRef.environmentId, next); - if (await navigateToResolvedUrl(resolved)) { + if ( + await navigateToResolvedUrl( + await resolveNavigableUrl(threadRef.environmentId, { kind: "url", url: next }), + ) + ) { recordVisitForThread(threadRef, next); } } catch { diff --git a/apps/web/src/components/projectScriptEditor.tsx b/apps/web/src/components/projectScriptEditor.tsx index 4ffd453955e9..8f14985469d9 100644 --- a/apps/web/src/components/projectScriptEditor.tsx +++ b/apps/web/src/components/projectScriptEditor.tsx @@ -78,6 +78,8 @@ export interface NewProjectScriptInput { command: string; icon: ProjectScriptIcon; runOnWorktreeCreate: boolean; + runOnWorktreeRemove: boolean; + runOnPrMerged: boolean; keybinding: string | null; /** Optional URL to open in the in-app preview when this script runs. */ previewUrl: string | null; @@ -92,6 +94,8 @@ export const EMPTY_PROJECT_SCRIPT_INPUT: NewProjectScriptInput = { command: "", icon: "play", runOnWorktreeCreate: false, + runOnWorktreeRemove: false, + runOnPrMerged: false, keybinding: null, previewUrl: null, autoOpenPreview: false, @@ -116,6 +120,8 @@ export function editorRequestForScript( command: script.command, icon: script.icon, runOnWorktreeCreate: script.runOnWorktreeCreate, + runOnWorktreeRemove: script.runOnWorktreeRemove === true, + runOnPrMerged: script.runOnPrMerged === true, keybinding: keybindingValueForCommand(keybindings, commandForProjectScript(script.id)), previewUrl: script.previewUrl ?? null, autoOpenPreview: script.autoOpenPreview ?? false, @@ -151,6 +157,8 @@ export function ProjectScriptEditorDialog({ const [icon, setIcon] = useState("play"); const [iconPickerOpen, setIconPickerOpen] = useState(false); const [runOnWorktreeCreate, setRunOnWorktreeCreate] = useState(false); + const [runOnWorktreeRemove, setRunOnWorktreeRemove] = useState(false); + const [runOnPrMerged, setRunOnPrMerged] = useState(false); const [keybinding, setKeybinding] = useState(""); const [previewUrl, setPreviewUrl] = useState(""); const [autoOpenPreview, setAutoOpenPreview] = useState(false); @@ -167,7 +175,12 @@ export function ProjectScriptEditorDialog({ setCommand(request.initial.command); setIcon(request.initial.icon); setIconPickerOpen(false); + // A confirm left open from the previous request would name that script + // while deleting this one. + setDeleteConfirmOpen(false); setRunOnWorktreeCreate(request.initial.runOnWorktreeCreate); + setRunOnWorktreeRemove(request.initial.runOnWorktreeRemove); + setRunOnPrMerged(request.initial.runOnPrMerged); setKeybinding(request.initial.keybinding ?? ""); setPreviewUrl(request.initial.previewUrl ?? ""); setAutoOpenPreview(request.initial.autoOpenPreview); @@ -219,6 +232,8 @@ export function ProjectScriptEditorDialog({ command: trimmedCommand, icon, runOnWorktreeCreate, + runOnWorktreeRemove, + runOnPrMerged, keybinding: keybindingRule?.key ?? null, previewUrl: trimmedPreviewUrl.length > 0 ? trimmedPreviewUrl : null, autoOpenPreview: trimmedPreviewUrl.length > 0 ? autoOpenPreview : false, @@ -352,6 +367,20 @@ export function ProjectScriptEditorDialog({ onCheckedChange={(checked) => setRunOnWorktreeCreate(Boolean(checked))} /> + +
    ) : null} + {serverUpdateState.status !== "idle" ? (
    diff --git a/apps/web/src/components/settings/DiagnosticsSettings.tsx b/apps/web/src/components/settings/DiagnosticsSettings.tsx index ec3bf854d7b0..30a8d9f46146 100644 --- a/apps/web/src/components/settings/DiagnosticsSettings.tsx +++ b/apps/web/src/components/settings/DiagnosticsSettings.tsx @@ -34,6 +34,7 @@ import { import { shellEnvironment } from "../../state/shell"; import { usePrimaryEnvironment } from "../../state/environments"; import { useCopyToClipboard } from "../../hooks/useCopyToClipboard"; +import { HostResourceStatus } from "../HostResourceStatus"; import { Button } from "../ui/button"; import { ScrollArea } from "../ui/scroll-area"; import { Toggle, ToggleGroup } from "../ui/toggle-group"; @@ -948,7 +949,7 @@ export function DiagnosticsSettingsPanel() { clearSignaling(); } }, - [refreshProcesses, signalServerProcess], + [environmentId, refreshProcesses, signalServerProcess], ); const processDiagnosticsError = processData ? Option.getOrNull(processData.error) : null; @@ -962,6 +963,23 @@ export function DiagnosticsSettingsPanel() { + {primaryEnvironment ? ( + +
    + +

    + Advisory system-wide metrics from the host running this T3 server. They do not affect + connection or provider readiness. +

    +
    +     + ) : null} { it("formats static and project script command labels", () => { expect(commandLabel("commandPalette.toggle")).toBe("Command Palette: Toggle"); + expect(commandLabel("editor.openFavorite")).toBe("Open in Preferred Application"); expect(commandLabel("themeEditor.toggle")).toBe("Theme Editor: Toggle"); expect(commandLabel("script.setup-db.run")).toBe("Run Script: Setup Db"); }); diff --git a/apps/web/src/components/settings/KeybindingsSettings.logic.ts b/apps/web/src/components/settings/KeybindingsSettings.logic.ts index 65589d1bcd9f..1dcde6ed55af 100644 --- a/apps/web/src/components/settings/KeybindingsSettings.logic.ts +++ b/apps/web/src/components/settings/KeybindingsSettings.logic.ts @@ -276,6 +276,7 @@ export function buildKeybindingCommandOptions( export function commandLabel(command: KeybindingCommand): string { const raw = String(command); + if (raw === "editor.openFavorite") return "Open in Preferred Application"; if (raw.startsWith("script.") && raw.endsWith(".run")) { return `Run Script: ${titleCaseCommandSegment(raw.slice("script.".length, -".run".length))}`; } diff --git a/apps/web/src/components/settings/ProjectSettingsPanel.tsx b/apps/web/src/components/settings/ProjectSettingsPanel.tsx index d88644fb7e3c..08e22d328491 100644 --- a/apps/web/src/components/settings/ProjectSettingsPanel.tsx +++ b/apps/web/src/components/settings/ProjectSettingsPanel.tsx @@ -55,6 +55,7 @@ import { } from "../../lib/projectScriptKeybindings"; import { buildProjectScript, + clearConflictingLifecycleFlags, commandForProjectScript, nextProjectScriptId, } from "../../projectScripts"; @@ -773,6 +774,8 @@ function ProjectDetail({ command: fileScript.command, icon: fileScript.icon ?? "play", runOnWorktreeCreate: fileScript.runOnWorktreeCreate ?? false, + runOnWorktreeRemove: fileScript.runOnWorktreeRemove ?? false, + runOnPrMerged: fileScript.runOnPrMerged ?? false, keybinding: null, previewUrl: fileScript.previewUrl ?? null, autoOpenPreview: fileScript.previewUrl ? (fileScript.autoOpenPreview ?? false) : false, diff --git a/apps/web/src/components/settings/ProviderModelsSection.tsx b/apps/web/src/components/settings/ProviderModelsSection.tsx index 505a86ff0eac..cdfdee05a2ff 100644 --- a/apps/web/src/components/settings/ProviderModelsSection.tsx +++ b/apps/web/src/components/settings/ProviderModelsSection.tsx @@ -27,6 +27,7 @@ const CUSTOM_MODEL_PLACEHOLDER_BY_KIND: Partial Version - {APP_VERSION} + {version} ); } @@ -574,6 +576,9 @@ export function useSettingsRestore(onRestored?: () => void) { ...(settings.addProjectBaseDirectory !== DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory ? ["Add project base directory"] : []), + ...(settings.terminalShell !== DEFAULT_UNIFIED_SETTINGS.terminalShell + ? ["Terminal shell"] + : []), ...(settings.confirmThreadUnpin !== DEFAULT_UNIFIED_SETTINGS.confirmThreadUnpin ? ["Unpin confirmation"] : []), @@ -583,6 +588,9 @@ export function useSettingsRestore(onRestored?: () => void) { ...(settings.confirmThreadDelete !== DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete ? ["Delete confirmation"] : []), + ...(settings.confirmWorktreeRemoval !== DEFAULT_UNIFIED_SETTINGS.confirmWorktreeRemoval + ? ["Worktree remove confirmation"] + : []), ...(settings.confirmQuit !== DEFAULT_UNIFIED_SETTINGS.confirmQuit ? ["Quit shortcut"] : []), ...(isTextGenerationModelDirty ? ["Text generation model"] : []), ...getChangedBrowserSettingLabels(settings), @@ -605,9 +613,11 @@ export function useSettingsRestore(onRestored?: () => void) { settings.confirmQuit, settings.confirmThreadArchive, settings.confirmThreadDelete, + settings.confirmWorktreeRemoval, settings.confirmThreadUnpin, settings.composerCollapseOnScroll, settings.addProjectBaseDirectory, + settings.terminalShell, settings.defaultThreadEnvMode, settings.newWorktreesStartFromOrigin, settings.diffIgnoreWhitespace, @@ -731,8 +741,10 @@ export function useSettingsRestore(onRestored?: () => void) { defaultThreadEnvMode: DEFAULT_UNIFIED_SETTINGS.defaultThreadEnvMode, newWorktreesStartFromOrigin: DEFAULT_UNIFIED_SETTINGS.newWorktreesStartFromOrigin, addProjectBaseDirectory: DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory, + terminalShell: DEFAULT_UNIFIED_SETTINGS.terminalShell, confirmThreadArchive: DEFAULT_UNIFIED_SETTINGS.confirmThreadArchive, confirmThreadDelete: DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete, + confirmWorktreeRemoval: DEFAULT_UNIFIED_SETTINGS.confirmWorktreeRemoval, confirmThreadUnpin: DEFAULT_UNIFIED_SETTINGS.confirmThreadUnpin, confirmQuit: DEFAULT_UNIFIED_SETTINGS.confirmQuit, textGenerationModelSelection: DEFAULT_UNIFIED_SETTINGS.textGenerationModelSelection, @@ -2452,7 +2464,7 @@ export function GeneralSettingsPanel() { + + updateSettings({ + terminalShell: DEFAULT_UNIFIED_SETTINGS.terminalShell, + }) + } + /> + ) : null + } + control={ + updateSettings({ terminalShell: next })} + placeholder="/bin/zsh" + spellCheck={false} + aria-label="Terminal shell" + /> + } + /> + + + updateSettings({ + confirmWorktreeRemoval: DEFAULT_UNIFIED_SETTINGS.confirmWorktreeRemoval, + }) + } + /> + ) : null + } + control={ + + updateSettings({ confirmWorktreeRemoval: Boolean(checked) }) + } + aria-label="Confirm worktree removal" + /> + } + /> + { it("matches normalized title substrings", () => { expect(searchSettings(" WORD WRAP ", ITEMS).map((item) => item.id)).toEqual(["word-wrap"]); + // "work" is not a substring of "word wrap". The full catalog matches the + // fork's "Worktree remove confirmation" (and not Word wrap). Upstream's + // project workspace setting left this catalog with #5923, which moved + // project settings onto contextual project routes. + expect( + searchSettings("work", [{ id: "word-wrap", title: "Word wrap", to: "/settings/appearance" }]), + ).toEqual([]); + expect(searchSettings("work").map((item) => item.id)).toEqual([ + "worktree-remove-confirmation", + "network-access", + "project-defaults", + "environment-identification", + "continue-threads-after-server-update", + "new-threads", + "start-from-origin", + ]); + expect(searchSettings("deploy").map((item) => item.id)).toContain( + "continue-threads-after-server-update", + ); expect(searchSettings("glass").map((item) => item.id)).toEqual(["setting-glass-opacity"]); expect(searchSettings("panel animations").map((item) => item.id)).toEqual(["panel-animations"]); expect(searchSettings("thè\u{1ab0}mes")[0]?.id).toBe("theme"); @@ -98,6 +117,7 @@ describe("searchSettings", () => { "unpin-confirmation", "archive-confirmation", "delete-confirmation", + "worktree-remove-confirmation", ]); }); diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.ts index f56579990714..532a9423ebf6 100644 --- a/apps/web/src/components/settings/settingsSearch.ts +++ b/apps/web/src/components/settings/settingsSearch.ts @@ -237,7 +237,7 @@ export const SETTINGS_SEARCH_ITEMS = [ title: "Continue threads after restarts", to: "/settings/general", searchTerms: [ - "resume running active interrupted work restart reboot machine crash desktop update automatically", + "resume running active interrupted work restart reboot machine crash desktop update automatically deploy", ], }, { @@ -284,6 +284,11 @@ export const SETTINGS_SEARCH_ITEMS = [ to: "/settings/general", searchTerms: ["ask before thread chat history"], }, + { + id: "worktree-remove-confirmation", + title: "Worktree remove confirmation", + to: "/settings/general", + }, { id: "quit-confirmation", title: "Quit shortcut", diff --git a/apps/web/src/components/sidebar/SidebarUpdatePill.tsx b/apps/web/src/components/sidebar/SidebarUpdatePill.tsx index a94b7801ecfd..4c4a66e56c33 100644 --- a/apps/web/src/components/sidebar/SidebarUpdatePill.tsx +++ b/apps/web/src/components/sidebar/SidebarUpdatePill.tsx @@ -19,7 +19,6 @@ import { shouldShowArm64IntelBuildWarning, shouldToastDesktopUpdateActionResult, } from "../desktopUpdate.logic"; -import { showDesktopUpdateDownloadedToast } from "../desktopUpdate.toast"; import { Alert, AlertDescription, AlertTitle } from "../ui/alert"; import { Popover, PopoverCreateHandle, PopoverPopup, PopoverTrigger } from "../ui/popover"; import { SidebarMenuItem } from "../ui/sidebar"; @@ -185,7 +184,11 @@ function SidebarUpdateControl() { .downloadUpdate() .then((result) => { if (result.completed) { - showDesktopUpdateDownloadedToast(bridge, result.state); + toastManager.add({ + type: "success", + title: "Update downloaded", + description: "Restart the app from the update button to install it.", + }); } if (!shouldToastDesktopUpdateActionResult(result)) return; const actionError = getDesktopUpdateActionError(result); diff --git a/apps/web/src/components/ui/errorDetailText.test.ts b/apps/web/src/components/ui/errorDetailText.test.ts new file mode 100644 index 000000000000..01dcb7cee53e --- /dev/null +++ b/apps/web/src/components/ui/errorDetailText.test.ts @@ -0,0 +1,26 @@ +import { assert, describe, it } from "vite-plus/test"; + +import { + ERROR_DETAIL_CLAMP_MIN_CHARS, + errorDetailClampClassName, + errorDetailShouldClamp, +} from "./errorDetailText"; + +describe("errorDetailShouldClamp", () => { + it("does not clamp short messages", () => { + assert.equal(errorDetailShouldClamp("a".repeat(ERROR_DETAIL_CLAMP_MIN_CHARS - 1)), false); + }); + + it("clamps long messages", () => { + assert.equal(errorDetailShouldClamp("a".repeat(ERROR_DETAIL_CLAMP_MIN_CHARS)), true); + }); +}); + +describe("errorDetailClampClassName", () => { + it("returns responsive clamps only when needed", () => { + assert.equal(errorDetailClampClassName(false), undefined); + const clampClass = errorDetailClampClassName(true); + assert.ok(clampClass?.includes("line-clamp-4")); + assert.ok(clampClass?.includes("sm:line-clamp-6")); + }); +}); diff --git a/apps/web/src/components/ui/errorDetailText.tsx b/apps/web/src/components/ui/errorDetailText.tsx new file mode 100644 index 000000000000..5e8dd18dffbd --- /dev/null +++ b/apps/web/src/components/ui/errorDetailText.tsx @@ -0,0 +1,112 @@ +"use client"; + +import { CheckIcon, CopyIcon } from "lucide-react"; +import type { ReactNode } from "react"; + +import { useCopyToClipboard } from "~/hooks/useCopyToClipboard"; +import { cn } from "~/lib/utils"; + +import { Tooltip, TooltipPopup, TooltipTrigger } from "./tooltip"; + +/** Long bodies get a responsive clamp in-card; shorter text stays fully visible. */ +export const ERROR_DETAIL_CLAMP_MIN_CHARS = 120; + +export const ERROR_DETAIL_TOOLTIP_CLASS = + "max-w-[min(calc(var(--available-width)-1rem),36rem)] whitespace-pre-wrap text-xs leading-relaxed"; + +export function errorDetailShouldClamp( + text: string, + minChars = ERROR_DETAIL_CLAMP_MIN_CHARS, +): boolean { + return text.length >= minChars; +} + +export function errorDetailClampClassName(shouldClamp: boolean): string | undefined { + if (!shouldClamp) { + return undefined; + } + return "line-clamp-4 sm:line-clamp-6 lg:line-clamp-[10]"; +} + +export function ErrorDetailCopyButton({ text, className }: { text: string; className?: string }) { + const { copyToClipboard, isCopied } = useCopyToClipboard({ target: "error-message" }); + const label = isCopied ? "Copied error" : "Copy error"; + + return ( + + copyToClipboard(text)} + type="button" + /> + } + > + {isCopied ? ( + + ) : ( + + )} + + {label} + + ); +} + +export function ErrorDetailText({ + text, + className, + textClassName, + showCopy = true, + tooltipSide = "top", +}: { + text: string; + className?: string; + textClassName?: string; + showCopy?: boolean; + tooltipSide?: "top" | "bottom" | "left" | "right"; +}) { + const shouldClamp = errorDetailShouldClamp(text); + const clampClassName = errorDetailClampClassName(shouldClamp); + + const body: ReactNode = ( + + {text} + + ); + + const textBlock = shouldClamp ? ( + + }> + {body} + + + {text} + + + ) : ( +
    {body}
    + ); + + if (!showCopy) { + return
    {textBlock}
    ; + } + + return ( +
    + {textBlock} + +
    + ); +} diff --git a/apps/web/src/components/ui/scroll-area.tsx b/apps/web/src/components/ui/scroll-area.tsx index 852a3ed10053..16e2ff0179b7 100644 --- a/apps/web/src/components/ui/scroll-area.tsx +++ b/apps/web/src/components/ui/scroll-area.tsx @@ -29,6 +29,7 @@ function ScrollArea({ scrollbarGutter = false, hideScrollbars = false, chainVerticalScroll = false, + chainHorizontalScroll = false, ...props }: ScrollAreaPrimitive.Root.Props & { scrollFade?: boolean; @@ -38,6 +39,7 @@ function ScrollArea({ scrollbarGutter?: boolean; hideScrollbars?: boolean; chainVerticalScroll?: boolean; + chainHorizontalScroll?: boolean; }) { return ( { it("hides non-front toasts until the stack is expanded", () => { assert.equal(shouldHideCollapsedToastContent(1, 3), true); }); + + it("keeps error toasts readable even when they are not front-most", () => { + assert.equal(shouldHideCollapsedToastContent(2, 4, "error"), false); + }); }); describe("buildVisibleToastLayout", () => { diff --git a/apps/web/src/components/ui/toast.logic.ts b/apps/web/src/components/ui/toast.logic.ts index 62c1a8af792d..f6dd2b1e2cf6 100644 --- a/apps/web/src/components/ui/toast.logic.ts +++ b/apps/web/src/components/ui/toast.logic.ts @@ -19,7 +19,10 @@ export function hasVisibleToastAction(actionProps: unknown): boolean { export function shouldHideCollapsedToastContent( visibleToastIndex: number, visibleToastCount: number, + toastType?: string, ): boolean { + // Errors must stay legible even when they are not the front-most toast in the stack. + if (toastType === "error") return false; // Keep the front-most toast readable even if Base UI marks it as "behind" // due to toasts hidden by thread filtering. if (visibleToastCount <= 1) return false; diff --git a/apps/web/src/components/ui/toast.tsx b/apps/web/src/components/ui/toast.tsx index d5e28441dc6b..add361a849eb 100644 --- a/apps/web/src/components/ui/toast.tsx +++ b/apps/web/src/components/ui/toast.tsx @@ -13,6 +13,7 @@ import { type ReactNode, } from "react"; import { useParams } from "@tanstack/react-router"; +import { useCopyToClipboard } from "~/hooks/useCopyToClipboard"; import { type ScopedThreadRef, type ThreadId } from "@t3tools/contracts"; import { CheckIcon, @@ -29,8 +30,14 @@ import { import { cn } from "~/lib/utils"; import { Button, buttonVariants } from "~/components/ui/button"; import { useComposerDraftStore } from "~/composerDraftStore"; -import { useCopyToClipboard } from "~/hooks/useCopyToClipboard"; import { resolveThreadRouteTarget } from "~/threadRoutes"; +import { + ERROR_DETAIL_TOOLTIP_CLASS, + ErrorDetailCopyButton, + ErrorDetailText, + errorDetailClampClassName, + errorDetailShouldClamp, +} from "./errorDetailText"; import { buildVisibleToastLayout, hasVisibleToastAction, @@ -89,16 +96,29 @@ const TOAST_ICONS = { warning: TriangleAlertIcon, } as const; -/** Visually shorten long error bodies; clipboard copy still uses the full `description` string. */ -const ERROR_DESCRIPTION_CLAMP_MIN_CHARS = 180; function errorDescriptionClampClass(type: unknown, description: unknown): string | undefined { if (type !== "error" || typeof description !== "string") { return undefined; } - if (description.length < ERROR_DESCRIPTION_CLAMP_MIN_CHARS) { - return undefined; + return errorDetailClampClassName(errorDetailShouldClamp(description)); +} + +function errorDescriptionTooltipText(type: unknown, description: unknown): string | null { + if (type !== "error" || typeof description !== "string") { + return null; + } + return errorDetailShouldClamp(description) ? description : null; +} + +function isErrorToastType(type: unknown): boolean { + return type === "error"; +} + +function errorToastTitleTooltipText(type: unknown, title: unknown): string | null { + if (!isErrorToastType(type) || typeof title !== "string") { + return null; } - return "line-clamp-4"; + return title.length >= 48 ? title : null; } /** Dismiss-only: circular control overlapping the card corner (iOS notification–style). */ @@ -189,20 +209,55 @@ function ToastDescriptionAndExpandable({ const expandableContent = toastData?.expandableContent; const labels = toastData?.expandableLabels ?? {}; const descriptionTrigger = toastData?.expandableDescriptionTrigger ?? false; + const [open, setOpen] = useState(false); + + if ( + isErrorToastType(toastType) && + typeof toastDescription === "string" && + toastDescription.trim().length > 0 && + !expandableContent + ) { + return ( + + ); + } + const descriptionClassName = cn( "min-w-0 select-text wrap-break-word text-muted-foreground", errorDescriptionClampClass(toastType, toastDescription), ); - const [open, setOpen] = useState(false); + const tooltipText = errorDescriptionTooltipText(toastType, toastDescription); + + const descriptionNode = ( + + ); + + const maybeTooltipDescription = + tooltipText === null ? ( + descriptionNode + ) : ( + + }> + {descriptionNode} + + + {tooltipText} + + + ); if (!expandableContent) { - return ; + return maybeTooltipDescription; } if (!descriptionTrigger) { return ( <> - + {maybeTooltipDescription} {expandableContent} ); @@ -322,9 +377,33 @@ interface ToastBodyContentProps extends ToastBodyDescriptor { readonly actionProps: { readonly children?: ReactNode } | undefined; readonly toastData: ThreadToastData | undefined; readonly toastDescription: unknown; + readonly toastTitle: unknown; readonly toastType: unknown; } +function ToastTitleBlock({ toastTitle, toastType }: { toastTitle: unknown; toastType: unknown }) { + const titleClassName = cn( + "min-w-0 wrap-break-word font-medium leading-snug", + isErrorToastType(toastType) ? "text-sm text-foreground" : null, + ); + const titleTooltip = errorToastTitleTooltipText(toastType, toastTitle); + + if (titleTooltip === null) { + return ; + } + + return ( + + }> + + + + {titleTooltip} + + + ); +} + function ToastBodyContent({ stackedActionLayout, Icon, @@ -335,6 +414,7 @@ function ToastBodyContent({ hasTrailingControls, toastData, toastDescription, + toastTitle, toastType, }: ToastBodyContentProps) { const additionalActions = toastData?.additionalActions ?? []; @@ -345,7 +425,13 @@ function ToastBodyContent({ return ( <> -
    +
    {leadingIcon ? (
    - + - {copyErrorText !== null ? : null} + {copyErrorText !== null ? : null} {additionalActions.map(({ id, props: { className, ...props } }) => ( + + + + ); +} + +export const Route = createFileRoute("/_chat/jump")({ + validateSearch: (search: Record) => ({ + project: typeof search.project === "string" ? search.project : undefined, + action: typeof search.action === "string" ? search.action : undefined, + }), + component: ProjectJumpRoute, +}); diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts index 401934bce5ba..88b3837cc20c 100644 --- a/apps/web/src/session-logic.test.ts +++ b/apps/web/src/session-logic.test.ts @@ -19,6 +19,8 @@ import { findLatestProposedPlan, hasActionableProposedPlan, isLatestTurnSettled, + shouldShowPlanFollowUpComposer, + shouldShowPlanReadyStatus, selectHandoffImageResources, selectMessageImageResources, workEntryIndicatesToolNeutralStatus, @@ -384,13 +386,7 @@ describe("hasActionableProposedPlan", () => { it("returns true for an unimplemented proposed plan", () => { expect( hasActionableProposedPlan({ - id: "plan-1", - turnId: TurnId.make("turn-1"), - planMarkdown: "# Plan", implementedAt: null, - implementationThreadId: null, - createdAt: "2026-02-23T00:00:00.000Z", - updatedAt: "2026-02-23T00:00:01.000Z", }), ).toBe(true); }); @@ -398,18 +394,74 @@ describe("hasActionableProposedPlan", () => { it("returns false for a proposed plan already implemented elsewhere", () => { expect( hasActionableProposedPlan({ - id: "plan-1", - turnId: TurnId.make("turn-1"), - planMarkdown: "# Plan", implementedAt: "2026-02-23T00:00:02.000Z", - implementationThreadId: ThreadId.make("thread-implement"), - createdAt: "2026-02-23T00:00:00.000Z", - updatedAt: "2026-02-23T00:00:02.000Z", }), ).toBe(false); }); }); +describe("shouldShowPlanFollowUpComposer", () => { + const actionablePlan = { + id: "plan-1", + turnId: TurnId.make("turn-1"), + planMarkdown: "# Plan", + implementedAt: null, + implementationThreadId: null, + createdAt: "2026-02-23T00:00:00.000Z", + updatedAt: "2026-02-23T00:00:01.000Z", + }; + + it("shows Plan Ready while still in plan mode with an actionable plan", () => { + expect( + shouldShowPlanFollowUpComposer({ + interactionMode: "plan", + hasPendingUserInput: false, + proposedPlan: actionablePlan, + }), + ).toBe(true); + }); + + it("does not require the turn to be settled (mid-run after exit_plan capture)", () => { + // Same gate whether or not a turn is still running — callers no longer pass settle. + expect( + shouldShowPlanFollowUpComposer({ + interactionMode: "plan", + hasPendingUserInput: false, + proposedPlan: actionablePlan, + }), + ).toBe(true); + }); + + it("hides when not in plan mode or plan already implemented", () => { + expect( + shouldShowPlanFollowUpComposer({ + interactionMode: "default", + hasPendingUserInput: false, + proposedPlan: actionablePlan, + }), + ).toBe(false); + expect( + shouldShowPlanFollowUpComposer({ + interactionMode: "plan", + hasPendingUserInput: false, + proposedPlan: { ...actionablePlan, implementedAt: "2026-02-23T00:00:02.000Z" }, + }), + ).toBe(false); + }); +}); + +describe("shouldShowPlanReadyStatus", () => { + it("is true for plan mode with an actionable plan flag", () => { + expect( + shouldShowPlanReadyStatus({ + interactionMode: "plan", + hasPendingUserInput: false, + hasActionableProposedPlan: true, + }), + ).toBe(true); + }); +}); + describe("workEntryIndicatesToolNeutralStatus", () => { it("keeps active tools neutral and agent spawns visible", () => { const entry = { @@ -450,6 +502,40 @@ describe("workEntryIndicatesToolNeutralStatus", () => { }); describe("deriveWorkLogEntries", () => { + it("shows submitted structured answers with their question transcript", () => { + const activities: OrchestrationThreadActivity[] = [ + makeActivity({ + id: "input-requested", + createdAt: "2026-02-23T00:00:01.000Z", + kind: "user-input.requested", + summary: "User input requested", + payload: { + requestId: "request-1", + questions: [{ id: "goal", header: "Goal", question: "What is the goal?", options: [] }], + }, + }), + makeActivity({ + id: "input-resolved", + createdAt: "2026-02-23T00:00:02.000Z", + kind: "user-input.resolved", + summary: "User input submitted", + payload: { requestId: "request-1", answers: { goal: "Make it sleep" } }, + }), + ]; + + const resolved = deriveWorkLogEntries(activities).find( + (entry) => entry.id === "input-requested", + ); + expect(resolved?.userInput).toMatchObject({ + answered: true, + questions: [ + { + customAnswer: "Make it sleep", + }, + ], + }); + }); + it("keeps the latest task progress without emitting plan-update log entries", () => { const activities = [ makeActivity({ id: "before", kind: "tool.completed", summary: "Read files", sequence: 0 }), @@ -1600,6 +1686,287 @@ describe("deriveWorkLogEntries", () => { }); }); +describe("deriveWorkLogEntries clarifying questions", () => { + function makeQuestionActivities(options: { + readonly multiSelect?: boolean; + readonly answers?: Record; + }): OrchestrationThreadActivity[] { + const requested = makeActivity({ + id: "ask", + createdAt: "2026-02-23T00:00:01.000Z", + kind: "user-input.requested", + summary: "User input requested", + tone: "info", + payload: { + requestId: "req-1", + questions: [ + { + id: "How should we proceed?", + header: "Approach", + question: "How should we proceed?", + options: [ + { label: "Ship it", description: "Merge as-is" }, + { label: "Iterate", description: "Another review round" }, + ], + multiSelect: options.multiSelect === true, + }, + ], + }, + }); + if (!options.answers) { + return [requested]; + } + return [ + requested, + makeActivity({ + id: "answer", + createdAt: "2026-02-23T00:00:09.000Z", + kind: "user-input.resolved", + summary: "User input submitted", + tone: "info", + payload: { requestId: "req-1", answers: options.answers }, + }), + ]; + } + + it("merges the request and its answer into one entry carrying the picked option", () => { + const entries = deriveWorkLogEntries( + makeQuestionActivities({ answers: { "How should we proceed?": "Iterate" } }), + ); + + expect(entries).toHaveLength(1); + expect(entries[0]?.label).toBe("Question: Approach"); + expect(entries[0]?.userInput).toEqual({ + requestId: "req-1", + answered: true, + questions: [ + { + id: "How should we proceed?", + header: "Approach", + question: "How should we proceed?", + multiSelect: false, + options: [ + { label: "Ship it", description: "Merge as-is" }, + { label: "Iterate", description: "Another review round" }, + ], + selectedLabels: ["Iterate"], + }, + ], + }); + }); + + it("keeps a free-text answer that matched no option", () => { + const entries = deriveWorkLogEntries( + makeQuestionActivities({ answers: { "How should we proceed?": " Split it in two " } }), + ); + + expect(entries[0]?.userInput?.questions[0]?.selectedLabels).toEqual([]); + expect(entries[0]?.userInput?.questions[0]?.customAnswer).toBe("Split it in two"); + }); + + it("lists multi-select answers in question order", () => { + const entries = deriveWorkLogEntries( + makeQuestionActivities({ + multiSelect: true, + answers: { "How should we proceed?": ["Iterate", "Ship it"] }, + }), + ); + + expect(entries[0]?.userInput?.questions[0]?.selectedLabels).toEqual(["Ship it", "Iterate"]); + }); + + it("classifies comma-joined multi-select answers from OpenCode", () => { + const entries = deriveWorkLogEntries( + makeQuestionActivities({ + multiSelect: true, + answers: { "How should we proceed?": "Iterate, Ship it" }, + }), + ); + + expect(entries[0]?.userInput?.questions[0]).toMatchObject({ + selectedLabels: ["Ship it", "Iterate"], + }); + expect(entries[0]?.userInput?.questions[0]?.customAnswer).toBeUndefined(); + }); + + it("keeps an option label that contains a comma whole", () => { + const entries = deriveWorkLogEntries([ + makeActivity({ + id: "ask", + createdAt: "2026-02-23T00:00:01.000Z", + kind: "user-input.requested", + summary: "User input requested", + tone: "info", + payload: { + requestId: "req-1", + questions: [ + { + id: "Scope?", + header: "Scope", + question: "Scope?", + options: [ + { label: "Small, safe change", description: "Minimal diff" }, + { label: "Tests", description: "Add coverage" }, + ], + multiSelect: true, + }, + ], + }, + }), + makeActivity({ + id: "answer", + createdAt: "2026-02-23T00:00:09.000Z", + kind: "user-input.resolved", + summary: "User input submitted", + tone: "info", + payload: { requestId: "req-1", answers: { "Scope?": "Small, safe change, Tests" } }, + }), + ]); + + expect(entries[0]?.userInput?.questions[0]?.selectedLabels).toEqual([ + "Small, safe change", + "Tests", + ]); + expect(entries[0]?.userInput?.questions[0]?.customAnswer).toBeUndefined(); + }); + + it("keeps a multi-select free-text answer containing a comma intact", () => { + const entries = deriveWorkLogEntries( + makeQuestionActivities({ + multiSelect: true, + answers: { "How should we proceed?": "Ship it, but revert the migration first" }, + }), + ); + + expect(entries[0]?.userInput?.questions[0]?.selectedLabels).toEqual([]); + expect(entries[0]?.userInput?.questions[0]?.customAnswer).toBe( + "Ship it, but revert the migration first", + ); + }); + + it("shows the question while it is still unanswered", () => { + const entries = deriveWorkLogEntries(makeQuestionActivities({})); + + expect(entries).toHaveLength(1); + expect(entries[0]?.userInput?.answered).toBe(false); + expect(entries[0]?.userInput?.questions[0]?.selectedLabels).toEqual([]); + }); + + it("drops the duplicate AskUserQuestion tool rows", () => { + const entries = deriveWorkLogEntries([ + makeActivity({ + id: "tool-started", + createdAt: "2026-02-23T00:00:00.500Z", + kind: "tool.started", + summary: "Tool call started", + payload: { itemType: "dynamic_tool_call", detail: "AskUserQuestion: {}" }, + }), + makeActivity({ + id: "tool-completed", + createdAt: "2026-02-23T00:00:10.000Z", + kind: "tool.completed", + summary: "Tool call", + payload: { + itemType: "dynamic_tool_call", + detail: 'AskUserQuestion: {"questions":[{"question":"How should we proceed?"}]}', + data: { toolName: "AskUserQuestion" }, + }, + }), + ...makeQuestionActivities({ answers: { "How should we proceed?": "Ship it" } }), + ]); + + expect(entries).toHaveLength(1); + expect(entries[0]?.userInput?.answered).toBe(true); + }); + + it("still shows the answer when the request activity is out of view", () => { + const entries = deriveWorkLogEntries([ + makeActivity({ + id: "answer-only", + createdAt: "2026-02-23T00:00:09.000Z", + kind: "user-input.resolved", + summary: "User input submitted", + tone: "info", + payload: { + requestId: "req-1", + answers: { "How should we proceed?": "Ship it" }, + }, + }), + ]); + + expect(entries).toHaveLength(1); + expect(entries[0]?.userInput).toEqual({ + requestId: "req-1", + answered: true, + questions: [ + { + id: "How should we proceed?", + header: "Answer", + question: "How should we proceed?", + multiSelect: false, + options: [], + selectedLabels: [], + customAnswer: "Ship it", + }, + ], + }); + }); + + it("falls back to the generic row when the questions cannot be parsed", () => { + const entries = deriveWorkLogEntries([ + makeActivity({ + id: "ask-broken", + createdAt: "2026-02-23T00:00:01.000Z", + kind: "user-input.requested", + summary: "User input requested", + tone: "info", + payload: { requestId: "req-1", questions: [{ header: "Approach" }] }, + }), + ]); + + expect(entries).toHaveLength(1); + expect(entries[0]?.userInput).toBeUndefined(); + expect(entries[0]?.label).toBe("User input requested"); + }); + + it("replaces an unparsed request row when its answer arrives", () => { + const entries = deriveWorkLogEntries([ + makeActivity({ + id: "ask-broken", + createdAt: "2026-02-23T00:00:01.000Z", + kind: "user-input.requested", + summary: "User input requested", + tone: "info", + payload: { requestId: "req-1", questions: [{ header: "Approach" }] }, + }), + makeActivity({ + id: "answer", + createdAt: "2026-02-23T00:00:09.000Z", + kind: "user-input.resolved", + summary: "User input submitted", + tone: "info", + payload: { + requestId: "req-1", + answers: { "How should we proceed?": "Ship it" }, + }, + }), + ]); + + expect(entries).toHaveLength(1); + expect(entries[0]?.id).toBe("ask-broken"); + expect(entries[0]?.userInput).toMatchObject({ + requestId: "req-1", + answered: true, + questions: [ + { + question: "How should we proceed?", + customAnswer: "Ship it", + }, + ], + }); + }); +}); + describe("image asset requests", () => { const image = { type: "image" as const, @@ -2329,7 +2696,7 @@ describe("session activity performance", () => { expect(appendedEntries[1]).toBe(initialEntries[1]); }); - it("reuses entries when appending to 20,000 ordered tool activities", () => { + it("reuses entries when appending to 20,000 ordered tool activities within 250 ms", () => { const activities = Array.from({ length: 20_000 }, (_, index) => makeActivity({ id: `benchmark-tool-${index}`, @@ -2365,8 +2732,12 @@ describe("session activity performance", () => { }), ]; + const startedAt = performance.now(); const updatedEntries = deriveWorkLogEntries(updatedActivities); expect(updatedEntries).toHaveLength(20_001); + // GitHub-hosted CI has seen the 100ms #8006 budget fail at ~139ms on the + // same tree that passed PR CI. 250ms still fails a quadratic rebuild. + expect(performance.now() - startedAt).toBeLessThan(250); expect(initialEntries.every((entry, index) => updatedEntries[index] === entry)).toBe(true); expect(updatedEntries.at(-1)).toMatchObject({ id: "benchmark-tool-appended", diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts index 0ffcc7fdd7c6..3c02845275d5 100644 --- a/apps/web/src/session-logic.ts +++ b/apps/web/src/session-logic.ts @@ -29,6 +29,7 @@ import { type ToolLifecycleItemType, type ThreadId, type TurnId, + type UserInputQuestion, } from "@t3tools/contracts"; import { @@ -43,6 +44,7 @@ import { } from "./types"; export type { PendingApproval, PendingUserInput } from "@t3tools/client-runtime/pending-requests"; +export { requestKindFromRequestType }; export { formatDuration } from "@t3tools/shared/orchestrationTiming"; @@ -53,6 +55,29 @@ export { type WorkLogToolLifecycleStatus, } from "@t3tools/client-runtime/work-log/presentation"; +/** One question from a clarifying-question round trip, with what the user picked. */ +export interface WorkLogUserInputQuestion { + id: string; + header: string; + question: string; + multiSelect: boolean; + options: ReadonlyArray<{ label: string; description: string }>; + /** Chosen option labels, in the order the question listed them. */ + selectedLabels: ReadonlyArray; + /** Free-text answer that matched no option (the "Other" escape hatch). */ + customAnswer?: string; +} + +/** + * A `user-input.requested` / `user-input.resolved` pair merged into one entry so + * the timeline can show the question alongside the answer it received. + */ +export interface WorkLogUserInput { + requestId: string; + answered: boolean; + questions: ReadonlyArray; +} + export interface WorkLogEntry { questionAnswer?: UserInputAttachmentAnswerPayload; id: string; @@ -93,6 +118,8 @@ export interface WorkLogEntry { workflowId: string | null; agentTaskIds: ReadonlyArray; }; + /** Present on clarifying-question entries; rendered as a Q&A card, never folded away. */ + userInput?: WorkLogUserInput; } const workLogCollapseKey = Symbol(); @@ -223,6 +250,219 @@ export function deriveActiveWorkStartedAt( return sendStartedAt; } +function parseUserInputQuestions( + payload: Record | null, +): ReadonlyArray | null { + const questions = payload?.questions; + if (!Array.isArray(questions)) { + return null; + } + const parsed = questions + .map((entry) => { + if (!entry || typeof entry !== "object") return null; + const question = entry as Record; + if ( + typeof question.id !== "string" || + typeof question.header !== "string" || + typeof question.question !== "string" || + !Array.isArray(question.options) + ) { + return null; + } + const options = question.options + .map((option) => { + if (!option || typeof option !== "object") return null; + const optionRecord = option as Record; + if ( + typeof optionRecord.label !== "string" || + typeof optionRecord.description !== "string" + ) { + return null; + } + return { + label: optionRecord.label, + description: optionRecord.description, + ...(typeof optionRecord.value === "string" ? { value: optionRecord.value } : {}), + }; + }) + .filter((option): option is UserInputQuestion["options"][number] => option !== null); + if (options.length === 0 && question.allowCustomAnswer === false) { + return null; + } + return { + id: question.id, + header: question.header, + question: question.question, + options, + multiSelect: question.multiSelect === true, + ...(typeof question.allowCustomAnswer === "boolean" + ? { allowCustomAnswer: question.allowCustomAnswer } + : {}), + }; + }) + .filter((question): question is UserInputQuestion => question !== null); + return parsed.length > 0 ? parsed : null; +} + +function questionsFromFoldedAnswerPayload( + payload: Record | null, +): ReadonlyArray | null { + const texts = asRecord(payload?.questionTextById); + if (!texts) return null; + const parsed = Object.entries(texts).flatMap(([id, question]) => + typeof question === "string" && question.length > 0 + ? [{ id, header: question, question, options: [] }] + : [], + ); + return parsed.length > 0 ? parsed : null; +} + +function parseUserInputAnswerValues(value: unknown): ReadonlyArray { + const values = typeof value === "string" ? [value] : Array.isArray(value) ? value : []; + return values.flatMap((entry) => { + if (typeof entry !== "string") return []; + const trimmed = entry.trim(); + return trimmed.length > 0 ? [trimmed] : []; + }); +} + +/** + * OpenCode reports a multi-select reply as one `", "`-joined string rather than + * a list. Consume the value label by label, longest first, so a label that + * itself contains a comma survives; anything that is not a run of option labels + * is left alone as free text. + */ +function splitJoinedOptionLabels( + value: string, + optionLabels: ReadonlySet, +): ReadonlyArray | null { + const labelsByLength = [...optionLabels].toSorted((left, right) => right.length - left.length); + const picked: string[] = []; + let rest = value.trim(); + while (rest.length > 0) { + const label = labelsByLength.find( + (candidate) => rest === candidate || rest.startsWith(`${candidate},`), + ); + if (label === undefined) { + return null; + } + picked.push(label); + rest = rest.slice(label.length).replace(/^,\s*/, ""); + } + return picked.length > 1 ? picked : null; +} + +/** Structural shape shared by a freshly parsed question and an already-derived one. */ +interface AskedUserInputQuestion { + readonly id: string; + readonly header: string; + readonly question: string; + readonly multiSelect?: boolean | undefined; + readonly options: ReadonlyArray<{ readonly label: string; readonly description: string }>; +} + +/** Pairs one asked question with the answer recorded for it, when there is one. */ +function toWorkLogUserInputQuestion( + question: AskedUserInputQuestion, + answers: Record | null, +): WorkLogUserInputQuestion { + const optionLabels = new Set(question.options.map((option) => option.label)); + const reported = parseUserInputAnswerValues(answers?.[question.id]); + const [onlyValue] = reported; + const answered = + (question.multiSelect === true && + reported.length === 1 && + onlyValue !== undefined && + !optionLabels.has(onlyValue) + ? splitJoinedOptionLabels(onlyValue, optionLabels) + : null) ?? reported; + // Keep question order rather than answer order so multi-select reads consistently. + const selectedLabels = question.options + .map((option) => option.label) + .filter((label) => answered.includes(label)); + const customAnswer = answered.filter((value) => !optionLabels.has(value)).join("\n"); + return { + id: question.id, + header: question.header, + question: question.question, + multiSelect: question.multiSelect === true, + options: question.options.map((option) => ({ + label: option.label, + description: option.description, + })), + selectedLabels, + ...(customAnswer.length > 0 ? { customAnswer } : {}), + }; +} + +/** + * `user-input.resolved` without its request in view (older activity trimmed + * away) still carries the questions as answer keys — enough to show the answer. + */ +function toOrphanedWorkLogUserInputQuestions( + answers: Record, +): WorkLogUserInputQuestion[] { + return Object.entries(answers).flatMap(([question, value]) => { + const answered = parseUserInputAnswerValues(value); + if (answered.length === 0) return []; + return [ + { + id: question, + header: "Answer", + question, + multiSelect: answered.length > 1, + options: [], + selectedLabels: [], + customAnswer: answered.join("\n"), + }, + ]; + }); +} + +function toWorkLogUserInputEntry( + activity: OrchestrationThreadActivity, + userInput: WorkLogUserInput, +): DerivedWorkLogEntry { + return { + id: activity.id, + createdAt: activity.createdAt, + turnId: activity.turnId, + label: userInputWorkLogLabel(userInput.questions), + tone: "info", + sourceActivityKind: activity.kind, + userInput, + }; +} + +function userInputWorkLogLabel(questions: ReadonlyArray): string { + const [first] = questions; + if (questions.length === 1 && first) { + return `Question: ${first.header}`; + } + return `${questions.length} questions`; +} + +/** + * Claude surfaces `AskUserQuestion` through the user-input event channel, so its + * tool row is a duplicate whose only content is the raw question JSON. + */ +function isUserInputToolActivity(activity: OrchestrationThreadActivity): boolean { + if ( + activity.kind !== "tool.started" && + activity.kind !== "tool.updated" && + activity.kind !== "tool.completed" + ) { + return false; + } + const payload = asRecord(activity.payload); + const toolName = asTrimmedString(asRecord(payload?.data)?.toolName); + if (toolName === "AskUserQuestion") { + return true; + } + // `tool.started` lands before any input streams, leaving only the detail prefix. + return asTrimmedString(payload?.detail)?.startsWith("AskUserQuestion:") === true; +} + function planStateFromActivity(activity: OrchestrationThreadActivity): ActivePlanState | null { const payload = activity.payload && typeof activity.payload === "object" @@ -386,6 +626,10 @@ export function hasActionableProposedPlan( return proposedPlan !== null && proposedPlan.implementedAt === null; } +export { + shouldShowPlanFollowUpComposer, + shouldShowPlanReadyStatus, +} from "@t3tools/shared/proposedPlan"; /** * Quiet-timeline guarantee: the work log carries the parent's narrative plus * at most one row per agent. Everything an agent does internally lives in the @@ -447,11 +691,26 @@ function isAgentInternalActivity(activity: OrchestrationThreadActivity): boolean return typeof payload.agentId === "string" && payload.agentId.trim().length > 0; } +/** Streaming appends are already ordered; skip the n log n copy+sort on that path. */ +function orderActivities( + activities: ReadonlyArray, +): ReadonlyArray { + for (let index = 1; index < activities.length; index++) { + if (compareActivitiesByOrder(activities[index - 1]!, activities[index]!) > 0) { + return activities.toSorted(compareActivitiesByOrder); + } + } + return activities; +} + export function deriveWorkLogEntries( activities: ReadonlyArray, ): WorkLogEntry[] { - const ordered = [...activities].toSorted(compareActivitiesByOrder); + const ordered = orderActivities(activities); const entries: DerivedWorkLogEntry[] = []; + // Answers arrive in a separate activity from the questions; fold them back + // into the entry that asked, so one round trip renders as one Q&A card. + const userInputEntryIndexByRequestId = new Map(); for (const activity of foldUserInputActivities(ordered)) { if (activity.tone !== "error" && isWorktreeSetupActivity(activity.kind)) continue; if (activity.kind === "tool.started") continue; @@ -468,6 +727,104 @@ export function deriveWorkLogEntries( if (isNoContentRuntimeWarning(activity)) continue; if (isPlanBoundaryToolActivity(activity)) continue; if (isAgentInternalActivity(activity)) continue; + if (isUserInputToolActivity(activity)) continue; + + if (activity.kind === "user-input.answer-submitted") { + const payload = asRecord(activity.payload); + const requestId = asTrimmedString(payload?.requestId); + const answers = asRecord(payload?.answers); + const originalRequested = ordered.find((candidate) => { + if (candidate.kind !== "user-input.requested") return false; + return asTrimmedString(asRecord(candidate.payload)?.requestId) === requestId; + }); + const questions = + parseUserInputQuestions(asRecord(originalRequested?.payload)) ?? + parseUserInputQuestions(payload) ?? + questionsFromFoldedAnswerPayload(payload); + if (requestId && questions) { + const derived = toWorkLogUserInputEntry(activity, { + requestId, + answered: Boolean(answers && Object.keys(answers).length > 0), + questions: questions.map((question) => toWorkLogUserInputQuestion(question, answers)), + }); + entries.push(derived); + continue; + } + if (requestId && answers) { + const orphaned = toOrphanedWorkLogUserInputQuestions(answers); + if (orphaned.length > 0) { + entries.push( + toWorkLogUserInputEntry(activity, { + requestId, + answered: true, + questions: orphaned, + }), + ); + continue; + } + } + } + + if (activity.kind === "user-input.requested") { + const payload = asRecord(activity.payload); + const requestId = asTrimmedString(payload?.requestId); + const questions = parseUserInputQuestions(payload); + if (requestId) { + userInputEntryIndexByRequestId.set(requestId, entries.length); + if (questions) { + const derived = toWorkLogUserInputEntry(activity, { + requestId, + answered: false, + questions: questions.map((question) => toWorkLogUserInputQuestion(question, null)), + }); + entries.push(derived); + continue; + } + } + } + + if (activity.kind === "user-input.resolved") { + const payload = asRecord(activity.payload); + const requestId = asTrimmedString(payload?.requestId); + const answers = asRecord(payload?.answers); + const askedIndex = requestId ? userInputEntryIndexByRequestId.get(requestId) : undefined; + if (askedIndex !== undefined) { + const asked = entries[askedIndex]; + if (asked?.userInput) { + const questions = asked.userInput.questions.map((question) => + toWorkLogUserInputQuestion(question, answers), + ); + entries[askedIndex] = { + ...asked, + label: userInputWorkLogLabel(questions), + userInput: { ...asked.userInput, answered: true, questions }, + }; + continue; + } + if (asked && requestId && answers) { + const questions = toOrphanedWorkLogUserInputQuestions(answers); + if (questions.length > 0) { + entries[askedIndex] = { + ...asked, + label: userInputWorkLogLabel(questions), + tone: "info", + userInput: { requestId, answered: true, questions }, + }; + } + } + // The matching request already represents this lifecycle. Keep one + // generic row when neither side has enough structure for a Q&A card. + continue; + } + if (requestId && answers) { + const questions = toOrphanedWorkLogUserInputQuestions(answers); + if (questions.length > 0) { + entries.push(toWorkLogUserInputEntry(activity, { requestId, answered: true, questions })); + continue; + } + } + } + entries.push(toDerivedWorkLogEntry(activity)); } return collapseDerivedWorkLogEntries(entries); diff --git a/apps/web/src/state/aiUsage.ts b/apps/web/src/state/aiUsage.ts new file mode 100644 index 000000000000..28ce8d712b8c --- /dev/null +++ b/apps/web/src/state/aiUsage.ts @@ -0,0 +1,5 @@ +import { createAiUsageEnvironmentAtoms } from "@t3tools/client-runtime/state/ai-usage"; + +import { connectionAtomRuntime } from "../connection/runtime"; + +export const aiUsageEnvironment = createAiUsageEnvironmentAtoms(connectionAtomRuntime); diff --git a/apps/web/src/state/entities.ts b/apps/web/src/state/entities.ts index d9610e20717f..b50022e768a1 100644 --- a/apps/web/src/state/entities.ts +++ b/apps/web/src/state/entities.ts @@ -9,7 +9,7 @@ import { mergeEnvironmentThread, } from "@t3tools/client-runtime/state/threads"; import type { ScopedProjectRef, ScopedThreadRef, ServerConfig } from "@t3tools/contracts"; -import type { EnvironmentId } from "@t3tools/contracts"; +import type { EnvironmentId, ThreadId } from "@t3tools/contracts"; import { Atom } from "effect/unstable/reactivity"; import { useMemo } from "react"; import { appAtomRegistry } from "../rpc/atomRegistry"; @@ -245,3 +245,11 @@ export function readEnvironmentThreadRefs( export function readThreadShells(): ReadonlyArray { return appAtomRegistry.get(environmentThreadShells.threadShellsAtom); } + +export function findThreadRef(threadId: ThreadId): ScopedThreadRef | null { + return ( + appAtomRegistry + .get(environmentThreadShells.threadRefsAtom) + .find((ref) => ref.threadId === threadId) ?? null + ); +} diff --git a/apps/web/src/state/environments.ts b/apps/web/src/state/environments.ts index f085075fdd7c..e20c1e20b82e 100644 --- a/apps/web/src/state/environments.ts +++ b/apps/web/src/state/environments.ts @@ -48,7 +48,7 @@ export function useEnvironments() { ); return { - isReady: catalog.isReady, + isReady: catalog?.isReady ?? false, networkStatus, environments, presentationById, diff --git a/apps/web/src/state/identity.ts b/apps/web/src/state/identity.ts new file mode 100644 index 000000000000..2f808489cba3 --- /dev/null +++ b/apps/web/src/state/identity.ts @@ -0,0 +1,34 @@ +import { createIdentityEnvironmentAtoms } from "@t3tools/client-runtime/state/identity"; +import type { EnvironmentId } from "@t3tools/contracts"; +import * as Option from "effect/Option"; +import { AsyncResult, Atom } from "effect/unstable/reactivity"; + +import { environmentCatalog } from "../connection/catalog"; +import { connectionAtomRuntime } from "../connection/runtime"; + +export const identityEnvironment = createIdentityEnvironmentAtoms(connectionAtomRuntime); + +const EMPTY_CLAIM_INPUT = {} as const; + +/** + * Session claim personId per connected environment. + * + * Ownership filters must key by the *thread's* environment, not primary. + * Desktop primary=smart (no map) while secondary=t3vm (claimed) must still + * Mine-filter t3vm threads correctly. + */ +export const identityClaimPersonIdByEnvironmentAtom = Atom.make((get) => { + const catalog = get(environmentCatalog.catalogValueAtom); + const out = new Map(); + for (const environmentId of catalog.entries.keys()) { + const result = get( + identityEnvironment.sessionClaim({ + environmentId: environmentId as EnvironmentId, + input: EMPTY_CLAIM_INPUT, + }), + ); + const claimResult = Option.getOrNull(AsyncResult.value(result)); + out.set(environmentId, claimResult?.claim?.personId ?? null); + } + return out; +}).pipe(Atom.withLabel("web-identity-claim-person-by-environment")); diff --git a/apps/web/src/state/presentation.ts b/apps/web/src/state/presentation.ts index 1c2fb7b6a627..7038d6bc345b 100644 --- a/apps/web/src/state/presentation.ts +++ b/apps/web/src/state/presentation.ts @@ -25,7 +25,7 @@ export function useEnvironmentPresentation(environmentId: EnvironmentId | null) : environmentPresentations.presentationAtom(environmentId), ); return { - isReady: catalog.isReady, + isReady: catalog?.isReady ?? false, presentation, }; } diff --git a/apps/web/src/state/server.ts b/apps/web/src/state/server.ts index f13965e5b4d8..5d91a4e087c2 100644 --- a/apps/web/src/state/server.ts +++ b/apps/web/src/state/server.ts @@ -85,6 +85,20 @@ export const primaryServerSettingsAtom = Atom.make( (get): ServerSettings => get(primaryServerConfigAtom)?.settings ?? DEFAULT_SERVER_SETTINGS, ).pipe(Atom.withLabel("web-primary-server-settings")); +/** + * Latest served web-bundle version reported by the primary server, or null + * before the first lifecycle event. The web update banner compares this against + * the version present when the client booted. + */ +export const primaryServerWebVersionAtom = Atom.make((get): string | null => { + const environmentId = get(primaryEnvironmentIdAtom); + if (environmentId === null) { + return null; + } + const target = { environmentId, input: {} }; + return Option.getOrNull(AsyncResult.value(get(serverEnvironment.webVersion(target)))); +}).pipe(Atom.withLabel("web-primary-server-web-version")); + export const primaryServerProvidersAtom = Atom.make( (get): ReadonlyArray => get(primaryServerConfigAtom)?.providers ?? EMPTY_SERVER_PROVIDERS, diff --git a/apps/web/src/state/sourceControlActions.ts b/apps/web/src/state/sourceControlActions.ts index 021fb255a4b9..a35436a7e743 100644 --- a/apps/web/src/state/sourceControlActions.ts +++ b/apps/web/src/state/sourceControlActions.ts @@ -217,7 +217,8 @@ export function useGitStackedAction(scope: SourceControlActionScope) { action: GitStackedAction; commitMessage?: string; featureBranch?: boolean; - filePaths?: string[]; + disableCommitSigning?: boolean; + filePaths?: ReadonlyArray; threadId?: ThreadId; onProgress?: (event: GitActionProgressEvent) => void; }) => { @@ -237,6 +238,7 @@ export function useGitStackedAction(scope: SourceControlActionScope) { action: input.action, ...(input.commitMessage ? { commitMessage: input.commitMessage } : {}), ...(input.featureBranch ? { featureBranch: true } : {}), + ...(input.disableCommitSigning ? { disableCommitSigning: true } : {}), ...(input.filePaths?.length ? { filePaths: input.filePaths } : {}), ...(input.threadId !== undefined ? { threadId: input.threadId } : {}), ...(input.onProgress ? { onProgress: input.onProgress } : {}), diff --git a/apps/web/src/threadModelPresentation.test.ts b/apps/web/src/threadModelPresentation.test.ts new file mode 100644 index 000000000000..0b33bf3804b5 --- /dev/null +++ b/apps/web/src/threadModelPresentation.test.ts @@ -0,0 +1,60 @@ +import { describe, expect, it } from "vite-plus/test"; +import { ProviderInstanceId } from "@t3tools/contracts"; +import type { ModelSelection, ServerConfig } from "@t3tools/contracts"; +import { resolveThreadModelPresentation } from "./threadModelPresentation"; + +describe("resolveThreadModelPresentation", () => { + it("uses provider display name and model short name when available", () => { + const modelSelection: ModelSelection = { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4-codex", + }; + const serverConfig = { + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + driver: "codex", + displayName: "Codex", + enabled: true, + installed: true, + version: "1.0.0", + status: "ready", + auth: { status: "authenticated" }, + checkedAt: "2026-07-06T00:00:00.000Z", + models: [ + { + slug: "gpt-5.4-codex", + name: "GPT-5.4 Codex", + shortName: "GPT-5.4", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + }, + ], + } as unknown as ServerConfig; + + expect(resolveThreadModelPresentation(modelSelection, serverConfig)).toMatchObject({ + driverKind: "codex", + providerLabel: "Codex", + modelLabel: "GPT-5.4", + tooltip: "Codex · GPT-5.4 (gpt-5.4-codex)", + }); + }); + + it("falls back to instance id and raw model slug when the provider is unavailable", () => { + const modelSelection: ModelSelection = { + instanceId: ProviderInstanceId.make("codex_work"), + model: "custom-model", + }; + + expect(resolveThreadModelPresentation(modelSelection, null)).toEqual({ + driverKind: null, + providerLabel: "codex_work", + modelLabel: "custom-model", + tooltip: "codex_work · custom-model", + }); + }); +}); diff --git a/apps/web/src/threadModelPresentation.ts b/apps/web/src/threadModelPresentation.ts new file mode 100644 index 000000000000..2fe910bc201a --- /dev/null +++ b/apps/web/src/threadModelPresentation.ts @@ -0,0 +1,44 @@ +import type { ModelSelection, ProviderDriverKind, ServerConfig } from "@t3tools/contracts"; + +import { getDisplayModelName } from "./components/chat/providerIconUtils"; +import { deriveProviderInstanceEntries } from "./providerInstances"; + +export interface ThreadModelPresentation { + readonly driverKind: ProviderDriverKind | null; + readonly providerLabel: string; + readonly modelLabel: string; + readonly tooltip: string; +} + +export function resolveThreadModelPresentation( + modelSelection: ModelSelection, + serverConfig: ServerConfig | null | undefined, +): ThreadModelPresentation { + const providerEntry = + serverConfig === null || serverConfig === undefined + ? undefined + : deriveProviderInstanceEntries(serverConfig.providers).find( + (entry) => entry.instanceId === modelSelection.instanceId, + ); + + const matchedModel = + providerEntry === undefined + ? undefined + : providerEntry.models.find((model) => model.slug === modelSelection.model); + + const providerLabel = providerEntry?.displayName ?? modelSelection.instanceId; + const modelLabel = matchedModel + ? getDisplayModelName(matchedModel, { preferShortName: true }) + : modelSelection.model; + const tooltip = + matchedModel !== undefined && matchedModel.slug !== modelLabel + ? `${providerLabel} · ${modelLabel} (${matchedModel.slug})` + : `${providerLabel} · ${modelLabel}`; + + return { + driverKind: providerEntry?.driverKind ?? null, + providerLabel, + modelLabel, + tooltip, + }; +} diff --git a/apps/web/src/threadTurnOutbox.ts b/apps/web/src/threadTurnOutbox.ts new file mode 100644 index 000000000000..828da4fca667 --- /dev/null +++ b/apps/web/src/threadTurnOutbox.ts @@ -0,0 +1,64 @@ +import type { StartThreadTurnInput } from "@t3tools/client-runtime/operations"; +import type { EnvironmentId, MessageId } from "@t3tools/contracts"; + +const DATABASE_NAME = "t3-thread-turn-outbox"; +const DATABASE_VERSION = 1; +const STORE_NAME = "turns"; + +export interface QueuedThreadTurn { + readonly messageId: MessageId; + readonly environmentId: EnvironmentId; + readonly input: StartThreadTurnInput; + readonly queuedAt: string; +} + +function openDatabase(): Promise { + return new Promise((resolve, reject) => { + const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION); + request.addEventListener("error", () => + reject(request.error ?? new Error("Failed to open the turn outbox.")), + ); + request.addEventListener("upgradeneeded", () => { + if (!request.result.objectStoreNames.contains(STORE_NAME)) { + request.result.createObjectStore(STORE_NAME, { keyPath: "messageId" }); + } + }); + request.addEventListener("success", () => resolve(request.result)); + }); +} + +function transactionRequest( + mode: IDBTransactionMode, + run: (store: IDBObjectStore) => IDBRequest, +): Promise { + return openDatabase().then( + (database) => + new Promise((resolve, reject) => { + const transaction = database.transaction(STORE_NAME, mode); + const request = run(transaction.objectStore(STORE_NAME)); + request.addEventListener("success", () => resolve(request.result)); + request.addEventListener("error", () => + reject(request.error ?? new Error("Turn outbox operation failed.")), + ); + transaction.addEventListener("complete", () => database.close()); + transaction.addEventListener("abort", () => { + database.close(); + reject(transaction.error ?? new Error("Turn outbox transaction was aborted.")); + }); + }), + ); +} + +export function enqueueThreadTurn(turn: QueuedThreadTurn): Promise { + return transactionRequest("readwrite", (store) => store.put(turn)).then(() => undefined); +} + +export function removeQueuedThreadTurn(messageId: MessageId): Promise { + return transactionRequest("readwrite", (store) => store.delete(messageId)).then(() => undefined); +} + +export function listQueuedThreadTurns(): Promise> { + return transactionRequest("readonly", (store) => store.getAll()).then((turns) => + turns.sort((left, right) => left.queuedAt.localeCompare(right.queuedAt)), + ); +} diff --git a/apps/web/src/uiStateStore.test.ts b/apps/web/src/uiStateStore.test.ts index 4d68a3231b31..46eab67dc9c9 100644 --- a/apps/web/src/uiStateStore.test.ts +++ b/apps/web/src/uiStateStore.test.ts @@ -9,12 +9,14 @@ import { PERSISTED_STATE_KEY, type PersistedUiState, persistState, + removeThreadUiState, reorderProjects, resolveProjectExpanded, setDefaultAdvertisedEndpointKey, setProjectExpanded, setSidebarProjectScopeKey, setThreadChangedFilesExpanded, + toggleThreadPinned, type UiState, } from "./uiStateStore"; @@ -24,6 +26,7 @@ function makeUiState(overrides: Partial = {}): UiState { projectOrder: [], sidebarProjectScopeKey: null, threadLastVisitedAtById: {}, + pinnedThreadKeys: [], threadChangedFilesExpandedById: {}, defaultAdvertisedEndpointKey: null, pullRequestMergeMethod: "merge", @@ -31,6 +34,14 @@ function makeUiState(overrides: Partial = {}): UiState { }; } +describe("toggleThreadPinned", () => { + it("adds and removes a client-local scoped thread key", () => { + const pinned = toggleThreadPinned(makeUiState(), "environment-1:thread-1"); + expect(pinned.pinnedThreadKeys).toEqual(["environment-1:thread-1"]); + expect(toggleThreadPinned(pinned, "environment-1:thread-1").pinnedThreadKeys).toEqual([]); + }); +}); + describe("uiStateStore pure functions", () => { it("stores server timestamps without moving visit state backwards", () => { const threadId = ThreadId.make("thread-1"); @@ -42,6 +53,27 @@ describe("uiStateStore pure functions", () => { expect(markThreadVisited(visited, threadId, "not-a-date")).toBe(visited); }); + it("removes all per-thread ui state for a deleted thread", () => { + const threadId = ThreadId.make("thread-1"); + const otherId = ThreadId.make("thread-2"); + const state = makeUiState({ + threadLastVisitedAtById: { + [threadId]: "2026-02-25T12:30:00.000Z", + [otherId]: "2026-02-25T12:31:00.000Z", + }, + threadChangedFilesExpandedById: { + [threadId]: { "turn-1": false }, + [otherId]: { "turn-1": false }, + }, + }); + + const next = removeThreadUiState(state, threadId); + expect(next.threadLastVisitedAtById).toEqual({ [otherId]: "2026-02-25T12:31:00.000Z" }); + expect(next.threadChangedFilesExpandedById).toEqual({ [otherId]: { "turn-1": false } }); + // No-op (same reference) when the thread has no state. + expect(removeThreadUiState(next, threadId)).toBe(next); + }); + it("marks a completed thread unread using the server completion timestamp", () => { const threadId = ThreadId.make("thread-1"); const initialState = makeUiState({ @@ -186,8 +218,8 @@ describe("parsePersistedState", () => { threadChangedFilesExpansionVersion: 2, threadChangedFilesExpandedById: { "environment:thread-1": { - "turn-1": false, - "turn-2": true, + "turn-1": true, + "turn-2": false, }, }, }); @@ -200,13 +232,14 @@ describe("parsePersistedState", () => { threadLastVisitedAtById: { "environment:thread-1": "2026-02-25T12:35:00.000Z", }, + pinnedThreadKeys: [], defaultAdvertisedEndpointKey: "desktop-core:lan:http", sidebarProjectScopeKey: null, pullRequestMergeMethod: "merge", threadChangedFilesExpandedById: { "environment:thread-1": { - "turn-1": false, - "turn-2": true, + "turn-1": true, + "turn-2": false, }, }, }); @@ -300,6 +333,7 @@ describe("uiStateStore persistence", () => { threadLastVisitedAtById: { "environment:thread-1": "2026-02-25T12:35:00.000Z", }, + pinnedThreadKeys: ["environment:thread-1"], threadChangedFilesExpandedById: { "environment:thread-1": { "turn-1": false, @@ -322,6 +356,7 @@ describe("uiStateStore persistence", () => { threadLastVisitedAtById: { "environment:thread-1": "2026-02-25T12:35:00.000Z", }, + pinnedThreadKeys: ["environment:thread-1"], defaultAdvertisedEndpointKey: "desktop-core:lan:http", sidebarProjectScopeKey: null, threadChangedFilesExpansionVersion: 2, diff --git a/apps/web/src/uiStateStore.ts b/apps/web/src/uiStateStore.ts index e82c86f26404..9dfdaebbff13 100644 --- a/apps/web/src/uiStateStore.ts +++ b/apps/web/src/uiStateStore.ts @@ -23,6 +23,7 @@ export interface PersistedUiState { projectExpandedById?: Record; projectOrder?: string[]; threadLastVisitedAtById?: Record; + pinnedThreadKeys?: string[]; collapsedProjectCwds?: string[]; expandedProjectCwds?: string[]; projectOrderCwds?: string[]; @@ -44,6 +45,7 @@ export interface UiProjectState { export interface UiThreadState { threadLastVisitedAtById: Record; + pinnedThreadKeys: string[]; threadChangedFilesExpandedById: Record>; } @@ -63,6 +65,7 @@ const initialState: UiState = { projectOrder: [], sidebarProjectScopeKey: null, threadLastVisitedAtById: {}, + pinnedThreadKeys: [], threadChangedFilesExpandedById: {}, defaultAdvertisedEndpointKey: null, pullRequestMergeMethod: "merge", @@ -149,6 +152,7 @@ export function parsePersistedState(parsed: PersistedUiState): UiState { projectExpandedById, projectOrder, threadLastVisitedAtById: sanitizeTimestampRecord(parsed.threadLastVisitedAtById), + pinnedThreadKeys: sanitizeStringArray(parsed.pinnedThreadKeys), threadChangedFilesExpandedById: parsed.threadChangedFilesExpansionVersion === THREAD_CHANGED_FILES_EXPANSION_VERSION ? sanitizePersistedThreadChangedFilesExpanded(parsed.threadChangedFilesExpandedById) @@ -221,12 +225,14 @@ export function persistState(state: UiState): void { ([key]) => key !== LEGACY_PROJECT_EXPANSION_DEFAULT_KEY, ), ); + window.localStorage.setItem( PERSISTED_STATE_KEY, JSON.stringify({ projectExpandedById, projectOrder: state.projectOrder, threadLastVisitedAtById: state.threadLastVisitedAtById, + pinnedThreadKeys: state.pinnedThreadKeys, defaultAdvertisedEndpointKey: state.defaultAdvertisedEndpointKey, sidebarProjectScopeKey: state.sidebarProjectScopeKey, threadChangedFilesExpansionVersion: THREAD_CHANGED_FILES_EXPANSION_VERSION, @@ -295,6 +301,34 @@ export function markThreadUnread( }; } +/** + * Drop all per-thread UI state for a deleted thread. Without this, both + * `threadLastVisitedAtById` and `threadChangedFilesExpandedById` grew one entry + * per thread ever visited and were persisted to localStorage indefinitely. + */ +export function removeThreadUiState(state: UiState, threadId: string): UiState { + const hasVisited = threadId in state.threadLastVisitedAtById; + const hasChangedFiles = threadId in state.threadChangedFilesExpandedById; + if (!hasVisited && !hasChangedFiles) { + return state; + } + const { [threadId]: _visited, ...threadLastVisitedAtById } = state.threadLastVisitedAtById; + const { [threadId]: _changed, ...threadChangedFilesExpandedById } = + state.threadChangedFilesExpandedById; + return { + ...state, + threadLastVisitedAtById, + threadChangedFilesExpandedById, + }; +} + +export function toggleThreadPinned(state: UiState, threadKey: string): UiState { + const pinnedThreadKeys = state.pinnedThreadKeys.includes(threadKey) + ? state.pinnedThreadKeys.filter((candidate) => candidate !== threadKey) + : [...state.pinnedThreadKeys, threadKey]; + return { ...state, pinnedThreadKeys }; +} + export function setThreadChangedFilesExpanded( state: UiState, threadId: string, @@ -426,6 +460,8 @@ export function reorderProjects( interface UiStateStore extends UiState { markThreadVisited: (threadId: string, visitedAt: string) => void; markThreadUnread: (threadId: string, latestTurnCompletedAt: string | null | undefined) => void; + removeThread: (threadId: string) => void; + toggleThreadPinned: (threadKey: string) => void; setThreadChangedFilesExpanded: (threadId: string, turnId: string, expanded: boolean) => void; setDefaultAdvertisedEndpointKey: (key: string | null) => void; setSidebarProjectScopeKey: (projectKey: string | null) => void; @@ -444,6 +480,8 @@ export const useUiStateStore = create((set) => ({ set((state) => markThreadVisited(state, threadId, visitedAt)), markThreadUnread: (threadId, latestTurnCompletedAt) => set((state) => markThreadUnread(state, threadId, latestTurnCompletedAt)), + removeThread: (threadId) => set((state) => removeThreadUiState(state, threadId)), + toggleThreadPinned: (threadKey) => set((state) => toggleThreadPinned(state, threadKey)), setThreadChangedFilesExpanded: (threadId, turnId, expanded) => set((state) => setThreadChangedFilesExpanded(state, threadId, turnId, expanded)), setDefaultAdvertisedEndpointKey: (key) => diff --git a/apps/web/src/vite-env.d.ts b/apps/web/src/vite-env.d.ts index 31260c8ae666..d07a60239036 100644 --- a/apps/web/src/vite-env.d.ts +++ b/apps/web/src/vite-env.d.ts @@ -23,5 +23,6 @@ interface ImportMeta { declare global { interface Window { desktopBridge?: DesktopBridge; + nativeApi?: import("@t3tools/contracts").LocalApi; } } diff --git a/apps/web/src/vitePreloadRecovery.test.ts b/apps/web/src/vitePreloadRecovery.test.ts new file mode 100644 index 000000000000..16d024fd3b68 --- /dev/null +++ b/apps/web/src/vitePreloadRecovery.test.ts @@ -0,0 +1,73 @@ +import { describe, expect, it, vi } from "vite-plus/test"; + +import { + installVitePreloadRecovery, + shouldReloadForPreloadError, + VITE_PRELOAD_RELOAD_COOLDOWN_MS, + VITE_PRELOAD_RELOAD_STORAGE_KEY, +} from "./vitePreloadRecovery"; + +describe("shouldReloadForPreloadError", () => { + it("allows the first reload", () => { + expect(shouldReloadForPreloadError(1_000, null)).toBe(true); + }); + + it("blocks reloads inside the cooldown window", () => { + const last = 10_000; + expect(shouldReloadForPreloadError(last + VITE_PRELOAD_RELOAD_COOLDOWN_MS - 1, last)).toBe( + false, + ); + }); + + it("allows another reload after the cooldown", () => { + const last = 10_000; + expect(shouldReloadForPreloadError(last + VITE_PRELOAD_RELOAD_COOLDOWN_MS, last)).toBe(true); + }); +}); + +describe("installVitePreloadRecovery", () => { + it("reloads once and records the attempt", () => { + const storage = new Map(); + const reload = vi.fn(); + const listeners = new Map(); + let now = 50_000; + + const dispose = installVitePreloadRecovery({ + storage: { + getItem: (key) => storage.get(key) ?? null, + setItem: (key, value) => { + storage.set(key, value); + }, + }, + reload, + now: () => now, + addEventListener: ((type: string, listener: EventListener) => { + listeners.set(type, listener); + }) as typeof window.addEventListener, + removeEventListener: ((type: string) => { + listeners.delete(type); + }) as typeof window.removeEventListener, + }); + + const event = { + preventDefault: vi.fn(), + } as unknown as Event; + + listeners.get("vite:preloadError")?.(event); + + expect(event.preventDefault).toHaveBeenCalledOnce(); + expect(reload).toHaveBeenCalledOnce(); + expect(storage.get(VITE_PRELOAD_RELOAD_STORAGE_KEY)).toBe(String(now)); + + // Same moment: cooldown blocks a second reload. + listeners.get("vite:preloadError")?.(event); + expect(reload).toHaveBeenCalledOnce(); + + now += VITE_PRELOAD_RELOAD_COOLDOWN_MS; + listeners.get("vite:preloadError")?.(event); + expect(reload).toHaveBeenCalledTimes(2); + + dispose(); + expect(listeners.has("vite:preloadError")).toBe(false); + }); +}); diff --git a/apps/web/src/vitePreloadRecovery.ts b/apps/web/src/vitePreloadRecovery.ts new file mode 100644 index 000000000000..9d4eee84875a --- /dev/null +++ b/apps/web/src/vitePreloadRecovery.ts @@ -0,0 +1,74 @@ +/** + * Recover from Vite version skew: after a deploy, an open tab still points at + * old hashed lazy chunks. Dynamic import then fails with + * "Failed to fetch dynamically imported module". Vite emits `vite:preloadError` + * for this; reloading picks up the new index + chunk map. + * + * Cooldown avoids a tight reload loop when the failure is not skew (offline, + * auth wall, etc.). + */ + +export const VITE_PRELOAD_RELOAD_STORAGE_KEY = "t3:vite-preload-reload-at"; +export const VITE_PRELOAD_RELOAD_COOLDOWN_MS = 10_000; + +export type VitePreloadRecoveryStorage = Pick; + +export function shouldReloadForPreloadError( + nowMs: number, + lastReloadAtMs: number | null, + cooldownMs: number = VITE_PRELOAD_RELOAD_COOLDOWN_MS, +): boolean { + if (lastReloadAtMs == null || !Number.isFinite(lastReloadAtMs)) { + return true; + } + return nowMs - lastReloadAtMs >= cooldownMs; +} + +function readLastReloadAt(storage: VitePreloadRecoveryStorage): number | null { + const raw = storage.getItem(VITE_PRELOAD_RELOAD_STORAGE_KEY); + if (raw == null || raw.length === 0) { + return null; + } + const parsed = Number(raw); + return Number.isFinite(parsed) ? parsed : null; +} + +export function installVitePreloadRecovery(options?: { + storage?: VitePreloadRecoveryStorage; + reload?: () => void; + now?: () => number; + addEventListener?: typeof window.addEventListener; + removeEventListener?: typeof window.removeEventListener; + cooldownMs?: number; +}): () => void { + if (typeof window === "undefined" && !options?.addEventListener) { + return () => undefined; + } + + const storage = options?.storage ?? window.sessionStorage; + const reload = options?.reload ?? (() => window.location.reload()); + const now = options?.now ?? Date.now; + const addEventListener = options?.addEventListener ?? window.addEventListener.bind(window); + const removeEventListener = + options?.removeEventListener ?? window.removeEventListener.bind(window); + const cooldownMs = options?.cooldownMs ?? VITE_PRELOAD_RELOAD_COOLDOWN_MS; + + const onPreloadError = (event: Event) => { + if (!shouldReloadForPreloadError(now(), readLastReloadAt(storage), cooldownMs)) { + return; + } + + // Prevent the default unhandled-rejection path so we own recovery. + if ("preventDefault" in event && typeof event.preventDefault === "function") { + event.preventDefault(); + } + + storage.setItem(VITE_PRELOAD_RELOAD_STORAGE_KEY, String(now())); + reload(); + }; + + addEventListener("vite:preloadError", onPreloadError); + return () => { + removeEventListener("vite:preloadError", onPreloadError); + }; +} diff --git a/apps/web/src/worktreeCleanup.test.ts b/apps/web/src/worktreeCleanup.test.ts index b16342ced789..b4b16ce9c1ec 100644 --- a/apps/web/src/worktreeCleanup.test.ts +++ b/apps/web/src/worktreeCleanup.test.ts @@ -20,6 +20,8 @@ function makeThread(overrides: Partial = {}): Thread { interactionMode: DEFAULT_INTERACTION_MODE, session: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, checkpoints: [], pullRequests: [], activities: [], diff --git a/apps/web/vercel.ts b/apps/web/vercel.ts index 12a823a360e4..f5f64b7751cf 100644 --- a/apps/web/vercel.ts +++ b/apps/web/vercel.ts @@ -25,7 +25,7 @@ function channelCookie(channel: "latest" | "nightly"): string { export const config: VercelConfig = { buildCommand: - 'vp run --filter @t3tools/web build && node ../../scripts/apply-web-brand-assets.ts --channel "${VITE_HOSTED_APP_CHANNEL:-latest}"', + 'VITE_HOSTED_APP_CHANNEL="${VITE_HOSTED_APP_CHANNEL:-latest}" vp run --filter @t3tools/web build && node ../../scripts/apply-web-brand-assets.ts --channel "${VITE_HOSTED_APP_CHANNEL:-latest}"', git: { deploymentEnabled: false, }, diff --git a/apps/web/vite.config.ts b/apps/web/vite.config.ts index ec4f15fc7eeb..f85fced49f9f 100644 --- a/apps/web/vite.config.ts +++ b/apps/web/vite.config.ts @@ -70,11 +70,154 @@ const buildSourcemap: boolean | "hidden" = ? "hidden" : true; +const isolatedUnitTestFiles = [ + "src/authBootstrap.test.ts", + // Mocks `~/state/session`; same isolate:false hazard as the favicon test — + // it failed in one full run and passed in the next, purely on file ordering. + "src/browserHistoryStore.test.ts", + "src/browser/browserRecording.test.ts", + // Mocks `~/hooks/useSettings`; under isolate:false an earlier file binds + // the real store and getBrowserDefaults never sees the test profile list. + "src/browser/browserDefaults.test.ts", + // Mocks `~/hooks/useSettings`; under isolate:false the real hydrate path + // already bound ensureLocalApi, so failed-read tests throw "Local API not found". + "src/browser/browserLinkTarget.test.ts", + // Mocks `~/localApi` persistence; same isolate:false binding as useSettings. + "src/browser/HostedBrowserWebview.test.tsx", + "src/browser/browserTargetResolver.test.ts", + "src/browser/desktopTabLifetime.test.ts", + "src/branding.test.ts", + "src/clientPersistenceStorage.test.ts", + "src/cloud/dpop.test.ts", + "src/cloud/linkEnvironment.test.ts", + "src/cloud/managedAuth.test.ts", + "src/components/ComposerPromptEditor.test.ts", + "src/components/ProjectFavicon.test.tsx", + "src/components/ProviderUpdateEnvironmentRows.test.tsx", + "src/components/ServerUpdateAction.test.tsx", + // Mocks `~/lib/assistantTextSelection` and `../ui/toast`; under + // isolate:false those modules are already bound and citation Range/CSS + // highlight fixtures never attach. + "src/components/chat/AssistantCitationSource.test.ts", + "src/components/chat/MessagesTimeline.test.tsx", + // Mocks `../assets/assetUrls` while ChatMarkdown is already bound to the + // real module under isolate:false — useAssetUrlState then sees + // useAtomValue() === null and throws on `_tag`. + "src/components/ChatMarkdown.workspace-images.test.tsx", + "src/components/chat/draftHeroTransition.test.ts", + // Mounts react-dom createRoot against a stub document; under isolate:false + // an earlier file can bind a real document/ReactDOM so hide/unhide never + // closes the popup. + "src/components/chat/useComposerMenuState.test.tsx", + "src/components/files/projectFilesQueryState.test.ts", + // Same react-hook mock as the .ts sibling; the .tsx refresh tests were added + // upstream and fail under isolate:false when real React is already bound. + "src/components/files/projectFilesQueryState.test.tsx", + // Mocks `~/browserFaviconStore`; under `isolate: false` an earlier file in + // the same worker can bind the real module first, and the mock then never + // applies — the icon falls back to the browser mockup and the stored-favicon + // assertion fails, depending only on how files land across workers. + "src/components/preview/PreviewFaviconIcon.test.tsx", + // Mocks `~/localApi` getClientSettings; under isolate:false the real + // localApi is already bound so open waits forever or never sees the mock. + "src/components/preview/PreviewAutomationHosts.test.tsx", + "src/components/preview/PreviewView.test.tsx", + "src/components/preview/openPreviewSession.test.ts", + "src/components/preview/openTerminalLinkInPreview.test.ts", + // Tests that mock `react` itself and drive components through + // reactHookHarness need their own module registry: under `isolate: false` + // the component graph may already be bound to the real react/compiler + // runtime by an earlier file in the same worker, and the mock then never + // applies — the compiled component reports a memo-cache hit and skips the + // hooks these tests assert on. Upstream ships these without isolation + // because it does not share registries; the fork does. + "src/components/diffs/StyledDiffCodeView.test.tsx", + "src/components/settings/AddProviderInstanceDialog.environment.test.tsx", + // Replaces `window` with a capture-bridge stub and fakes rAF/localStorage; + // under isolate:false that window leak makes later files miss animation + // frames or fail composer persist verification, depending on worker order. + "src/components/desktop/SnapShotCoordinator.test.ts", + // Mocks `~/lib/desktopSnapShot` and drives keyboard recording against a + // stub window; under isolate:false an earlier file can bind the real + // capture bridge so suppression never arms. + "src/components/settings/useSnapShotShortcutRecorder.test.tsx", + // Mounts CaptureShortcutConfig through react-test-renderer; under + // isolate:false useTheme's useSyncExternalStore hits a second React copy. + "src/components/settings/CaptureShortcutConfig.test.tsx", + // Mocks `../../hooks/useSettings` without usePrimarySettingsAvailable; + // under isolate:false that incomplete mock leaks into SettingsRow and + // ProviderInstanceCard.test.ts throws on the missing export. + "src/components/settings/SnapShotSettings.test.tsx", + // Mocks `~/hooks/useSettings` with only useEnvironmentIdentificationMode; + // same isolate:false SettingsRow leak as SnapShotSettings.test.tsx. + "src/components/chat/ComposerPrimaryActions.test.tsx", + // Mocks `../../hooks/useSettings` and `../../state/environments`; under + // isolate:false an earlier file binds the real hooks so useEnvironments + // sees a null presentations map and throws on `.entries()`. + "src/components/settings/IntegrationsSettings.test.tsx", + // Mocks `../ui/button` as a host-element string; under isolate:false that + // stub leaks into later files (ComposerControl then renders variant as a + // DOM attribute and drops size classes). + "src/components/settings/ProjectIconPickerDialog.test.tsx", + "src/components/settings/ProviderSettingsPanel.environment.test.tsx", + // Mocks `../ui/toast`; under isolate:false an earlier file binds the real + // toast manager and the release-link error toast is never recorded. + "src/components/sidebar/SidebarUpdateReleaseNotes.test.tsx", + // Mocks `react` useState and `../ui/button` as "button"; same isolate:false + // Button leak as ProjectIconPickerDialog.test.tsx. + "src/components/usage/UsagePage.test.tsx", + "src/connection/storage.test.ts", + "src/contextMenuFallback.test.ts", + "src/environments/primary/bootstrap.test.ts", + "src/environments/primary/httpLayer.test.ts", + "src/hooks/useCopyToClipboard.test.ts", + // Mocks `react` (useCallback/useMemo) and `@effect/atom-react`; under + // isolate:false an earlier file binds real React and useContext is null. + "src/hooks/useHandleNewThread.test.ts", + // Mocks `~/localApi` persistence; under isolate:false the real ensureLocalApi + // is already bound and hydration throws "Local API not found". + "src/hooks/useSettings.test.ts", + "src/hooks/useLocalStorage.test.ts", + "src/hooks/useTheme.test.ts", + // Mocks `react` (useSyncExternalStore) like useTheme.test.ts; under + // isolate:false an earlier file binds real React and the mock never applies. + "src/hooks/useEnvironmentThemeSync.test.ts", + "src/lib/elementContext.test.ts", + // Mocks `@t3tools/client-runtime/state/runtime` without spreading the real + // module; under isolate:false that incomplete mock leaks into later files + // that import asset URL atoms (PullRequestListFilters.test.tsx). + "src/lib/attachmentUploadQueue.test.ts", + "src/localApi.test.ts", + // Mocks `~/localApi`; under isolate:false terminalCloseConfirm is already + // bound to the real module so confirm() is never the mock and pending stays false. + "src/lib/terminalCloseConfirm.test.ts", + "src/providerUpdateDismissal.test.ts", + // Mocks `@pierre/diffs` getSharedHighlighter; under isolate:false ChatMarkdown + // already binds the real highlighter so the recovered-text cache test sees + // a live object instead of the stub. + "src/lib/syntaxHighlighting.test.ts", + // Real Pierre worker + 7k-line tokenizer. The 60-edit stale-highlight case + // timed out at 15s under isolate:false CI load. + "src/components/files/fileEditorHighlight.test.ts", + // Mocks `./vendor/ghostty-vt.wasm?url`; under isolate:false runtime.ts is + // already bound to the real asset URL and fetch('/src/...wasm') is invalid. + "src/terminal/ghostty/core.test.ts", + "src/uiStateStore.test.ts", + "src/versionSkew.test.ts", +] as const; + const unitTestProject = { extends: true, test: { name: "unit", + // Reuse each worker's transformed module graph across test files. The suite + // resets its stores explicitly; process isolation was spending most of CI + // time re-importing the same React/Effect graph for every file. + isolate: false, + fileParallelism: true, + maxWorkers: 4, include: ["src/**/*.test.{ts,tsx}"], + exclude: [...isolatedUnitTestFiles], // The web runtime suite exercises auth bootstrap, saved environments, // and websocket subscription lifecycles. Under the full monorepo test // run, those async tests can exceed Vitest's default 5s budget. @@ -84,6 +227,19 @@ const unitTestProject = { }, } satisfies TestProjectInlineConfiguration; +const isolatedUnitTestProject = { + extends: true, + test: { + name: "unit-isolated", + isolate: true, + fileParallelism: true, + maxWorkers: 4, + include: [...isolatedUnitTestFiles], + hookTimeout: 15_000, + testTimeout: 15_000, + }, +} satisfies TestProjectInlineConfiguration; + function resolveDevProxyTarget( backendPort: string | undefined, wsUrl: string | undefined, @@ -274,7 +430,7 @@ export default defineConfig(() => { sourcemap: buildSourcemap, }, test: { - projects: [defineProject(unitTestProject)], + projects: [defineProject(unitTestProject), defineProject(isolatedUnitTestProject)], }, }; }); diff --git a/docs/README.md b/docs/README.md index 4691e6f83c8e..73f7e112c8a2 100644 --- a/docs/README.md +++ b/docs/README.md @@ -26,7 +26,8 @@ ## Working on T3 Code Start with the [development runbook](./operations/development.md) and -[contribution policy](../CONTRIBUTING.md). +[contribution policy](../CONTRIBUTING.md). Fork branch model, agent rules, and the ship gate live in +[AGENTS.md](../AGENTS.md). Internal notes preserve architectural decisions, constraints, and implementation traps that the source alone does not explain. Most code changes do not need an internal documentation update. Follow the @@ -54,6 +55,7 @@ source alone does not explain. Most code changes do not need an internal documen - [Development and local builds](./operations/development.md) - [T3 Connect setup](./operations/connect-setup.md) +- [CI quality gates](./operations/ci.md) - [Release](./operations/release.md) - [Observability](./operations/observability.md) - [Relay observability](./operations/relay-observability.md) diff --git a/docs/internals/composer-turn-lifecycle.md b/docs/internals/composer-turn-lifecycle.md new file mode 100644 index 000000000000..03ad1c59472a --- /dev/null +++ b/docs/internals/composer-turn-lifecycle.md @@ -0,0 +1,400 @@ +# Composer Turn Lifecycle — Known Issues & Remediation Plan + +This document explains four reported problems with the chat composer and the +send / abort lifecycle, why they exist (they are mostly consequences of the +current optimistic client state model plus a missing turn-liveness guarantee, +not random bugs), and a plan to fix them. + +## Reported symptoms + +1. **Intermittent submit while a turn is processing.** After sending a message + and while the agent (Codex / Claude / OpenCode) is processing, pressing Enter + to submit another message _sometimes_ works and sometimes silently does + nothing. Reloading the page reliably restores the ability to submit. +2. **Unresponsive abort button.** The Stop button frequently does nothing when + clicked. +3. **Submit/abort button does not follow the conventional toggle.** In many + other agent clients the primary button shows **Stop** while a turn runs, but + as soon as you start typing a new message it becomes **Send**; clearing the + input turns it back into **Stop**. T3 Code does not do this — the button is + driven purely by turn status, and typing never converts it to Send. +4. **Turns stuck "running" for hours.** A turn can display a live + **"Working for 8h 23m"** indicator long after any real work finished (the + last tool call in the timeline shows as completed). The turn never settles, + the elapsed timer keeps counting without bound, and — because of #2 — it + cannot be aborted. Only a reload / session restart clears it. This is the + end-stage of the same failure class as #1 and #2, plus a missing liveness + guarantee (#4 below). + +## Relevant architecture + +### Session phase + +`derivePhase(session)` (`apps/web/src/session-logic.ts:1381`) collapses the +server's `OrchestrationSessionStatus` +(`idle | starting | running | ready | interrupted | stopped | error`, +`packages/contracts/src/orchestration.ts:260`) into a 4-value client +`SessionPhase` (`apps/web/src/types.ts:19`): +`disconnected | connecting | ready | running`. + +`phase === "running"` is the single gate that flips the composer's primary +button into a Stop button and blocks new sends. + +### Optimistic local dispatch (`isSendBusy`) + +Sends are optimistic. `useLocalDispatchState` +(`apps/web/src/components/ChatView.tsx:362`) records a `LocalDispatchSnapshot` +of the thread's `latestTurn` / `session` at send time +(`createLocalDispatchSnapshot`, `ChatView.logic.ts:398`). `isSendBusy` stays +true (`ChatView.logic.ts:419`) until the server state visibly _changes_ from +that snapshot, as judged by `hasServerAcknowledgedLocalDispatch` +(`ChatView.logic.ts:416-462`). + +Acknowledgement is inferred — there is no explicit "command accepted" signal. +It is considered acknowledged when any of these differ from the snapshot: +`latestTurn.{turnId,requestedAt,startedAt,completedAt}`, `session.status`, or +`session.updatedAt`; or when a pending approval / pending user input / thread +error appears. + +### The one toggle button + +`ComposerPrimaryActions` (`apps/web/src/components/chat/ComposerPrimaryActions.tsx`) +branches in priority order: + +1. `pendingAction` (plan Q&A) → Next / Submit. +2. `isRunning` → red **Stop** button (`onClick={onInterrupt}`), lines 126-140. +3. `showPlanFollowUpPrompt` → Refine / Implement. +4. default → **Send** (`type="submit"`), `disabled` when + `isSendBusy || isConnecting || isEnvironmentUnavailable || !hasSendableContent`. + +`isRunning` is wired to `phase === "running"` +(`ChatComposer.tsx:2545`). **Input content does not participate in the +branch** — only in whether the Send button is disabled. + +### Send / interrupt transport + +Both commands funnel through `dispatch` → +`request(ORCHESTRATION_WS_METHODS.dispatchCommand, …)` +(`packages/client-runtime/src/operations/commands.ts:78`). `request` +(`packages/client-runtime/src/rpc/client.ts:106`) resolves `currentSession()`; +if the socket is not live it **fails immediately** with +`EnvironmentRpcUnavailableError` (`client.ts:88-104`). The RPC session does not +retry (`retryTransientErrors: false`, `Schedule.recurs(0)`, +`packages/client-runtime/src/rpc/session.ts:99-102`); reconnect/backoff lives +only in `EnvironmentSupervisor` +(`packages/client-runtime/src/connection/supervisor.ts`). **Commands are not +queued across a reconnect** — they are dropped. + +Server side, an interrupt is emitted as `thread.turn-interrupt-requested` +whether or not a `turnId` is supplied (`decider.ts:468-488`) and is applied +**by provider session**, not by turn id +(`ProviderCommandReactor.ts:879-898`). + +## Root-cause analysis + +### Issue 1 — intermittent submit, fixed by reload + +`onSend` bails when `isSendBusy` is true (`ChatView.tsx:3903-3909`) and the +composer disables/ignores Enter on the same signal +(`collapsedComposerPrimaryActionDisabled`, `ChatComposer.tsx:1137`). So the +symptom is: **`isSendBusy` is stuck true.** + +`isSendBusy` is derived, not timed. It only clears when +`hasServerAcknowledgedLocalDispatch` observes a _difference_ from the snapshot +taken at send time (`ChatView.logic.ts:432-461`). It gets stuck whenever that +difference never materialises on the client: + +- **Sending a second message while a turn is already running.** The snapshot is + taken with the running turn's ids/timestamps already populated. If the server + queues/answers without producing a _distinct_ `latestTurn`/`session` change + the client can see — or produces one that matches the snapshot's fields — the + `phase === "running"` branch keeps returning `false` (`ChatView.logic.ts:440-454`) + and the dispatch is never acknowledged. +- **A missed or coalesced projection update.** The acknowledgement depends on + seeing the `updatedAt`/turn transition. A dropped WebSocket frame, a + reconnect (`supervisor.ts`), or a projection snapshot that lands already in + the post-transition state can skip the exact delta the heuristic is waiting + for. +- **No timeout / no explicit ack.** Because acknowledgement is inferred from + state diffing and there is no fallback timer, once the delta is missed the + client waits forever. + +Reloading rebuilds `localDispatch` as `null` from a fresh snapshot, so +`isSendBusy` is false again — which is exactly the reported workaround. + +### Issue 2 — unresponsive abort + +Two independent causes, both client-side (the server interrupts by session and +tolerates a missing `turnId`, so the payload shape is not the problem): + +- **The Stop button is only rendered when `phase === "running"`** + (`ComposerPrimaryActions.tsx:126`, gated by `ChatComposer.tsx:2545`). During + the window where a send is in flight but the session has not yet reported + `running` (`isSendBusy` true, `phase` still `ready`/`connecting`), the + composer shows a **disabled Send spinner, not Stop** — there is no way to + abort. Conversely if the client's `session.status` is stale (see Issue 1), + the button state and the real provider state disagree. +- **Fire-and-forget dispatch over a possibly-down socket.** `onInterrupt` + (`ChatView.tsx:4291`) calls `interruptThreadTurn` once. If the socket is + reconnecting, `currentSession()` rejects immediately (`client.ts:93-99`) and + the interrupt is dropped (no queue, no retry). Failures classified as + "interrupted" are swallowed (`isAtomCommandInterrupted`, `ChatView.tsx:4297`), + so the click produces no visible effect and no error. + +`interruptTurn` does use the `urgentScheduler` +(`packages/client-runtime/src/state/threadCommands.ts:110`), so scheduling is +not the bottleneck — availability of the socket and visibility of the button +are. + +### Issue 3 — button does not toggle on input content + +This is a **design gap, not a defect**. `ComposerPrimaryActions` decides +Send-vs-Stop solely from turn status (`isRunning`); the draft's +`hasSendableContent` only toggles the Send button's `disabled` state, and is not +consulted in branch 2 (`ComposerPrimaryActions.tsx:126-228`). The conventional +behaviour (Stop when idle-of-input during a run, Send the moment the user types, +Stop again when the input is cleared) is simply not implemented. Implementing it +also removes the Issue 2 dead-zone, because a running turn with a non-empty +draft would expose Send while still allowing Stop via a secondary affordance. + +### Issue 4 — turns stuck "running" for hours, unbounded timer + +A turn is displayed as in-progress whenever `isLatestTurnSettled` returns false +(`apps/web/src/session-logic.ts:294-303`): + +```ts +if (!latestTurn?.startedAt) return false; +if (!latestTurn.completedAt) return false; // no completion observed → "running" +if (!session) return true; +if (session.status === "running") return false; +return true; +``` + +The `MessagesTimeline` renders the "Working for …" row while `!latestTurnSettled` +(`ChatView.tsx:5126`), and `WorkingTimer` (`MessagesTimeline.tsx:1082-1102`) +computes `now − createdAt` on a 1 s interval with **no upper bound**. So the +label counts up forever as long as the turn is considered unsettled. + +A turn only _becomes_ settled when the server applies a `turn.completed` (or +`session.exited`) event and sets `completedAt` / flips `session.status` +(`apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts:1257-1645`). +There is **no liveness guarantee** on that ever happening: + +- **No per-turn stall / idle / heartbeat timeout anywhere.** The only timeouts + in the provider layer are for _session load_ (90 s, + `apps/server/src/provider/acp/AcpSessionRuntime.ts:49-50`). If a provider + process hangs, its stdout stream stalls, or the terminal event is never + emitted, the orchestration engine keeps the session `running` indefinitely. +- **A single dropped completion event is unrecoverable on the client.** Same + fragility as Issue 1 — if the `turn.completed` projection frame is lost over a + reconnect, the client's `session.status` stays `running` and `completedAt` + stays null, so `isLatestTurnSettled` never flips. +- **Abort is the only recovery, and it is unreliable** (Issues 1 & 2), so the + turn wedges until a reload or a server restart. + +The "8h 23m" is therefore not evidence of work — it is a turn that lost (or +never received) its completion signal, with nothing on either side to time it +out. This is the single most user-visible consequence of the missing +acknowledgement/liveness model. + +## Design principles + +**The composer is never blocked by turn state.** A user must be able to type and +send messages regardless of whether a turn is running, stalled, or will never +complete. Turn liveness is a server/provider concern; it must not gate the +input. This is the primary requirement and it reframes the whole plan: + +- Sending must **not** depend on `phase === "running"` or on the previous turn + being settled. A hung turn (Issue 4) must never take the composer offline. +- `isSendBusy` may only represent the **in-flight send RPC itself** — a + sub-second round-trip — never the lifetime of a turn. It must clear on the + RPC's own resolution/failure (or a short watchdog), not on inferred turn + progress. +- The only legitimate hard blocks on send are: no active thread, or the + environment/socket being unavailable (and even then, prefer queueing the + message over silently dropping it — see Phase 5). +- Enabling send while a turn runs requires the **server to accept a message + during an active turn** (queue it for the next turn, or interrupt-then-send). + That server contract is the gating dependency for this principle; see the + open question on send-while-running semantics. + +## Remediation plan + +Ordered by value-to-risk. Phase 1 makes the composer always usable (the +principle above) and self-healing; Phase 2 makes abort always reachable; Phase 3 +aligns the button UX with the convention; Phase 4 adds a liveness guarantee so a +lost/hung turn cannot wedge for hours; Phase 5 hardens the transport. + +### Phase 1 — composer always usable + self-healing (fixes Issue 1, enforces the principle) + +- **Stop gating send on turn state.** Remove `phase === "running"` from the + composer's send/Enter disable + (`collapsedComposerPrimaryActionDisabled`, `ChatComposer.tsx:1137`) and remove + `isSendBusy` as a hard block in `onSend` (`ChatView.tsx:3903-3909`). Sending + is allowed whenever there is sendable content and the environment is + connected, regardless of whether a turn is running or stuck. +- **Redefine `isSendBusy` to the send RPC only.** It must reflect the in-flight + `dispatchCommand` round-trip and clear on that RPC's own resolution/failure — + not on inferred turn progress via `hasServerAcknowledgedLocalDispatch` + (`ChatView.logic.ts:416-462`). Back it with a short watchdog so a lost + response cannot pin it; a hung _turn_ no longer touches it at all. +- Prefer an **explicit acknowledgement** over state-diff inference: have + `dispatchCommand` resolve with the accepted command / turn (or queued-message) + id (`packages/client-runtime/src/operations/commands.ts:78`, + `packages/contracts/src/orchestration.ts` command results). +- Reconcile local state on **reconnect / fresh snapshot**: when a full thread + snapshot arrives, trust it over any stale in-flight flag so a missed delta + cannot wedge the composer. +- Add regression tests to `ChatView.logic.ts` covering: send-while-running, + send-while-stalled (turn never completes), snapshot equal to post-state, and + reconnect mid-dispatch. + +### Phase 2 — guarantee abort is always reachable and never silent (fixes Issue 2) + +- **Decouple Stop visibility from `phase === "running"`.** Show Stop whenever + there is an interruptible turn, including the optimistic `isSendBusy` window + (i.e. `isRunning || isSendBusy` with an `activeTurn`/pending dispatch). Target + `ChatComposer.tsx:2545` and `ComposerPrimaryActions.tsx:126`. +- **Do not swallow interrupt failures.** When the socket is unavailable, either + queue the interrupt for delivery on reconnect or show an explicit, actionable + error instead of treating `EnvironmentRpcUnavailableError` as a no-op + (`ChatView.tsx:4291-4304`). +- Consider optimistic feedback on the Stop button (pressed/disabled state) so a + click is always acknowledged in the UI even before the server confirms. + +### Phase 3 — content-aware primary button + send-while-running semantics (fixes Issue 3) + +- Change `ComposerPrimaryActions` so that when a turn is running **and** the + draft has sendable content, the primary button is **Send** while Stop remains + available as a secondary control; when the draft is empty, the primary button + is **Stop**. +- Model the two send-while-running modes explicitly rather than picking one: + - **Queue** — the message waits and is delivered when the current turn ends + (Codex's default behaviour: queued messages sit until the turn completes). + Surface queued messages in the composer/timeline so the user can see and + ideally cancel/edit them while they wait. + - **Steer** — inject the message into the running turn now (Codex "steer"), + redirecting the agent mid-turn without a full interrupt. Expose this as an + explicit action (e.g. modifier on Send, or a distinct control) since it is a + force/override, not the default. +- This makes the "wait until the turn ends, or force a steer" reality first-class + instead of implicit. Requires the server contract to distinguish queue vs steer + per provider (see open question). +- Keep the plan Q&A / follow-up branches at higher priority than this toggle. + +### Phase 4 — turn liveness guarantee (fixes Issue 4) + +This is the phase that directly kills the "Working for 8h" state. Two layers: + +- **Server-side stall detection (authoritative).** Track a last-activity + timestamp per running turn in the orchestration engine and add a bounded + idle/heartbeat timeout. If no provider stream activity (tokens, tool events, + approvals) arrives within the window, emit a synthetic + `turn.completed`/failed (e.g. status `stalled`) so `completedAt` is set and + the session leaves `running`. Target the ingestion / reactor around + `apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts:1257-1645` + and `ProviderCommandReactor.ts`. Also verify provider-process exit / + `session.exited` always finalises the active turn (a crashed provider must not + leave a `running` session). +- **Client-side settled reconciliation + honest timer (defensive).** When a full + thread snapshot arrives, trust it over any stale `running` status; and cap / + qualify the `WorkingTimer` — after an unreasonable threshold show an + "unresponsive / may be stalled" state with a recover action instead of a bare + ever-growing counter (`MessagesTimeline.tsx:1082-1102`, + `isLatestTurnSettled` at `session-logic.ts:294`). + +### Phase 5 — transport hardening (reduces recurrence of 1, 2 & 4) + +- Introduce a small **outbound command queue** in the client runtime so + `dispatch` for user-initiated commands (start turn, interrupt) survives a + brief reconnect instead of failing at `currentSession()` + (`packages/client-runtime/src/rpc/client.ts:88-124`). Bound it and drop with a + visible notice on prolonged disconnect. +- Document and test the interaction between the supervisor's reconnect backoff + (`supervisor.ts`, 1→16 s) and command delivery, so the acknowledgement model + in Phase 1 has defined behaviour across reconnects. + +## Open questions + +- **Send-while-running semantics (queue vs steer).** A message sent during a + running turn should support both **queue** (deliver after the turn ends — + Codex's default) and **steer** (inject into the running turn now — Codex + "steer"). Confirm what each provider (Codex / Claude / Cursor / OpenCode) + supports, and how the server should model it: the current path emits a user + message + turn-start on `thread.turn.start` (`decider.ts`) with no notion of a + queued or steering message — determine whether concurrent turn-starts are + queued, rejected, or need a new command/field to carry the queue-vs-steer + intent. +- **Acknowledgement source of truth.** Confirm whether `dispatchCommand` can + return an accepted-command id today, or whether the contract in + `packages/contracts/src/orchestration.ts` needs a new result field. +- **Stall threshold & heartbeats.** What idle window counts as "stalled" per + provider (Codex / Claude / Cursor / OpenCode), and do any of them emit a + keepalive/heartbeat we can key off instead of a blind timeout? A long tool + call or a slow model must not be misclassified as stalled. Confirm every + provider path finalises the active turn on process exit. + +## Upstream tracking (pingdotgg/t3code) + +As of 2026-07-04 every symptom here is already reported upstream; all are **open +issues** and there are **no open PRs** addressing them. #231 is the only one +marked in progress. + +- **Issue 1 — stuck send / can't send while working** + - [#2173](https://github.com/pingdotgg/t3code/issues/2173) — Stuck 'working' + icon after prompt, **can't send more prompts** (bug, needs-triage). + - [#379](https://github.com/pingdotgg/t3code/issues/379) — Sending message box + getting stuck (Linux app). + - [#1048](https://github.com/pingdotgg/t3code/issues/1048) — Threads get stuck + on "waiting for 0s". +- **Principle — must keep sending even when a turn won't complete** + - [#1297](https://github.com/pingdotgg/t3code/issues/1297) — No way to + background or kill a long-running process, **blocking further prompts/chats**. +- **Issue 2 — abort unreliable** + - [#2573](https://github.com/pingdotgg/t3code/issues/2573) — Opencode: steering + breaks session tracking and **stop doesn't work after steer**. +- **Issue 3 — send-while-running (queue vs steer)** + - [#231](https://github.com/pingdotgg/t3code/issues/231) — feat: add **Steer and + Queue** follow-up modes (enhancement, 🚧 In Progress). Directly matches Phase 3. +- **Issue 4 — turns stuck "running" for hours / lost completion** + - [#917](https://github.com/pingdotgg/t3code/issues/917) — Proposal: **recover + stuck running turns when turn/completed is lost** after long command + execution. Directly matches Phase 4 (server-side liveness). + - [#2644](https://github.com/pingdotgg/t3code/issues/2644) — Chat shows + "working..." **indefinitely** after opencode CLI already finished. + - [#2778](https://github.com/pingdotgg/t3code/issues/2778) — Session hung + forever after spawning subagents. + - [#3580](https://github.com/pingdotgg/t3code/issues/3580) — [orchestrator-v2] + Grok steer rows vanish and **runs wedge on Working** after reply. +- **Phase 5 — transport / desync (contributing cause)** + - [#3054](https://github.com/pingdotgg/t3code/issues/3054), + [#2750](https://github.com/pingdotgg/t3code/issues/2750) — WS + disconnect/reconnect loops leaving threads desynced on lossy links. + - [#2065](https://github.com/pingdotgg/t3code/issues/2065) — thread becomes + inconsistent after closing the app during execution. + +## Key references + +| Concern | Location | +| ---------------------------------------- | ---------------------------------------------------------------------------- | +| Phase derivation | `apps/web/src/session-logic.ts:1381` | +| `SessionPhase` type | `apps/web/src/types.ts:19` | +| Session status enum | `packages/contracts/src/orchestration.ts:260` | +| Optimistic dispatch state | `apps/web/src/components/ChatView.tsx:362-421` | +| Ack heuristic | `apps/web/src/components/ChatView.logic.ts:416-462` | +| `onSend` guard | `apps/web/src/components/ChatView.tsx:3900-3909` | +| Enter handler | `apps/web/src/components/chat/ChatComposer.tsx:1727-1758` | +| Primary button branch | `apps/web/src/components/chat/ComposerPrimaryActions.tsx:75-228` | +| `onInterrupt` | `apps/web/src/components/ChatView.tsx:4291-4304` | +| Interrupt input builder | `apps/web/src/components/ChatView.logic.ts:77-86` | +| Turn-settled predicate | `apps/web/src/session-logic.ts:294-303` | +| "Working for" row + unbounded timer | `apps/web/src/components/chat/MessagesTimeline.tsx:1053-1102` | +| `activeTurnInProgress` gate | `apps/web/src/components/ChatView.tsx:5126` | +| Turn completion ingestion | `apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts:1257-1645` | +| Only load-time timeout (no turn timeout) | `apps/server/src/provider/acp/AcpSessionRuntime.ts:49-50` | +| Dispatch funnel | `packages/client-runtime/src/operations/commands.ts:78` | +| RPC availability gate | `packages/client-runtime/src/rpc/client.ts:88-124` | +| No RPC-level retry | `packages/client-runtime/src/rpc/session.ts:99-102` | +| Reconnect backoff | `packages/client-runtime/src/connection/supervisor.ts:32-104` | +| Server interrupt (by session) | `apps/server/src/orchestration/Layers/ProviderCommandReactor.ts:879-898` | +| Interrupt decider | `apps/server/src/orchestration/decider.ts:468-488` | diff --git a/docs/internals/conversation-search.md b/docs/internals/conversation-search.md new file mode 100644 index 000000000000..645da0c1cda7 --- /dev/null +++ b/docs/internals/conversation-search.md @@ -0,0 +1,153 @@ +# Conversation Search — State, Gap Analysis & Design Notes + +Agent tools across the ecosystem (Codex CLI, Claude CLI, VS Code chat) ship rich +_scoped_ search — command palettes, model/file pickers — but almost none let you +**search the content of your past conversations**. T3 Code is largely the same. +This document records what search exists today, what's missing, why the gap is +so common, the upstream issues/PRs that track it, and a design sketch for +closing it. + +## What "search" exists in T3 Code today + +There is a lot of _scoped picker_ search, all built on the shared ranking +helper `normalizeSearchQuery` / `scoreQueryMatch` +(`packages/shared/src/searchRanking.ts`): + +- **Command palette** — searches **thread titles** and project titles/paths, and + lists recent threads (`RECENT_THREAD_LIMIT = 12`, + `apps/web/src/components/CommandPalette.logic.ts`). It does **not** match + message content. +- **Model picker** (`apps/web/src/components/chat/modelPickerSearch.ts`), + **file browser** (`apps/web/src/components/files/FileBrowserPanel.tsx`), + **composer slash-commands** (`composerSlashCommandSearch.ts`), **path / skill + autocomplete** (`providerSkillSearch.ts`, `lib/composerPathSearchState.ts`). + +All of these are "pick a known entity by name" search — none of them search the +transcript. + +## What's missing + +### 1. In-thread content find (Cmd/Ctrl+F) — _in progress_ + +There is no in-thread find on `main`. Native browser / Electron find does not +work because the transcript is **virtualized** (`LegendList`): off-screen +messages are not in the DOM, so a browser find misses most of the conversation. + +This is being addressed by **open PR +[#3539](https://github.com/pingdotgg/t3code/pull/3539) — feat(web): add +Ctrl/Cmd+F find-in-chat** (branch `feat/find-in-chat`). Its approach is the +correct one: **search the data model, not the DOM** — `chatSearch.ts` projects +each timeline entry (user/assistant messages, tool/work entries, proposed plans, +including collapsed content) to searchable text, renders a floating find bar +with an `N/total` counter, Enter / Shift+Enter (or ↑/↓) navigation, and match +highlighting. It answers issue +[#1486](https://github.com/pingdotgg/t3code/issues/1486)'s in-thread half. + +### 2. Cross-thread content search — _unaddressed_ + +The real gap. You cannot search the _content_ of past conversations across all +threads — only jump to a thread by **title**. The canonical use case +(from [#3509](https://github.com/pingdotgg/t3code/issues/3509)): "I remember +solving a bug or writing a snippet in some session weeks ago" — today the only +recourse is to remember the thread's title. There is **no issue-linked PR** and +no implementation. + +### 3. Sidebar / thread filtering — _adjacent, unaddressed_ + +Not content search, but the same "find the right thread among many" problem: +global thread filters in the Projects sidebar +([#1043](https://github.com/pingdotgg/t3code/issues/1043)) and archive +enhancements ([#2935](https://github.com/pingdotgg/t3code/issues/2935)). + +## Why this gap is near-universal + +It is not a simple oversight; several forces push it below the fold everywhere: + +1. **The data model fights it.** Transcripts are not flat text — they are event + streams (user turns, streamed assistant deltas, reasoning, tool calls, diffs, + approvals, images). "Search" first requires deciding _what a hit is_ (my + prompt? assistant prose? tool stdout? a path inside a diff?). PR #3539's + "project each entry to searchable text" is exactly this decision made + explicit — and it is real design work, not a checkbox. +2. **Built around the current task, not an archive.** History is treated as + scrollback. CLIs punt hardest — the terminal/pager "already owns" find, so + authors assume you scroll or `grep` the session file. +3. **Indexing is unglamorous infra.** Cross-thread content search wants a + persistent, maintained full-text index (e.g. SQLite FTS). History is often + append-only JSONL (Codex/Claude session files) or, in T3 Code, server-side + event-sourced projections. An index means write-path cost, migrations, and + staleness handling — easy to defer while a product is young. +4. **It pays off late.** Search only becomes valuable once there is a lot of + history worth searching, so it sits behind provider support, reliability, and + new-model work on the roadmap. +5. **The "ask the agent" bet.** The implicit philosophy is that you _ask_ the + agent to recall instead of searching a UI. Memory/RAG is meant to replace + search — but it is lossy today, so the replacement under-delivers and no + fallback UI was built. +6. **VS Code chat specifically** grafts chat onto an editor whose identity _is_ + search (files, symbols, ripgrep); the team polished editor search and treated + chat as a transient side panel. + +## Why T3 Code is well-positioned to fix it + +Unlike the file-based CLIs, T3 Code already has the substrate for real search: + +- A **server-side store with event-sourced thread/message projections** + (`apps/server/src/orchestration/…`) — the messages are already persisted and + queryable server-side, not just scrollback. +- A **command palette** that is the obvious home for a "Search conversations…" + entry (`apps/web/src/components/CommandPalette.tsx`). +- A **shared ranking helper** (`packages/shared/src/searchRanking.ts`) and now, + via PR #3539, a **timeline-entry-to-text projection** (`chatSearch.ts`) that a + server-side indexer could reuse for consistent hit semantics. + +## Design sketch (cross-thread content search) + +Non-binding, to seed discussion on #3509: + +- **Index server-side.** Add a full-text index over message/turn content in the + orchestration store (SQLite FTS5 or equivalent), populated from the same + projection pipeline that already writes thread history. Reuse PR #3539's + entry→text projection so in-thread find and cross-thread search agree on what + is searchable. +- **Expose a `searchThreads`/`searchMessages` RPC** in the orchestration + contract (`packages/contracts/src/orchestration.ts`) returning ranked hits + with `threadId`, message id, and a snippet + offsets for highlighting. +- **Surface in the command palette** as a dedicated "Search conversations" mode + (distinct from the current title/recent-thread mode), with result rows that + deep-link to the thread and scroll/highlight the matching entry (reusing the + find-in-chat highlight from #3539). +- **Scope & filters.** Support project scoping and the sidebar filters from + #1043 (status/archived) as search facets so the two features compose. +- **Incremental delivery.** (a) ship in-thread find (#3539) → (b) title + + content search of _loaded_ threads client-side → (c) server-side FTS across + all threads. Each step is independently useful. + +## Upstream tracking (pingdotgg/t3code) + +As of 2026-07-04: + +| Item | Type / State | Relevance | +| ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | -------------------------------------------------------------------------- | +| [#3539](https://github.com/pingdotgg/t3code/pull/3539) — feat(web): add Ctrl/Cmd+F find-in-chat | **PR, open** | In-thread find (data-model based). Implements the in-thread half of #1486. | +| [#1486](https://github.com/pingdotgg/t3code/issues/1486) — Add search within the thread/chat | Issue, open (enhancement, needs-triage) | In-thread find **+** sidebar search. Partially covered by #3539. | +| [#3509](https://github.com/pingdotgg/t3code/issues/3509) — Search across all threads by message content (not just titles) | Issue, open | **The core gap.** No PR. | +| [#1043](https://github.com/pingdotgg/t3code/issues/1043) — Global thread filters in Projects sidebar | Issue, open (enhancement) | Adjacent: filter, not content search. Compose as facets. | +| [#2935](https://github.com/pingdotgg/t3code/issues/2935) — Archive enhancements | Issue, open | Adjacent: archived-thread discoverability. | + +**Summary:** in-thread find has an in-flight PR (#3539); cross-thread content +search (#3509) is the unaddressed piece and the highest-leverage feature to add, +and T3 Code's event-sourced store makes it more tractable here than in any +file-based CLI. + +## Key references + +| Concern | Location | +| ------------------------------------- | --------------------------------------------------------------------------------------------------- | +| Shared search ranking | `packages/shared/src/searchRanking.ts` | +| Command palette (title/recent search) | `apps/web/src/components/CommandPalette.logic.ts` | +| Model picker search | `apps/web/src/components/chat/modelPickerSearch.ts` | +| Slash-command / path / skill search | `apps/web/src/components/chat/composerSlashCommandSearch.ts`, `apps/web/src/providerSkillSearch.ts` | +| File browser search | `apps/web/src/components/files/FileBrowserPanel.tsx` | +| Orchestration store / projections | `apps/server/src/orchestration/` | +| Orchestration contract (RPC surface) | `packages/contracts/src/orchestration.ts` | diff --git a/docs/internals/overview.md b/docs/internals/overview.md index b348a0ac0882..c126e910007d 100644 --- a/docs/internals/overview.md +++ b/docs/internals/overview.md @@ -77,6 +77,9 @@ must reject that operation before changing the filesystem. Tests use [drainable workers](../../packages/shared/src/DrainableWorker.ts) to wait until both the queue and its current item have finished. An empty queue alone does not prove the worker is idle. +Provider command dispatch is keyed by thread: FIFO within a thread, concurrent across threads, with +lazy ephemeral lanes so only threads with work consume one. + Runtime receipts mark specific test milestones. Their [production layer](../../apps/server/src/orchestration/Layers/RuntimeReceiptBus.ts) is a no-op; production behavior must use persisted state and events. These test signals are separate from the diff --git a/docs/internals/providers.md b/docs/internals/providers.md index ec40c49810dc..6d7991fe0b4f 100644 --- a/docs/internals/providers.md +++ b/docs/internals/providers.md @@ -9,6 +9,10 @@ A driver kind identifies an integration; an instance identifies one configuratio lifecycle. Route work by instance, so two accounts using the same driver do not share mutable session or catalog state. +Provider command work is FIFO within a thread and concurrent across threads. Lanes are lazy and +ephemeral: they exist only while a thread has queued or active work, and deleting a thread +interrupts its lane. A stalled provider must not block unrelated conversations. + ## Process and account isolation T3-managed OpenCode chat uses one server per thread. Its MCP registrations are directory-scoped, while @@ -39,7 +43,10 @@ and removal must respect those leases instead of replacing executables under a r Opening a provider session can start MCP servers, run hooks, or launch a login browser. [Grok probes](../../apps/server/src/provider/Layers/GrokProvider.ts) avoid authentication and -session creation for this reason. Antigravity likewise reserves authenticated catalog sessions for +session creation for this reason. The built-in `grok-build` slug is the CLI product name, not an ACP +model id; treat it as "keep the session's current model" and never send it in `session/set_model`. +A failed `initialize` during a probe should degrade to a warning with the CLI model list, not persist +`error` over a working install. Antigravity likewise reserves authenticated catalog sessions for explicit setup or model refresh; background checks use initialization only. [Antigravity sign-in](../../apps/server/src/provider/AntigravityAuth.ts) belongs to the initiating diff --git a/docs/operations/ci.md b/docs/operations/ci.md new file mode 100644 index 000000000000..679af8b1f998 --- /dev/null +++ b/docs/operations/ci.md @@ -0,0 +1,12 @@ +# CI quality gates + +- `.github/workflows/fork-ci.yml` runs the fork quality gates for pull requests targeting + `fork/dev` and for pushes to `fork/dev`. The inherited upstream `ci.yml` workflow is disabled so + updates to the `main` mirror do not duplicate those checks. +- The inherited upstream `release.yml` (T3 Connect nightly on a three-hour cron, plus tag/desktop + GitHub Releases) and `deploy-relay.yml` workflows are disabled at repository level. This fork does + not deploy T3 Connect. Fork desktop and mobile shipping uses Fork Release, not `release.yml`. +- Upstream `release.yml` builds macOS (`arm64` and `x64`), Linux (`x64`), and Windows (`x64`) + desktop artifacts from a single `v*.*.*` tag. Leave it disabled here; do not re-enable it to + “fix” the red scheduled Release job. +- See [Release Checklist](./release.md) for the full release/signing setup checklist. diff --git a/docs/operations/mobile-app-store-screenshots.md b/docs/operations/mobile-app-store-screenshots.md index 0e3c1784429b..8e09bc06eb2c 100644 --- a/docs/operations/mobile-app-store-screenshots.md +++ b/docs/operations/mobile-app-store-screenshots.md @@ -105,8 +105,8 @@ Run the `Mobile Showcase Screenshots` workflow from GitHub's Actions tab, choose `android`, select `light`, `dark`, or `both`, and pick a palette (or `all`, which raises each job's timeout from 60 to 300 minutes). The default dispatch captures both appearances of the `t3-code` palette and runs iOS and Android concurrently: iPhone and iPad capture on a -12-vCPU Blacksmith macOS runner, while Android phone, 7-inch tablet, and 10-inch tablet capture on a -16-vCPU Blacksmith Linux runner with a KVM-accelerated x86_64 emulator. +GitHub-hosted macOS runner, while Android phone, 7-inch tablet, and 10-inch tablet capture on a +GitHub-hosted Linux runner with an x86_64 emulator. Every job uploads its PNGs even when capture fails, which makes partial runs useful for diagnosis. The separate validation step is success-gated: it runs before upload only when capture succeeds. If diff --git a/docs/planning/linear-adapter.md b/docs/planning/linear-adapter.md new file mode 100644 index 000000000000..afe12833d29e --- /dev/null +++ b/docs/planning/linear-adapter.md @@ -0,0 +1,50 @@ +# Linear adapter + +Notes for a Linear adapter following Jira (`ntbs-todos.md`). Facts checked September 2026. + +## API surface + +- One GraphQL endpoint: `https://api.linear.app/graphql`. No REST. `@linear/sdk` is optional; this adapter needs a handful of mutations/queries. +- App errors hide behind HTTP 200: check the `errors` array and `success: false` on mutation payloads; rate limits return 400 with `extensions.code: "RATELIMITED"`. +- Rate limits are leaky buckets: 2,500 req/h per user (API key), 5,000 (OAuth app), plus complexity caps (10,000 points per query). Read `X-RateLimit-*` headers. +- Relay-style cursor pagination, 50 records default. + +## Auth + +- Personal API key: simplest; actions are attributed to the user. Scopeable read/write/admin, optionally team-limited. +- OAuth2 with `actor=app` installs the app as a workspace actor with its own identity — required for Agent Sessions. Access tokens last ~24 h; refresh rotates with a 30-minute replay grace. +- OAuth apps can register their webhook automatically per installing organization, each with its own signing secret. + +## Webhooks + +- Verify `Linear-Signature`: hex HMAC-SHA256 of the raw body (never re-stringify). Also check `webhookTimestamp` is within ~60 s (replay guard). +- Respond 200 within 5 s, or Linear retries 3 times (1 m, 1 h, 6 h) and may disable the webhook. +- Headers: `Linear-Delivery` (UUID per delivery — the dedup key), `Linear-Event`, `Linear-Timestamp`. Body: `action` create/update/remove, `type` (Issue, Comment, …), `data`, `updatedFrom`, `actor`. +- Resource types include Issue, Comment, Comment reaction, Issue attachment, Project, Document, Cycle. + +## Agent Sessions (Developer Preview) + +Purpose-built for coding agents: delegating an issue to the app or mentioning it creates an `AgentSession` and pushes `AgentSessionEvent` webhooks (`created`, `prompted`). + +- After `created`, emit an activity within 10 s or the session renders unresponsive. (Webhook itself must 2xx within 5 s.) +- Outbound: `agentActivityCreate` with `thought`, `action` (action/parameter/result), `elicitation`, `response`, or `error`. Markdown; `thought`/`action` may be ephemeral. A `response` also creates an issue comment. +- `agentSessionUpdate` sets the plan (`pending|inProgress|completed|canceled`, tech preview) and external URLs. Activities carry signals: `stop`, `auth`, `select` (elicitation options). A `prompted` payload carries the user's message and its signals. +- Sessions can exist without an issue (document/editor mentions) — handle or reject explicitly. +- Enabling the webhook category immediately exposes Agent Session UI to workspace users. + +## Mapping onto NTBS + +- The port (`apps/server/src/ntbs/adapter.ts:31-56`) is outbound-only; inbound parsing and the webhook route live outside it. + - `acknowledge` → `thought`; `postReply` → `response` (answer) or `error` (failure); `findPostedReply` → query `agentSession.activities` and match the exact stored body (frozen, queryable — a clean recovery story). +- `sourceUri`: `linear:///agent-session/` meets both contracts (stable identity, cold-start addressability). +- Inbound route mirrors `apps/server/src/jira/http.ts`: verify signature, dedup on `Linear-Delivery` (persist like `JiraDeliveryStore.ts`), respond 200/202 immediately, fork processing. +- Config mirrors `jira/JiraAppConfig.ts` (`T3CODE_LINEAR_*`: token/secret, mention, allowed teams, project map, base branch). + +## Risks / open decisions + +1. **Ack deadline vs provisioning.** NTBS acknowledges only after thread provisioning (`processor.ts:346-347`), which includes worktree creation and setup scripts and can exceed 10 s. Either the webhook handler emits the initial `thought` before handing off, or the ack moves earlier. +2. **Preview API and the alternative.** Agent Sessions are a Developer Preview and validate activity shapes server-side. The comment-mention bridge is the GA, Jira-shaped fallback: no session UI, plan, or elicitation, and no 10 s deadline. +3. **Follow-ups.** NTBS models one exchange per thread, and `T3Target` only mints new threads. Decide how a `prompted` message continues an existing session, and where a `stop` signal lands (the adapter cannot reach the processor mid-exchange). +4. **Prerequisites.** `makeNTBSProcessor` is not wired into the server, the repository is in-memory, and `findNonTerminalExchanges` lacks a platform filter (`processor.ts:178-186`), so two processors would re-drive each other's exchanges. `SourceChannel` has no `"linear"` (`packages/contracts/src/identity.ts:60-73`) and NTBS turns do not stamp `source`; decide attribution when wiring. + +Sources: [GraphQL](https://linear.app/developers/graphql), [webhooks](https://linear.app/developers/webhooks), [agent interaction](https://linear.app/developers/agent-interaction), [agent best practices](https://linear.app/developers/agent-best-practices), [rate limiting](https://linear.app/developers/rate-limiting), [actor authorization](https://linear.app/developers/oauth-actor-authorization). diff --git a/docs/planning/ntbs-todos.md b/docs/planning/ntbs-todos.md new file mode 100644 index 000000000000..912c67cafeae --- /dev/null +++ b/docs/planning/ntbs-todos.md @@ -0,0 +1,42 @@ +# NTBS todos + +The exchange model, ports, processor, and T3 gateway are implemented under `apps/server/src/ntbs/`. This file tracks only what is still open. Findings referenced by id are in `review-01-09.md`. + +## Other review items + +- [ ] Review user-facing error messages. +- [ ] In `processor.test.ts`, replace `settle()` with an explicit completion signal where assertions require a finished pass, especially before interrupting after a failed reply post. Quiet call logs do not prove completion: a pass waiting on a timer or Deferred also looks quiet, so these tests can pass before the behavior they mean to check occurs. + +## Next + +- [ ] Jira port as the first real adapter, replacing the legacy bridge path. +- [ ] SQL `ExchangeRepository`: `sourceUri` primary key, unique `threadId` index (NULLs allowed) — one exchange per thread, both lookups indexed. +- [ ] Wire `makeNTBSProcessor` into the server with a real adapter and SQL repository; verify persistence and recovery across restarts. + +## Review fork-specific provenance after the NTBS migration + +Keep `SourceChannel`, `SourceRef`, `sourceHint`, `originSource`, and related fork-specific provenance out of the NTBS design. Adapters already retain the platform data needed to connect external messages with T3 work. + +After every external platform has moved to NTBS, remove obsolete integration logic. Review provenance fields separately: they also support participant attribution, ownership filters, and source badges in clients, so migration alone does not make them redundant. + +## Decide thread archival after testing + +Keep NTBS-created T3 threads after their responses are posted for now. Once the workflow has been tested in practice, decide whether completed threads should be archived automatically and under which conditions. + +## Inbound triggers and reply delivery + +- [ ] Define when an edit counts as a first invocation and which snapshot is accepted when deliveries arrive late or out of order. `sourceUri` deduplicates accepted requests; platform-specific inbound code must decide which events to submit. +- [ ] Decide reply placement for each platform so final delivery works even if acknowledgement fails. For Discord, replying to the invoking message fits the current contract; replying to the acknowledgement requires locating a message whose ID NTBS does not retain. +- [ ] Investigate provider requests for user input: NTBS forwards settled outcomes, so a turn waiting for input may remain active until timeout. Decide how to handle this without relying on interactive platform controls. + +## Concurrency choreography + +We've got lots of code that does locking, queueing, concurrency bonding for exchanges, etc, etc that is now a bit spread over the whole processor and hard to follow. + +Activity handling has since collapsed into one queue-and-worker pipeline inside `run`; what remains spread out is the per-exchange lock and the pass helpers (`resumeExchange`, `tryResumeExchange`, `advanceSavedExchange`). + +We need to investigate whether it can be simplified or abstracted to its own module so processor stays as simple as possible and concurrency logic is easier to test and verify. + +## Integration tests + +- [ ] Against the real `OrchestrationEngine` + sqlite: dispatch `thread.turn.start` through the real engine, then read `getTurnStatus`. The whole design rests on dispatch being synchronous with projection, which `t3gateway.ts:184-186` notes no test in this package would notice if it broke; the test would also have caught the provider-failure retry loop fixed on 2026-09-02. diff --git a/docs/project/wishlist.md b/docs/project/wishlist.md new file mode 100644 index 000000000000..b87f077182df --- /dev/null +++ b/docs/project/wishlist.md @@ -0,0 +1,217 @@ +# Project Wishlist + +Personal feature ideas for T3 Code, captured before they're ready to be filed +upstream or built. Each entry states the problem, a proposed shape, and the +smallest useful scope. Promote an entry to an upstream issue / implementation +when it's ripe. + +--- + +## Reopen existing worktrees without an active thread + +**Status:** idea · **Area:** apps/web + apps/server (composer workspace picker, VCS RPC) + +### Problem / use case + +Worktrees are currently discoverable through threads and indirectly through the +ref picker. If every thread associated with a worktree has been closed, the +worktree disappears from the sidebar even though it still exists on disk. + +It is possible to create a draft in **Current checkout**, open the ref picker, +and select a ref marked `worktree`, but that path is not obvious. A user looking +for a workspace reasonably expects the workspace picker to list it. + +### Proposed solution + +Extend the existing **Current checkout** workspace dropdown to include existing +worktrees for the selected project and environment: + +- Keep **Current checkout** and **New worktree** as the primary choices. +- Add an **Existing worktrees** group showing the branch/ref and a compact path. +- Selecting one creates or updates the draft with its `branch`, `worktreePath`, + and worktree environment mode; it must reuse the checkout without running + `git worktree add` or switching its ref. +- Make the worktree group searchable and give the popup a bounded height with + proper keyboard-accessible scrolling/virtualization. Repositories may have + many worktrees, so the list must not grow the dropdown beyond the viewport. +- Keep the ref picker's existing `worktree` badges as a complementary shortcut. + +### Smallest useful scope + +List attached, branch-backed worktrees in a scrollable **Existing worktrees** +section of the workspace picker and allow opening a new draft in the selected +worktree. Refresh the list when the picker opens and after worktree creation or +removal. + +### Design notes + +- The current ref-list implementation already reads + `git worktree list --porcelain` and exposes a `worktreePath` on matching local + refs. This can support a prototype. +- Prefer a dedicated `vcs.listWorktrees` RPC for the durable implementation so + discovery is independent of ref search/pagination and can include detached + HEAD worktrees and explicit prunable/missing-state handling. +- Worktree identity should be its canonical path, not its branch name. Branch + and final path segment are display metadata. +- Scope discovery to the selected project and execution environment; a local + worktree path is not assumed to exist in another environment. +- The existing **Current checkout** wording should remain unchanged. It refers + to the project's primary checkout; existing worktrees are additional choices + in the same workspace menu. + +### Open questions + +- Should existing worktrees appear only in the composer workspace picker, or + also as threadless groups in the project sidebar? +- Should missing/prunable worktrees be hidden, disabled with an explanation, or + offered with a prune action? +- When the list is long, is one searchable combined workspace menu sufficient, + or should **Existing worktrees…** open a dedicated combobox/submenu? + +--- + +## Per-project idea queue + pluggable integrations (deferred, provider-agnostic drafts) + +**Status:** idea · **Area:** apps/web + apps/server (orchestration, MCP/RPC) + +### Problem / use case + +I frequently want to jot down an idea the moment it occurs, but often I can't or +don't want to dispatch it to an agent right then: + +- My AI credits have run out, so no provider can run it now. +- I haven't decided **which** provider/model I want to handle the idea. +- The idea is half-formed and I want to keep writing without starting a turn. + +Today the composer is coupled to _sending_: to write the idea down I effectively +have to commit to a thread, a provider, and a model, and (for anything to +persist meaningfully) dispatch it. There's no first-class place to park a +provider-agnostic draft and decide later. + +### Proposed solution + +A **per-project idea queue** — a lightweight, offline, provider-agnostic inbox of +draft prompts/ideas scoped to a project: + +- Write freely into the queue with no provider, model, or credits required, and + no turn started. Drafts persist per project. +- Each queued item can carry attachments/context the composer already supports + (images, file/terminal/element contexts) without being tied to a live session. +- Later, **promote** a queued item: choose the provider + model (+ effort / + interaction mode) at submit time, which creates/opens a thread and dispatches + it as a normal turn. +- Manage the queue: edit, reorder, delete, and ideally tag/title items. + +**Key framing:** all the integration ideas below are the same primitive wearing +different clothes — an idea queue with an _open ingestion path_ and optional +_result write-back_. Build the queue so anything can push items in and read the +outcome, and external tools (Obsidian, GitHub, shortcuts, other agents) become +**thin adapters** rather than bespoke features. The design question is therefore +"what is the ingestion/write-back contract," then "which adapters ship first." + +### Smallest useful scope + +A per-project list of plain-text draft prompts you can add to without any +provider selected, and a "Send to…" action that opens the provider/model picker +and dispatches the draft into a new thread. Attachments, reordering, and tagging +are follow-ups. + +### Design notes + +- **Storage.** Drafts are provider-agnostic and must outlive any session, so they + belong in the project's persisted state (server-side, alongside project / + thread data in the orchestration store) rather than transient composer draft + state. Reuse the existing composer-draft content model where possible so + promotion re-hydrates attachments/contexts cleanly. +- **Decoupling from dispatch.** This reinforces the composer principle in + [composer-turn-lifecycle.md](../architecture/composer-turn-lifecycle.md): input + and drafting should never require an active turn, a chosen provider, or + connectivity. An idea queue is the extreme case — drafting with _no_ provider + at all. +- **Promotion = normal turn start.** Submitting a queued idea should funnel + through the same `thread.turn.start` path as any message, with the queue item + supplying the prompt + contexts; no special-case send path. +- **Relationship to "send while running."** A queue is the offline sibling of the + queue/steer follow-up modes discussed for running turns + ([#231](https://github.com/pingdotgg/t3code/issues/231)); worth keeping the UX + vocabulary ("queue") consistent between the two. + +### Integrations (pluggable sources & sinks) + +Grouped by capture _mood_ — these are complementary, not redundant: private +free-form thinking vs. shareable actionable work vs. universal quick capture. + +**Backbone (build these first — they make every adapter cheap):** + +- **Watched drop-folder.** A per-project `ideas/` folder (or a configured vault + subfolder) of markdown files. t3code reads/writes it; any external editor edits + the same files. Bidirectional by construction — no API, no auth. This alone + makes the Obsidian case essentially free. +- **Open ingestion endpoint.** t3code already exposes an **MCP server** + (`mcp__t3-code__*`) and a WS/RPC API. Add an `enqueue idea` tool/endpoint so + _anything_ can feed a project's queue: an Obsidian plugin, a shortcut, a + webhook, or another agent. Build the queue against this contract and the + adapters below are ~20 lines each. + +**File-based adapter — Obsidian (the private-thinking end):** + +- A vault is just a folder, so point the queue at a vault subfolder. Jump + t3code → note via `obsidian://open?vault=…&file=…`; jump note → t3code via a + t3code URL/protocol handler (desktop can register one) or an Obsidian button + that writes into the drop-folder. +- Use frontmatter for metadata (`status: queued|dispatched`, `provider`, + `model`, `project`). **Write-back:** append the turn's result to the source + note, closing the loop ("bring an idea from notes → execute → answer lands back + in notes"). + +**API-based adapter — GitHub Issues (the shareable-work end):** + +- Ideas as issues with a `t3code-idea` label or a project-board column. t3code + lists them and offers "dispatch this issue as a turn"; on completion it + comments the result or opens a PR. This **compounds with t3code's existing + branch/PR integration** — "issue in → turn → PR out" is a natural loop. +- Trade-off vs. Obsidian: issues are shareable, collaborative, actionable, and + cross-device, but heavier and more public — great for "this is real work," bad + for half-formed private thoughts. Different mood, not a duplicate. + +**Quick-capture front-ends (low-friction entry the moment the idea strikes):** + +- CLI verb `t3 idea add "…"` (the server CLI already has `project` / `auth` + subcommands; an `idea` verb fits). +- OS layer: Raycast / Alfred command, macOS Shortcuts / share sheet, a global + hotkey, or email-to-queue. +- Editor command: "Send selection to t3code idea queue" (VS Code / Zed / + Obsidian). + +**Task managers as the inbox:** + +- Linear / Todoist / Things / Apple Reminders tagged `@t3code`; t3code pulls + tagged items, dispatches, and marks them done on completion. Same pattern as + GitHub Issues, different home. + +**Recommended sequencing:** drop-folder + MCP/API enqueue endpoint (core) → +Obsidian (first file adapter) → GitHub Issues (first API adapter, reuses PR +machinery) → everything else as optional adapters. + +### Open questions + +- **Which adapters first?** Recommendation above (drop-folder + API, then + Obsidian, then GitHub Issues) — confirm priority. +- **Conflict / sync semantics** for the drop-folder: t3code and Obsidian editing + the same file concurrently — last-writer-wins, or a lightweight merge/lock? +- **Write-back placement:** append results into the source note/issue, or keep + the t3code thread as the source of truth and only link back? Probably link + + optional append. +- One flat queue per project, or per-thread queues too (park a follow-up against + a specific conversation)? +- Should a queued item remember a _preferred_ provider/model (optional default) + while still allowing a choice at submit time? +- Does an idea queue overlap enough with saved snippets + ([#1547](https://github.com/pingdotgg/t3code/issues/1547)) to share a surface, + or are they distinct (reusable snippets vs. one-shot deferred ideas)? + +### Related + +- Composer-must-stay-usable principle: [composer-turn-lifecycle.md](../architecture/composer-turn-lifecycle.md) +- Queue/steer follow-up modes: [#231](https://github.com/pingdotgg/t3code/issues/231) +- Saved snippets for frequent prompts: [#1547](https://github.com/pingdotgg/t3code/issues/1547) diff --git a/docs/reference/scripts.md b/docs/reference/scripts.md new file mode 100644 index 000000000000..dd63c9a10242 --- /dev/null +++ b/docs/reference/scripts.md @@ -0,0 +1,56 @@ +# Scripts + +- `vp run dev` — Starts contracts, server, and web in watch mode. +- `vp run dev --share` — Also publishes the web port over HTTPS on this machine's tailnet. The startup pairing URL is built against the shared origin, and the mapping is removed on exit. +- `vp run dev:server` — Starts just the WebSocket server. The server process runs on Bun (`@effect/platform-bun` + `BunPtyAdapter`), but task running uses `vp run`. +- `vp run dev:web` — Starts just the Vite dev server for the web app. +- Dev commands run from a linked **git worktree** default to that worktree's gitignored `.t3`, even when `T3CODE_HOME` is set, storing state in `/.t3/userdata`. Pass `--home-dir ` to choose another isolated directory explicitly. Submodules are not worktrees and keep the normal precedence. +- From the **main checkout**, dev commands implicitly use `~/.t3/dev`, keeping development state separate from `~/.t3/userdata`. An explicit `--home-dir ` stores state under `/userdata`; the base directory remains available for caches, worktrees, and other shared data. +- Web dev commands do not auto-open a browser. Open the one-time pairing URL printed by the server so the first browser navigation is authenticated. Set `T3CODE_NO_BROWSER=0` only when interactive auto-open is intentional. +- Pass dev-runner flags directly after the root task name, for example: + `vp run dev --home-dir /tmp/t3code-dev` +- `vp run start` — Runs the production server (serves built web app as static files). +- `vp run build` — Builds contracts, web app, and server. +- `vp run typecheck` — Strict TypeScript checks for all packages. +- `vp run test` — Runs workspace tests. +- `node apps/server/scripts/t3-sqlite-state.ts --base-dir ...` — Inspects or seeds an isolated T3 SQLite database; writes create a private backup first. +- `vp run dist:desktop:artifact -- --platform --target --arch ` — Builds a desktop artifact for a specific platform/target/arch. +- `vp run dist:desktop:dmg` — Builds a shareable macOS `.dmg` into `./release`. +- `vp run dist:desktop:dmg:x64` — Builds an Intel macOS `.dmg`. +- `vp run dist:desktop:linux` — Builds the Linux desktop app into `./release` (default target `dir`; use `dist:desktop:linux:appimage` or `dist:desktop:linux:pacman` for those targets). +- `vp run dist:desktop:win` — Builds a Windows NSIS installer into `./release`. + +## Desktop `.dmg` packaging notes + +- Default build is unsigned/not notarized for local sharing. +- The DMG build uses `assets/prod/black-macos-1024.png` as the production app icon source. +- Desktop production windows load the bundled UI from `t3code://app/index.html` (not a `127.0.0.1` document URL). + +- Desktop packaging includes `apps/server/dist` (the `t3` backend) and starts it on loopback with an auth token for WebSocket/API traffic. +- Your tester can still open it on macOS by right-clicking the app and choosing **Open** on first launch. +- To keep staging files for debugging package contents, run: `vp run dist:desktop:dmg -- --keep-stage` +- To allow code-signing/notarization when configured in CI/secrets, add: `--signed`. +- Signed macOS builds also require `T3CODE_APPLE_TEAM_ID` and + `T3CODE_MACOS_PROVISIONING_PROFILE`. The passkey RP domain is derived from + `T3CODE_CLERK_PUBLISHABLE_KEY` unless `T3CODE_CLERK_PASSKEY_RP_DOMAINS` overrides it. +- Windows `--signed` uses Azure Trusted Signing and expects: + `AZURE_TRUSTED_SIGNING_ENDPOINT`, `AZURE_TRUSTED_SIGNING_ACCOUNT_NAME`, + `AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE_NAME`, and `AZURE_TRUSTED_SIGNING_PUBLISHER_NAME`. +- Azure authentication env vars are also required (for example service principal with secret): + `AZURE_TENANT_ID`, `AZURE_CLIENT_ID`, `AZURE_CLIENT_SECRET`. + +## Browser development + +`dev` and `dev:web` leave `VITE_HTTP_URL` and `VITE_WS_URL` unset so the browser resolves the backend from `window.location.origin`. Vite proxies `/api`, `/ws`, `/oauth`, and `/.well-known` to the server, allowing the same bundle to work from localhost or a tailnet hostname. + +Worktrees derive a preferred port offset from their path. The runner shifts both ports together when either is occupied or the web port is blocked by browsers, so treat the `[dev-runner]` output as authoritative. + +## Running multiple dev instances + +Set `T3CODE_DEV_INSTANCE` to any value to deterministically shift all dev ports together. + +- Default ports: server `13773`, web `5733` +- Shifted ports: `base + offset` (offset is hashed from `T3CODE_DEV_INSTANCE`) +- Example: `T3CODE_DEV_INSTANCE=branch-a vp run dev:desktop` + +If you want full control instead of hashing, set `T3CODE_PORT_OFFSET` to a numeric offset. diff --git a/docs/sidebar-v2.md b/docs/sidebar-v2.md new file mode 100644 index 000000000000..4d5a8046e848 --- /dev/null +++ b/docs/sidebar-v2.md @@ -0,0 +1,21 @@ +# Sidebar V2 ordering contract + +Web and mobile persist thread-list ordering with the historical enum +`"recency" | "project" | "none"`. The enum predates Sidebar V2, so its names are storage +compatibility—not a literal description of every renderer. + +| Persisted value | User-facing label | Sidebar V1 | Sidebar V2 | +| --------------- | ----------------- | ---------------------- | ------------------------------------------ | +| `project` | Group by default | Project-group sections | Upstream V2 static creation order | +| `recency` | Group by recency | Recency sections | Latest-activity order with recency headers | +| `none` | Group by nothing | Flat legacy list | Treated as upstream/default V2 order | + +Do not make `project` group V2 rows by project. In V2, pinning and lifecycle placement outrank the +ordering preference: pinned cards remain above active cards, snoozed threads remain on the Snoozed +shelf, and settled threads remain on the Settled shelf. The preference changes ordering only; it +must not select a different row component or visual treatment. Recency headers may partition the +active block and the expanded Settled shelf; pinned cards stay above those buckets. + +Renaming the stored `project` value would require an explicit web-local-storage and mobile +preferences migration. Until then, code should use the labels and behavior above rather than infer +V2 behavior from the legacy enum spelling. diff --git a/docs/user/github-pr-conversations.md b/docs/user/github-pr-conversations.md new file mode 100644 index 000000000000..5a99cf7d2cd9 --- /dev/null +++ b/docs/user/github-pr-conversations.md @@ -0,0 +1,246 @@ +# RFC: GitHub PR conversations + +**Status:** implemented MVP +**Scope:** GitHub.com pull-request comments backed by an existing T3 thread and worktree + +## Summary + +An authorized GitHub user can mention the T3 GitHub App in a pull-request conversation and continue +the T3 thread whose checked-out worktree branch resolves to that PR. + +The GitHub entry point **joins or provisions**: + +1. **Work-item store** — unique thread for this PR URL, or unique thread for a Jira key in the PR + title **or mention comment** (Jira/Discord-first sessions continue). +2. **Live worktree match** — unique checked-out PR worktree on a matching T3 project. +3. **Provision** — prepare a PR worktree and create a T3 thread when nothing unique matches. + +On accept, the bridge appends the PR URL and Jira keys extracted from the PR title and the mention +comment body to `ThreadWorkItemStore`. It never creates a **project**. See +[work-item thread linking](./work-item-thread-linking.md). + +Setup and development webhook instructions are in +[GitHub App setup](./github-app-setup.md). For agent `gh`/`git` auth without a machine user, see +[GitHub App agent auth](./github-app-agent-auth.md). The longer in-process broker plan is +[GitHub App account migration](./github-app-account-migration.md). + +## User experience + +The bridge handles two GitHub comment surfaces on pull requests: + +| Surface | Webhook event | Where you write | Where T3 replies | +| --------------- | ------------------------------------- | ---------------------------- | --------------------------- | +| PR conversation | `issue_comment.created` | Conversation tab | New conversation comment | +| Inline review | `pull_request_review_comment.created` | Files changed (line comment) | Reply in that review thread | + +A turn starts only when a non-bot user writes an explicit configured mention followed by a prompt: + +```text +@t3-code investigate why the Windows check is failing +``` + +On an inline review comment, the same mention works and the agent receives the file path, line, side, +and diff hunk from the review comment: + +```text +@t3-code please fix this null check +``` + +### Thread mode (session selection) + +Both surfaces share the **PR worktree** (the same checkout Discord/T3 use for that PR). Sessions differ: + +| Surface | Default | Behavior | +| ----------------- | ----------- | ----------------------------------------------------------------------------------------------------------------------- | +| **Conversation** | **main** | Reuse the live T3/Discord PR work thread | +| **Inline review** | **sibling** | First `@mention` in a GH review discussion creates a T3 session; later `@mention`s in **that same discussion** reuse it | + +Overrides (stripped from the prompt): + +| Flag | Effect | +| ------------------------------------------------------ | --------------------------------------------------------------------- | +| `main-thread` / `--thread main` | Force the PR work thread | +| `sibling-thread` / `--thread sibling` / `--thread new` | Force a **new** sibling session (and rebind that GH discussion to it) | + +So: new T3 thread only when starting an unbound inline discussion, or when forced. Continuing a tagged review thread stays on the assigned session until the user switches. + +The app: + +1. Verifies the webhook signature and deduplicates the delivery. +2. Checks the repository allowlist and the requester's current repository permission. +3. Resolves session: main PR thread, existing review-discussion binding, or create sibling on the PR worktree. +4. Acknowledges the source comment with an eyes reaction, starts a turn, and posts the final answer + (conversation comment or in-thread review reply). + +If the chosen T3 thread is already running, the app asks the user to retry instead of queuing. Edited +comments, mention-free comments, normal issue comments (non-PR), and app-authored comments are ignored. + +## Work-item store + +When a GitHub invocation successfully resolves a T3 thread, the server records the PR URL in the +shared **ThreadWorkItemStore** (`stateDir/thread-work-items.json`) alongside any Jira issue keys. +That store is platform-agnostic (not Discord-only) and can later support reverse lookup, UI, and +agent tools without reading Discord bot state. + +Live PR resolution below remains the primary GitHub link path for this MVP. + +## Link definition + +A PR is linked only while exactly one active T3 thread satisfies all of these conditions: + +- `worktreePath` is non-null. +- `branch` is non-null. +- Git can inspect the worktree. +- T3's source-control provider resolves the branch to a GitHub PR. +- The resolved PR number and canonical URL match the webhook repository and PR. + +This is a live PR/branch/worktree/thread relationship rather than a second mutable link database. It +supports both directions already present in T3: + +- A PR checked out through `git.preparePullRequestThread` has its upstream configured and resolves to + that PR. +- A PR created from an existing T3 worktree branch resolves through the branch's GitHub PR status. + +Deleting the worktree, removing the thread, switching the branch to another PR, or producing multiple +matching threads immediately makes the lookup fail closed. The webhook never attempts repair. + +## Architecture + +```text +GitHub App issue_comment | pull_request_review_comment webhook + | + v +POST /api/github/webhook + raw-body HMAC verification + payload/schema validation + delivery-id dedupe + | + v +GitHubPrBridge + repository allowlist + actor permission lookup + parse thread mode (conversation→main, review→sibling+affinity; flags override) + resolve: main PR thread | bound review-discussion session | create sibling + | + v +OrchestrationEngineService.dispatch(thread.turn.start) + (inline review: path/line/diff hunk in prompt context) + | + v +ProjectionSnapshotQuery polling + --> issue surface: create/update Issues API comment + --> review surface: create/update review-thread reply +``` + +Implementation lives under `apps/server/src/github/`. It runs inside the T3 server so it uses the same +orchestration projection and command engine as the web application. + +## Security model + +- Verify `X-Hub-Signature-256` against the exact raw request body before decoding JSON. +- Accept at most 1 MiB per webhook body. +- Accept only `issue_comment` and `pull_request_review_comment` events with a non-empty + `X-GitHub-Delivery` id. +- Ignore bot actors and require an explicit configured mention. +- Require the repository to be enabled and the actor to meet the configured permission floor + (`write` by default). +- Treat all GitHub fields and comment text as untrusted user input in the generated T3 prompt. +- Use a GitHub App installation token for permission checks and PR comment writes. +- Keep the webhook secret and private key out of prompts, logs, persisted deliveries, and git config. +- Use the checked-out branch's provider-resolved canonical PR URL; branch-name equality alone is never + sufficient. + +Private repositories should set `T3CODE_GITHUB_ALLOWED_REPOSITORIES`; an empty value allows every +repository on which the app is installed. Entries are `owner/repo` or `owner/*` (every repository +under that owner). + +## Reliability + +Processed deliveries are persisted atomically in: + +```text +${T3CODE_HOME}/userdata/github-webhook-deliveries.json +``` + +Inbound webhook intake is also logged (24h retention) to: + +```text +${T3CODE_HOME}/userdata/github-webhook-debug.ndjson +``` + +Each row records outcome (`accepted_202`, `ignored_202`, `invalid_400`, `unauthorized_401`, +`repo_denied_202`, …), delivery id, and a capped body preview on failures. Best-effort only. + +Development mode uses the corresponding dev state directory. The newest 2,000 deliveries are kept. +Claiming a delivery is serialized, so a GitHub retry cannot create a second T3 turn. Each record stores +the response comment, T3 thread, and previous turn id. + +On restart, processing records resume projection polling and finalize the original GitHub comment. +Installation tokens are cached briefly and renewed automatically. A response longer than GitHub's +comment limit is truncated explicitly. + +Temporary GitHub/T3 failures are logged and do not get mislabeled as an unlinked PR. A missing thread, +missing worktree, failed branch resolution, repository mismatch, PR mismatch, or ambiguous match does. + +## Configuration + +| Variable | Required | Default | Purpose | +| ------------------------------------ | -------- | ------------------- | ------------------------------------------------- | +| `T3CODE_GITHUB_APP_ID` | yes | — | Numeric GitHub App id | +| `T3CODE_GITHUB_APP_PRIVATE_KEY_PATH` | yes | — | Path to the downloaded PEM key | +| `T3CODE_GITHUB_WEBHOOK_SECRET` | yes | — | Shared webhook HMAC secret | +| `T3CODE_GITHUB_APP_MENTION` | yes | — | Mention handle without `@` | +| `T3CODE_GITHUB_ALLOWED_REPOSITORIES` | no | all installed repos | Comma-separated `owner/repo` or `owner/*` | +| `T3CODE_GITHUB_MIN_PERMISSION` | no | `write` | `read`, `triage`, `write`, `maintain`, or `admin` | +| `T3CODE_GITHUB_TURN_TIMEOUT_MS` | no | `1800000` | Response bridge timeout, minimum 10 seconds | + +The route returns 404 unless all four required variables are configured. + +## Failure semantics + +| Condition | Result | +| ---------------------------------------------- | -------------------------------------------------------- | +| No unique live PR/branch/worktree/thread match | Exactly `not yet linked/checked out.` | +| Missing/deleted worktree or T3 thread | Exactly `not yet linked/checked out.` | +| Repository or PR mismatch | Exactly `not yet linked/checked out.` | +| Unauthorized repository | Silently ignored; no response, no turn | +| Unauthorized actor | Neutral authorization response; no link-state disclosure | +| Thread already running | Busy response; no queue and no turn | +| Duplicate delivery | Reuse persisted classification; no new comment or turn | +| Turn completes | Replace working/progress comment with final answer | +| Turn errors or is interrupted | Replace comment with a stable failure response | +| Server restarts during turn | Resume the persisted response bridge | + +Provision still shells out to `gh` for PR metadata. Transient App installation-token +auth failures (exit 4 / 401) are retried **inside the guest `gh-app-wrapper`** (wait, +remint `--no-cache`, one retry)—not in this bridge—so agents and status polls get the +same fix. That wrapper ships with the microVM image (`infra/microvm/github-app` in ops). + +## Tests and acceptance criteria + +Automated coverage includes raw-body signatures, invocation parsing, bot/issue/empty-prompt ignores, +permission ordering, GitHub App JWT signing, and the exact missing-link response. + +End-to-end acceptance: + +1. Check out a GitHub PR into a T3 worktree-backed thread. +2. Mention the app with a prompt on that PR conversation. +3. Confirm exactly one new user turn appears in the same T3 thread and its final answer is posted as a + conversation comment. +4. Mention the app on an inline Files-changed review comment on the same PR. +5. Confirm the reply lands in that review thread and the turn prompt includes path/line context. +6. Redeliver the same webhook and confirm no duplicate comment or turn appears. + +## Deferred scope + +- Approval and structured user-input interactions in GitHub. +- GitHub Checks output. +- Durable relay ingress for environments that cannot expose the local server directly. +- Replacing the source-control implementation's personal `gh` and git credentials with GitHub App + installation credentials; see the migration plan linked above. +- **Provision auth hardening** (guest `gh-app-wrapper` remint-on-401 ships in ops; rest still open): + - Resolve PR head/base via `GitHubAppClient` (webhook installation token) instead of CLI `gh` + - Post the real provision error on the PR comment (not only “check server logs”) + - Always pass `-R owner/repo` from the bridge; fix App-mode errors that still say `gh auth login` + - Server token cache under `XDG_RUNTIME_DIR` / `T3_GITHUB_APP_TOKEN_CACHE_DIR`, not agent `TMPDIR` + - Cut `lookupStatusPr` `gh` noise; prune expired installation-token cache files diff --git a/docs/user/jira-issue-conversations.md b/docs/user/jira-issue-conversations.md new file mode 100644 index 000000000000..227edb39b5bc --- /dev/null +++ b/docs/user/jira-issue-conversations.md @@ -0,0 +1,236 @@ +# RFC: Jira issue conversations (mentions + replies) + +**Status:** foundation (webhook intake + parsing + bridge skeleton) +**Scope:** Jira Cloud issue comments that mention the T3 bot, bridged to an existing T3 thread + +## Summary + +An authorized Jira user can **@mention** the configured bot identity in an issue comment (or a reply +in a comment thread when Jira supplies a parent) and continue a T3 thread that is already linked to +that issue key. + +Thread resolution uses the **server-native work-item store** (`thread-work-items.json` under the +server state dir) keyed by Jira issue (**join-or-create**): + +1. **Exactly one** store hit → continue that thread (Discord import is a migration fallback only). +2. **Multiple** hits → fail closed with an ambiguous message (never guess). +3. **Zero** hits → **auto-create** a T3 thread on a **new git worktree** (never the project main + checkout), attach the issue key, and run the turn. Project pick order: + `T3CODE_JIRA_PROJECT_MAP` for the Jira project key (e.g. `SA`) → + `T3CODE_JIRA_DEFAULT_PROJECT_ID` → sole shell project when exactly one exists. Disable with + `T3CODE_JIRA_AUTO_CREATE_THREAD=false`. Base branch: `T3CODE_JIRA_BASE_BRANCH` (default `main`). + Branch names are key-first (`SA-402-t3-`) so GitHub-for-Jira can auto-link. + +Does **not** create projects or clone repositories. New threads always get a dedicated worktree +sibling under the project's worktrees dir (same isolation model as Discord/GitHub create). Later +surfaces join via the same work-item store. + +Agent-side Jira read/write for general tooling remains the shared Jira MCP (`mcp-atlassian`). This +bridge only owns **inbound webhooks** and **outbound response comments** for mention turns. + +## User experience + +| Surface | Webhook event | Trigger | Where T3 replies | +| ------------- | ----------------- | ---------------------------------------------- | ---------------------------------------------------- | +| Issue comment | `comment_created` | Explicit configured mention + prompt | Threaded **reply** under the mention (`parentId`) | +| Comment reply | `comment_created` | Mention in a comment with `parent` (when set) | Threaded **reply** under the same thread root | +| Comment edit | `comment_updated` | Edited comment still contains mention + prompt | Threaded **reply** under the edited comment’s thread | + +A turn starts only when a non-bot author writes an explicit configured mention followed by a prompt: + +```text +@omegent investigate why packing fails on SA-402 +``` + +Mentions are recognized in: + +1. Plain / wiki-ish text (`@handle`, `[~accountId:…]`, `[~username]`) +2. Atlassian Document Format (ADF) `mention` nodes (`attrs.id` / `attrs.text`) + +Bot-authored comments and mention-free comments are ignored. + +**Edits:** `comment_updated` re-dispatches when the edited body still mentions the bot and has a +prompt. Delivery ids include the comment `updated` timestamp (or a prompt fingerprint) so the same +edit is not double-run, but a later edit starts a new turn. The agent prompt notes that the user +edited the comment and treats the new text as authoritative. + +## Link definition + +An issue is linked when **exactly one** T3 thread lists the issue key in the server +`ThreadWorkItemStore` (`stateDir/thread-work-items.json`). + +How associations get there: + +1. **Jira webhook** — on a successful resolve/dispatch, the issue key is appended for that thread +2. **GitHub webhook** — PR URLs are recorded the same way (shared store) +3. **Discord import** — optional one-shot/fallback import from Discord bot `links.json` + (`T3CODE_JIRA_DISCORD_LINKS_PATH`) when the server store has no match yet +4. **Future** — authenticated API / web UI / agent tools to attach work items without Discord + +Fail closed when: + +- Zero threads match the issue key +- More than one thread matches +- The matched T3 thread no longer exists + +## Architecture + +```text +Jira Cloud comment_created | comment_updated webhook + | + v +POST /api/jira/webhook + shared-secret verification + payload validation + delivery-id dedupe (created: comment id; updated: comment id + updated-at) + | + v +JiraIssueBridge + project allowlist + best-effort 👀 reaction on trigger comment (cleared when done) + parse mention + prompt (+ optional parent comment id) + resolve unique T3 thread via ThreadWorkItemStore + (optional Discord links.json import if still unlinked) + join-or-create via PROJECT_MAP / DEFAULT_PROJECT_ID / sole project + dispatch orchestration turn + poll projection snapshot + | + v +Jira REST comment create (markdown → ADF, parentId reply when possible) ++ remove ack reaction +``` + +Work-item associations live in: + +```text +${T3CODE stateDir}/thread-work-items.json +``` + +## Webhook debug log + +Every inbound integration webhook writes one NDJSON row under the server state dir: + +```text +${T3CODE stateDir}/jira-webhook-debug.ndjson +${T3CODE stateDir}/github-webhook-debug.ndjson +``` + +Outcomes include `accepted_202`, `ignored_202`, `invalid_400`, `unauthorized_401`, +`project_denied_202` / `repo_denied_202`, `too_large_413`, `missing_delivery_id_400` +(GitHub), and `disabled_404`. Invalid rows store a capped `bodyPreview` plus a `reason` +(`json_parse_failed` is common when Jira Automation injects unescaped newlines into +Custom data JSON). + +Retention: **24 hours** (and a hard cap of 5 000 rows per source). Older lines are pruned +on each append and on process start. Best-effort only — append failures never fail the +webhook. + +## Configuration + +| Variable | Required | Default | Purpose | +| -------------------------------- | -------- | ------- | ----------------------------------------------------------------- | +| `T3CODE_JIRA_WEBHOOK_SECRET` | yes\* | — | Shared secret for inbound webhook auth | +| `T3CODE_JIRA_MENTION` | yes\* | — | Bot handle / display name / accountId to match | +| `T3CODE_JIRA_URL` | yes\* | — | Site or gateway base (`…atlassian.net` or `…/ex/jira/{cloudId}`) | +| `T3CODE_JIRA_USERNAME` | yes\* | — | Service account email for REST replies | +| `T3CODE_JIRA_API_TOKEN` | yes\* | — | API token (Basic or Bearer per deployment) | +| `T3CODE_JIRA_ALLOWED_PROJECTS` | no | empty | Comma-separated project keys; empty = all | +| `T3CODE_JIRA_DISCORD_LINKS_PATH` | no | — | Path to Discord bot `links.json` for issue→thread | +| `T3CODE_JIRA_TURN_TIMEOUT_MS` | no | 30m | Max wait for turn completion before timeout comment | +| `T3CODE_JIRA_AUTH_MODE` | no | `basic` | `basic` (email+token) or `bearer` (scoped token) | +| `T3CODE_JIRA_AUTO_CREATE_THREAD` | no | `true` | Create a T3 thread when the issue is unlinked | +| `T3CODE_JIRA_PROJECT_MAP` | no | empty | Jira key → T3 project map (see below) | +| `T3CODE_JIRA_DEFAULT_PROJECT_ID` | no\* | — | Fallback project for auto-create (\*or exactly one shell project) | +| `T3CODE_JIRA_ACK_EMOJI_ID` | no | `1f440` | Reaction on the trigger comment (`👀`); empty string disables | +| `T3CODE_JIRA_BOT_ACCOUNT_ID` | no | — | Alias for wiki/ADF `[~accountId:…]` mention matching | + +\*When any required value is missing, the integration is **disabled** (webhook returns 404). + +### Project map values + +Each map value (and `T3CODE_JIRA_DEFAULT_PROJECT_ID`) may be any of: + +1. **T3 project id** (UUID from the shell / `links.json` `projectId`) +2. **Project title** (case-insensitive), e.g. `scanner` +3. **Workspace basename**, e.g. `scanner` for `/var/lib/t3/src/macs/scanner` +4. **Absolute workspace root**, e.g. `/var/lib/t3/src/macs/scanner` (Discord-style paths) + +```bash +# Prefer prefix map for multi-project hosts +T3CODE_JIRA_PROJECT_MAP=SA:scanner,CFG:/var/lib/t3/src/macs/configurator + +# Optional global fallback (id, title, basename, or full path) +T3CODE_JIRA_DEFAULT_PROJECT_ID=/var/lib/t3/src/macs/scanner +``` + +### Acknowledgment reactions + +On accept, the bridge best-effort adds an eyes reaction (`1f440` / 👀 by default) to the +triggering comment, then removes it when the turn finishes or is rejected — same idea as Discord +and GitHub eyes. Jira Cloud’s public REST surface for comment reactions varies by site; failures +are logged and never block the turn. + +## Security + +- Require a shared secret on every delivery (`Authorization: Bearer …` or `X-T3-Webhook-Secret`). +- Cap body size at 1 MiB. +- Ignore events that are not `comment_created`. +- Allowlist projects when configured. +- Do not put secrets in prompts, delivery logs, or git. +- Prefer the free Atlassian **service account** for REST replies (see + [atlassian-service-accounts](./atlassian-service-accounts.md) when present on the branch). + +## Outbound comments + +Responses are posted as issue comments authored by the service account, preferably as a +**threaded reply** under the triggering mention (REST body field `parentId` — supported on Jira +Cloud even though it is lightly documented). The body **@-mentions** the human requester via an ADF `mention` node: + +```json +{ + "type": "mention", + "attrs": { + "id": "", + "text": "@Display Name", + "accessLevel": "" + } +} +``` + +`attrs.id` is the **bare** account id from the webhook author (e.g. `6331c323…` or +`712020:uuid`) — the same shape returned by GET comment bodies on this site — not the wiki +`[~accountid:…]` form and not plain `@Name` text alone. + +**Inline threading (required for reliable replies):** Jira Cloud only accepts children under a +**root** comment. POST with `parentId` set to a nested reply id returns **400** +(`Parent comment not found, and no child comments exist`) — the bridge used to fall back flat. +Before posting, `JiraAppClient` GETs `/rest/api/3/issue/{key}/comment/{id}` and uses that +comment’s `parentId` when set (else the id itself). Webhooks should send either `comment.parentId` +(REST shape) or `comment.parent.id` when known; empty Automation fields are ignored. Only if every +resolved root is rejected does the bridge fall back to a top-level comment (logged as error when +the create response lacks `parentId`). + +**Busy threads:** follow-up mentions always dispatch `thread.turn.start`. Orchestration queues the +message while a turn is running; the bridge does **not** post an “already working” short-circuit. +The reply still posts asynchronously when the turn completes (`bridgeTurn` is fork-detached). + +Prefer Markdown converted to a minimal ADF document for API v3. Do not @-spam watchers unless the +agent explicitly mentions users. + +## Testing checklist + +1. Unit: mention extraction for plain text, wiki, and ADF; parent comment id; bot/self skip. +2. Unit: webhook secret acceptance / rejection; project allowlist. +3. Unit: delivery dedupe on redelivery of the same comment id. +4. Unit: webhook debug retention prune (24h) and body failure classification. +5. Integration (manual): register a Jira webhook or Automation rule → `POST /api/jira/webhook` + with the shared secret; mention the bot on a linked issue; confirm a reply comment and a + matching `accepted_202` (or `invalid_400` with preview) line in `jira-webhook-debug.ndjson`. + +## Non-goals (this foundation) + +- Creating worktrees or projects from Jira +- Full comment-edit re-routing +- Confluence page mentions +- Jira Service Management customer portal public/internal split (beyond posting internal comments later) +- Real-time streaming of intermediate assistant text into Jira (final answer only) diff --git a/docs/user/remote-access.md b/docs/user/remote-access.md index b10123ab6223..10ee2f463bf0 100644 --- a/docs/user/remote-access.md +++ b/docs/user/remote-access.md @@ -164,6 +164,33 @@ your login; `t3 connect logout` also clears that login. Background-service Treat pairing URLs and authorization codes as passwords. Do not include them in screenshots, logs, or bug reports. +## Preview a port on a remote environment + +Agent-started preview servers usually listen only on that machine's loopback +interface, so the address you use to reach T3 Code does not reach them. + +Opening such a port in the in-app browser asks the environment to find a +reachable URL, in this order: + +1. Reuse an existing Tailscale Serve route for that port. +2. Use the environment's own address if the server already answers there. +3. Otherwise publish a tailnet-only HTTPS route, confirm it answers, and return + that URL. The route is removed when the preview server exits or the + environment shuts down. + +Step 3 needs Tailscale signed in on the host, and the T3 Code server allowed to +manage Serve routes (`sudo tailscale set --operator=$USER`). Without that, you +can publish a port yourself: + +```sh +tailscale serve --bg --https=5173 http://127.0.0.1:5173 +``` + +These routes are visible to your tailnet only, never through Tailscale Funnel. +Anyone on the tailnet can reach a published preview while it runs. To skip +automatic publishing, bind the preview server to a reachable address or publish +the ports you want by hand. + ## T3 Connect troubleshooting Run `t3 connect status` on the host to inspect saved authorization and link diff --git a/docs/user/source-control.md b/docs/user/source-control.md index 48e3eb1992cd..0945a5d833b3 100644 --- a/docs/user/source-control.md +++ b/docs/user/source-control.md @@ -82,6 +82,24 @@ supports approving waiting fork workflows and opening a revert pull request for For Azure DevOps, use the host website to view diffs or change comments. Bitbucket does not support reopening a declined pull request. +## Worktree lifecycle scripts + +Project scripts can run around git worktrees and pull requests. Configure them in the project +scripts menu, or check them into the project's `t3.json`. + +- **Run on worktree creation** starts after a new worktree thread is created. +- **Run before worktree removal** runs before the worktree is removed. T3 Code waits for the script + to exit; a non-zero exit blocks removal. +- **Run when the pull request merges** runs in that workspace when the branch's review moves from + open to merged. Failures are logged and do not block other work. + +Scripts receive `T3CODE_PROJECT_ROOT`, `T3CODE_WORKTREE_PATH`, and `T3CODE_LIFECYCLE` +(`worktree-remove` or `pr-merged`). When a linked pull request is known, they also receive +`T3CODE_PR`, `T3CODE_PR_NUMBER`, `T3CODE_PR_URL`, `T3CODE_PR_TITLE`, `T3CODE_PR_BASE_REF`, +`T3CODE_PR_HEAD_REF`, and `T3CODE_PR_STATE`. + +Use these to stop dev servers or drop temporary databases before a worktree goes away. + ## Troubleshooting - **Not authenticated:** run the provider's login command on the server, then rescan. For Bitbucket, diff --git a/docs/user/updating.md b/docs/user/updating.md index d72df7382f56..5c840f21be11 100644 --- a/docs/user/updating.md +++ b/docs/user/updating.md @@ -16,8 +16,10 @@ restart. Changes are saved to connected environments that support this setting; update older servers first. If a supported environment was offline or has a different value, use **Apply to all** in Settings after it connects. T3 Code must start again on that machine; -the setting does not enable automatic startup. Terminal commands may still be -interrupted, and threads without saved provider resume state need a new message. +the setting does not enable automatic startup. A graceful server restart, +including a deploy that stops and starts the service, still resumes supported +threads that were actively working. Terminal commands may still be interrupted, +and threads without saved provider resume state need a new message. If you previously enabled continuation for updates, enable this setting once to allow recovery without a connected client. diff --git a/infra/relay/README.md b/infra/relay/README.md index 33bb0ba74352..3a5d5579a49e 100644 --- a/infra/relay/README.md +++ b/infra/relay/README.md @@ -1,7 +1,7 @@ # T3 Connect Relay -> [!NOTE] -> Sign in to T3 Connect from the app under Settings > Connections. +> [!WARNING] +> T3 Connect is currently in private beta. Join the waitlist in the app under Settings > T3 Connect. The relay is the hosted control plane for T3 Connect. It helps clients discover and connect to remote environments, manages the cloud-side records needed for those connections, and delivers @@ -161,6 +161,6 @@ and hosted web builds. See: -- [T3 Connect setup](../../docs/operations/connect-setup.md) for Clerk keys, JWT templates, and sign-up restrictions. +- [T3 Connect setup](../../docs/operations/connect-setup.md) for Clerk keys, JWT templates, and waitlist setup. - [Relay Observability](../../docs/operations/relay-observability.md) for deployment tracing and diagnostics. - [T3 Connect architecture](../../docs/internals/t3-connect.md) for environment linking and trust boundaries. diff --git a/infra/relay/src/environments/EnvironmentConnector.ts b/infra/relay/src/environments/EnvironmentConnector.ts index 9201f814661e..23ada2e544bf 100644 --- a/infra/relay/src/environments/EnvironmentConnector.ts +++ b/infra/relay/src/environments/EnvironmentConnector.ts @@ -13,7 +13,6 @@ import { RelayEnvironmentMintResponse, RelayEnvironmentMintResponseProofPayload, RelayCloudMintCredentialProofPayload, - RelayEnvironmentConnectNotAuthorizedReason, type RelayEnvironmentConnectResponse, type RelayEnvironmentStatusResponse, } from "@t3tools/contracts/relay"; @@ -45,8 +44,21 @@ import * as ManagedEndpointAllocations from "./ManagedEndpointAllocations.ts"; import * as RelayConfiguration from "../Config.ts"; import { isManagedEndpointHostname } from "../deploymentConfig.ts"; +export const EnvironmentConnectNotAuthorizedReason = Schema.Literals([ + "client_proof_key_thumbprint_missing", + "environment_link_not_found", + "endpoint_provider_not_managed", + "managed_endpoint_allocation_not_found", + "managed_endpoint_base_domain_not_configured", + "managed_endpoint_allocation_not_ready", + "managed_endpoint_hostname_invalid", + "managed_endpoint_mismatch", +]); +export type EnvironmentConnectNotAuthorizedReason = + typeof EnvironmentConnectNotAuthorizedReason.Type; + function environmentConnectNotAuthorizedReasonMessage( - reason: RelayEnvironmentConnectNotAuthorizedReason, + reason: EnvironmentConnectNotAuthorizedReason, ): string { switch (reason) { case "client_proof_key_thumbprint_missing": @@ -73,7 +85,7 @@ export class EnvironmentConnectNotAuthorized extends Schema.TaggedError { + const lintable = filenames.filter((file) => { + const normalized = file.replaceAll("\\", "/"); + return !normalized.startsWith(".repos/") && !normalized.includes("/.repos/"); + }); + if (lintable.length === 0) { + return []; + } + return [`vp lint --fix ${lintable.map((file) => JSON.stringify(file)).join(" ")}`]; + }, +}; diff --git a/oxlint-plugin-t3code/index.ts b/oxlint-plugin-t3code/index.ts index 5037dc943413..ba3e7a2132dd 100644 --- a/oxlint-plugin-t3code/index.ts +++ b/oxlint-plugin-t3code/index.ts @@ -6,6 +6,7 @@ import noInlineSchemaCompile from "./rules/no-inline-schema-compile.ts"; import noManualEffectRuntimeInTests from "./rules/no-manual-effect-runtime-in-tests.ts"; import noMobileUniwindThemeEscapeHatches from "./rules/no-mobile-uniwind-theme-escape-hatches.ts"; import noNativeTitleTooltip from "./rules/no-native-title-tooltip.ts"; +import noUnsupportedHermesArrayMethods from "./rules/no-unsupported-hermes-array-methods.ts"; export default definePlugin({ meta: { @@ -18,5 +19,6 @@ export default definePlugin({ "no-manual-effect-runtime-in-tests": noManualEffectRuntimeInTests, "no-mobile-uniwind-theme-escape-hatches": noMobileUniwindThemeEscapeHatches, "no-native-title-tooltip": noNativeTitleTooltip, + "no-unsupported-hermes-array-methods": noUnsupportedHermesArrayMethods, }, }); diff --git a/oxlint-plugin-t3code/rules/no-unsupported-hermes-array-methods.test.ts b/oxlint-plugin-t3code/rules/no-unsupported-hermes-array-methods.test.ts new file mode 100644 index 000000000000..c2b861397990 --- /dev/null +++ b/oxlint-plugin-t3code/rules/no-unsupported-hermes-array-methods.test.ts @@ -0,0 +1,38 @@ +import { assert, describe } from "@effect/vitest"; + +import { createOxlintRuleHarness } from "../test/utils.ts"; + +describe("t3code/no-unsupported-hermes-array-methods", () => { + const mobileRule = createOxlintRuleHarness("t3code/no-unsupported-hermes-array-methods", { + filename: "apps/mobile/src/fixture.ts", + }); + const sharedRule = createOxlintRuleHarness("t3code/no-unsupported-hermes-array-methods", { + filename: "packages/shared/src/fixture.ts", + }); + const webRule = createOxlintRuleHarness("t3code/no-unsupported-hermes-array-methods", { + filename: "apps/web/src/fixture.ts", + }); + + mobileRule.invalid( + "reports toSorted in mobile code", + "export const sorted = [3, 1, 2].toSorted();", + (output) => { + assert.match(output, /Hermes does not provide Array\.prototype\.toSorted/); + }, + ); + + sharedRule.invalid( + "reports toReversed in shared runtime code", + "export const reversed = [1, 2, 3].toReversed();", + ); + + mobileRule.valid( + "allows copy then sort in mobile code", + "export const sorted = [...[3, 1, 2]].sort();", + ); + + webRule.valid( + "does not constrain browser-only code", + "export const sorted = [3, 1, 2].toSorted();", + ); +}); diff --git a/oxlint-plugin-t3code/rules/no-unsupported-hermes-array-methods.ts b/oxlint-plugin-t3code/rules/no-unsupported-hermes-array-methods.ts new file mode 100644 index 000000000000..b45360f05593 --- /dev/null +++ b/oxlint-plugin-t3code/rules/no-unsupported-hermes-array-methods.ts @@ -0,0 +1,41 @@ +import { defineRule } from "@oxlint/plugins"; +import * as Option from "effect/Option"; + +import { getPropertyName } from "../utils.ts"; + +const unsupportedMethods = new Set(["toReversed", "toSorted", "toSpliced"]); +const mobileRuntimeRoots = ["apps/mobile/", "packages/client-runtime/", "packages/shared/"]; + +const normalizePath = (path: string) => path.replaceAll("\\", "/"); + +const isMobileRuntimeFile = (filename: string) => { + const normalized = normalizePath(filename); + return mobileRuntimeRoots.some( + (root) => normalized.startsWith(root) || normalized.includes(`/${root}`), + ); +}; + +export default defineRule({ + meta: { + type: "problem", + docs: { + description: + "Disallow ES2023 change-by-copy array methods in code that can run on Expo's Hermes runtime.", + }, + }, + createOnce(context) { + return { + MemberExpression(node) { + if (!isMobileRuntimeFile(context.filename)) return; + + const property = getPropertyName(node.property); + if (Option.isNone(property) || !unsupportedMethods.has(property.value)) return; + + context.report({ + node, + message: `Hermes does not provide Array.prototype.${property.value}; copy the array and use its mutating equivalent instead.`, + }); + }, + }; + }, +}); diff --git a/package.json b/package.json index dd1a106a0409..c1d814b9353b 100644 --- a/package.json +++ b/package.json @@ -3,7 +3,9 @@ "private": true, "type": "module", "scripts": { - "prepare": "effect-tsgo patch && vp config --no-agent", + "prepare": "node scripts/clean-tsgo-backups.mjs && effect-tsgo patch && vp config --no-agent && node scripts/install-git-hooks.mjs", + "pr:ready": "node scripts/agent-pr-ready.mjs", + "test:agent-gate": "vp test run scripts/agent-pre-push.test.mjs", "dev": "node scripts/dev-runner.ts dev", "dev:share": "node scripts/dev-runner.ts dev --share", "dev:server": "node scripts/dev-runner.ts dev:server", @@ -40,6 +42,7 @@ "dist:desktop:dmg:arm64": "node scripts/build-desktop-artifact.ts --platform mac --target dmg --arch arm64", "dist:desktop:dmg:x64": "node scripts/build-desktop-artifact.ts --platform mac --target dmg --arch x64", "dist:desktop:linux": "node scripts/build-desktop-artifact.ts --platform linux --target AppImage --arch x64", + "dist:desktop:linux:dir": "node scripts/build-desktop-artifact.ts --platform linux --target dir --arch x64", "dist:gnome-extension": "gnome-extensions pack apps/desktop/gnome-extension --extra-source=captureService.js --extra-source=captureFeedback.js --extra-source=feedbackGeometry.js --out-dir=release --force", "dist:desktop:win": "node scripts/build-desktop-artifact.ts --platform win --target nsis", "dist:desktop:win:arm64": "node scripts/build-desktop-artifact.ts --platform win --target nsis --arch arm64", @@ -52,6 +55,7 @@ "@effect/tsgo": "catalog:", "@types/node": "catalog:", "knip": "6.34.0", + "lint-staged": "^16.4.0", "typescript": "catalog:", "vite-plus": "catalog:" }, diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json index 2a5eb2c7fe93..e89733b63807 100644 --- a/packages/client-runtime/package.json +++ b/packages/client-runtime/package.json @@ -91,6 +91,18 @@ "types": "./src/relay/index.ts", "default": "./src/relay/index.ts" }, + "./state/ai-usage": { + "types": "./src/state/aiUsage.ts", + "default": "./src/state/aiUsage.ts" + }, + "./state/aiUsagePresentation": { + "types": "./src/state/aiUsagePresentation.ts", + "default": "./src/state/aiUsagePresentation.ts" + }, + "./state/identity": { + "types": "./src/state/identity.ts", + "default": "./src/state/identity.ts" + }, "./state/auth": { "types": "./src/state/auth.ts", "default": "./src/state/auth.ts" @@ -179,6 +191,10 @@ "types": "./src/state/server.ts", "default": "./src/state/server.ts" }, + "./state/hostResourcePresentation": { + "types": "./src/state/hostResourcePresentation.ts", + "default": "./src/state/hostResourcePresentation.ts" + }, "./state/session": { "types": "./src/state/session.ts", "default": "./src/state/session.ts" @@ -207,10 +223,22 @@ "types": "./src/state/subagentRuntime.ts", "default": "./src/state/subagentRuntime.ts" }, + "./state/thread-reducer": { + "types": "./src/state/threadReducer.ts", + "default": "./src/state/threadReducer.ts" + }, + "./state/older-thread-activities": { + "types": "./src/state/olderThreadActivities.ts", + "default": "./src/state/olderThreadActivities.ts" + }, "./state/thread-sort": { "types": "./src/state/threadSort.ts", "default": "./src/state/threadSort.ts" }, + "./state/thread-recency-groups": { + "types": "./src/state/threadRecencyGroups.ts", + "default": "./src/state/threadRecencyGroups.ts" + }, "./state/thread-settled": { "types": "./src/state/threadSettled.ts", "default": "./src/state/threadSettled.ts" @@ -219,10 +247,18 @@ "types": "./src/state/threadSearch.ts", "default": "./src/state/threadSearch.ts" }, + "./state/needs-attention": { + "types": "./src/state/needsAttention.ts", + "default": "./src/state/needsAttention.ts" + }, "./state/vcs": { "types": "./src/state/vcs.ts", "default": "./src/state/vcs.ts" }, + "./state/worktreeCleanup": { + "types": "./src/state/worktreeCleanup.ts", + "default": "./src/state/worktreeCleanup.ts" + }, "./work-log/user-input": { "types": "./src/work-log/userInput.ts", "default": "./src/work-log/userInput.ts" @@ -264,7 +300,17 @@ }, "devDependencies": { "@effect/vitest": "catalog:", + "@types/react": "~19.2.14", "micromark-util-types": "^2.0.2", + "react": "19.2.6", "vite-plus": "catalog:" + }, + "peerDependencies": { + "react": "^19.0.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + } } } diff --git a/packages/client-runtime/src/authorization/remote.test.ts b/packages/client-runtime/src/authorization/remote.test.ts index 0df4bab35ed8..a6be6dc4a7de 100644 --- a/packages/client-runtime/src/authorization/remote.test.ts +++ b/packages/client-runtime/src/authorization/remote.test.ts @@ -520,9 +520,18 @@ describe("remote environment authorization", () => { connectionMethod: "relay", }).pipe(provideRemoteHttp(fetch.fetchFn)); - expect(url).toBe( - "wss://remote.example.com/ws?wsTicket=ws-ticket&clientSurface=mobile&clientAppVersion=1.2.3&clientDeviceType=phone&clientOs=Android&clientOsMajorVersion=15&clientDeviceModel=Pixel+9&connectionMethod=relay", - ); + const parsed = new URL(url); + expect(parsed.origin + parsed.pathname).toBe("wss://remote.example.com/ws"); + expect(parsed.searchParams.get("wsTicket")).toBe("ws-ticket"); + expect(parsed.searchParams.get("productFamily")).toBe("omegent-t3"); + expect(parsed.searchParams.get("productToken")).toBeTruthy(); + expect(parsed.searchParams.get("clientSurface")).toBe("mobile"); + expect(parsed.searchParams.get("clientAppVersion")).toBe("1.2.3"); + expect(parsed.searchParams.get("clientDeviceType")).toBe("phone"); + expect(parsed.searchParams.get("clientOs")).toBe("Android"); + expect(parsed.searchParams.get("clientOsMajorVersion")).toBe("15"); + expect(parsed.searchParams.get("clientDeviceModel")).toBe("Pixel 9"); + expect(parsed.searchParams.get("connectionMethod")).toBe("relay"); }), ); }); diff --git a/packages/client-runtime/src/authorization/remote.ts b/packages/client-runtime/src/authorization/remote.ts index 538c0aa114a3..2c482aaae389 100644 --- a/packages/client-runtime/src/authorization/remote.ts +++ b/packages/client-runtime/src/authorization/remote.ts @@ -7,6 +7,7 @@ import { type AuthEnvironmentScope, } from "@t3tools/contracts"; import { encodeOAuthScope } from "@t3tools/shared/oauthScope"; +import { appendOmegentT3ProductHandshake } from "@t3tools/shared/productFamily"; import * as Effect from "effect/Effect"; import { environmentEndpointUrl } from "../environment/endpoint.ts"; import { @@ -241,7 +242,7 @@ export const resolveRemoteWebSocketConnectionUrl = Effect.fn( } url.searchParams.set("wsTicket", issued.ticket); appendClientConnectionParams(url, input.clientMetadata, input.connectionMethod); - return url.toString(); + return appendOmegentT3ProductHandshake(url.toString()); }); export const resolveRemoteDpopWebSocketConnectionUrl = Effect.fn( @@ -267,5 +268,5 @@ export const resolveRemoteDpopWebSocketConnectionUrl = Effect.fn( } url.searchParams.set("wsTicket", issued.ticket); appendClientConnectionParams(url, input.clientMetadata, input.connectionMethod); - return url.toString(); + return appendOmegentT3ProductHandshake(url.toString()); }); diff --git a/packages/client-runtime/src/connection/connectivity.test.ts b/packages/client-runtime/src/connection/connectivity.test.ts new file mode 100644 index 000000000000..7e607ee30d0b --- /dev/null +++ b/packages/client-runtime/src/connection/connectivity.test.ts @@ -0,0 +1,298 @@ +import { describe, expect, it } from "@effect/vitest"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Ref from "effect/Ref"; +import * as Stream from "effect/Stream"; +import * as SubscriptionRef from "effect/SubscriptionRef"; + +import * as Connectivity from "./connectivity.ts"; +import type { NetworkStatus } from "./model.ts"; +import * as ConnectionWakeups from "./wakeups.ts"; + +const makeHarness = Effect.fn("TestConnectivityHarness.make")(function* (options?: { + readonly status?: Effect.Effect; + readonly initialStatus?: NetworkStatus; +}) { + const liveStatus = yield* Ref.make(options?.initialStatus ?? "online"); + const reported = yield* SubscriptionRef.make<{ + readonly sequence: number; + readonly status: NetworkStatus; + }>({ sequence: 0, status: options?.initialStatus ?? "online" }); + const wakeups = yield* SubscriptionRef.make(0); + const applied = yield* Ref.make>([]); + + const connectivity = Connectivity.Connectivity.of({ + status: options?.status ?? Ref.get(liveStatus), + changes: SubscriptionRef.changes(reported).pipe( + Stream.drop(1), + Stream.map((event) => event.status), + ), + }); + + const wakeupService = ConnectionWakeups.ConnectionWakeups.of({ + changes: SubscriptionRef.changes(wakeups).pipe( + Stream.drop(1), + Stream.map(() => "application-active" as const), + ), + }); + + return { + connectivity, + wakeups: wakeupService, + applied, + setLiveStatus: (status: NetworkStatus) => Ref.set(liveStatus, status), + // Emits a listener event, as a platform connectivity listener would. + report: (status: NetworkStatus) => + Ref.set(liveStatus, status).pipe( + Effect.andThen( + SubscriptionRef.update(reported, (event) => ({ + sequence: event.sequence + 1, + status, + })), + ), + ), + resume: SubscriptionRef.update(wakeups, (count) => count + 1), + apply: (status: NetworkStatus) => Ref.update(applied, (statuses) => [...statuses, status]), + }; +}); + +// The forked listeners subscribe after `followNetworkStatus` returns, so repeat +// the trigger until its effect is observed rather than racing the first one. +const untilApplied = Effect.fn("TestConnectivityHarness.untilApplied")(function* ( + trigger: Effect.Effect, + applied: Ref.Ref>, + expected: number, +) { + for (let attempt = 0; attempt < 100; attempt += 1) { + yield* trigger; + yield* Effect.yieldNow; + if ((yield* Ref.get(applied)).length >= expected) { + return yield* Ref.get(applied); + } + } + return yield* Effect.die(new Error("The expected network status was never applied.")); +}); + +describe("followNetworkStatus", () => { + it.effect("applies statuses reported by the platform listener", () => + Effect.scoped( + Effect.gen(function* () { + const harness = yield* makeHarness(); + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: harness.apply, + }); + + const applied = yield* untilApplied(harness.report("offline"), harness.applied, 1); + expect(applied).toEqual(["offline"]); + }), + ), + ); + + it.effect("applies a resumed read when the listener missed a transition", () => + Effect.scoped( + Effect.gen(function* () { + const harness = yield* makeHarness({ initialStatus: "offline" }); + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: harness.apply, + }); + + // The device came back online while suspended and the listener never + // reported the transition. + yield* harness.setLiveStatus("online"); + const applied = yield* untilApplied(harness.resume, harness.applied, 1); + expect(applied).toEqual(["online"]); + }), + ), + ); + + it.effect("discards a resumed read that a repeated report raced", () => + Effect.scoped( + Effect.gen(function* () { + const readStarted = yield* Deferred.make(); + const releaseRead = yield* Deferred.make(); + const harness = yield* makeHarness({ + initialStatus: "online", + // The resume samples a brief opposite state. + status: Deferred.succeed(readStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseRead)), + Effect.as("offline" as const), + ), + }); + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: harness.apply, + }); + + // Apply "online" first so the listener's later repeat of it is genuinely + // redundant rather than a new status. + yield* untilApplied(harness.report("online"), harness.applied, 1); + yield* harness.resume.pipe( + Effect.andThen(Effect.yieldNow), + Effect.repeat({ until: () => Deferred.isDone(readStarted) }), + ); + + // The repeat carries no new status, but it proves the listener spoke + // after this read began, so the read is stale even though the status it + // returns differs. Applying it would strand consumers on "offline" while + // the platform reports "online" — the very failure this helper exists to + // prevent. + yield* harness.report("online"); + yield* Effect.yieldNow; + yield* Deferred.succeed(releaseRead, undefined); + yield* Effect.yieldNow; + yield* Effect.yieldNow; + + expect(yield* Ref.get(harness.applied)).toEqual(["online"]); + }), + ), + ); + + it.effect("still deduplicates a repeated report before it reaches consumers", () => + Effect.scoped( + Effect.gen(function* () { + const harness = yield* makeHarness({ initialStatus: "online" }); + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: harness.apply, + }); + + yield* untilApplied(harness.report("offline"), harness.applied, 1); + // Counting the repeat for staleness must not turn it into a redundant + // consumer update. + yield* harness.report("offline"); + yield* Effect.yieldNow; + yield* Effect.yieldNow; + expect(yield* Ref.get(harness.applied)).toEqual(["offline"]); + + // A genuine transition after the repeat still lands. + yield* untilApplied(harness.report("online"), harness.applied, 2); + expect(yield* Ref.get(harness.applied)).toEqual(["offline", "online"]); + }), + ), + ); + + it.effect("does not start a second status read while one is in flight", () => + Effect.scoped( + Effect.gen(function* () { + const firstRead = yield* Deferred.make(); + const readCount = yield* Ref.make(0); + const harness = yield* makeHarness({ + initialStatus: "unknown", + status: Ref.updateAndGet(readCount, (count) => count + 1).pipe( + Effect.andThen(Deferred.await(firstRead)), + ), + }); + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: harness.apply, + }); + + yield* harness.resume.pipe( + Effect.andThen(Effect.yieldNow), + Effect.repeat({ + until: () => Ref.get(readCount).pipe(Effect.map((count) => count >= 1)), + }), + ); + + // Resumes are consumed sequentially, so further resumes cannot start a + // read that races the one already in flight. Overlapping snapshots + // therefore cannot apply out of order. + yield* harness.resume; + yield* harness.resume; + yield* Effect.yieldNow; + expect(yield* Ref.get(readCount)).toBe(1); + + yield* Deferred.succeed(firstRead, "online"); + yield* Effect.yieldNow; + expect(yield* Ref.get(harness.applied)).toEqual(["online"]); + }), + ), + ); + + it.effect("discards a resumed read that a newer reported change superseded", () => + Effect.scoped( + Effect.gen(function* () { + const readStarted = yield* Deferred.make(); + const releaseRead = yield* Deferred.make(); + const harness = yield* makeHarness({ + initialStatus: "offline", + status: Deferred.succeed(readStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseRead)), + Effect.as("online" as const), + ), + }); + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: harness.apply, + }); + + // Resume, and hold the status read open so the listener can report a + // newer transition while that read is still in flight. + yield* harness.resume.pipe( + Effect.andThen(Effect.yieldNow), + Effect.repeat({ until: () => Deferred.isDone(readStarted) }), + ); + yield* untilApplied(harness.report("offline"), harness.applied, 1); + yield* Deferred.succeed(releaseRead, undefined); + yield* Effect.yieldNow; + + // The stale "online" snapshot must not land on top of the newer event. + expect(yield* Ref.get(harness.applied)).toEqual(["offline"]); + }), + ), + ); + + it.effect("keeps a reported change from interleaving with a resumed apply", () => + Effect.scoped( + Effect.gen(function* () { + const applyStarted = yield* Deferred.make(); + const releaseApply = yield* Deferred.make(); + const harness = yield* makeHarness({ initialStatus: "offline" }); + // Holds the resumed apply open once it begins, so a reported change has + // a window to interleave between the guard and its apply. + const gatedApply = (status: NetworkStatus) => + status === "online" + ? Deferred.succeed(applyStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseApply)), + Effect.andThen(harness.apply(status)), + ) + : harness.apply(status); + + yield* Connectivity.followNetworkStatus({ + connectivity: harness.connectivity, + wakeups: harness.wakeups, + apply: gatedApply, + }); + + yield* harness.setLiveStatus("online"); + yield* harness.resume.pipe( + Effect.andThen(Effect.yieldNow), + Effect.repeat({ until: () => Deferred.isDone(applyStarted) }), + ); + + // The listener reports a newer transition mid-apply. + yield* harness.report("offline"); + yield* Effect.yieldNow; + yield* Deferred.succeed(releaseApply, undefined); + yield* Effect.yieldNow.pipe( + Effect.repeat({ + until: () => + Ref.get(harness.applied).pipe(Effect.map((statuses) => statuses.length >= 2)), + }), + ); + + // The reported change has to land last; applying it before the resumed + // status finished would leave the stale "online" as the final word. + expect(yield* Ref.get(harness.applied)).toEqual(["online", "offline"]); + }), + ), + ); +}); diff --git a/packages/client-runtime/src/connection/connectivity.ts b/packages/client-runtime/src/connection/connectivity.ts index 9bf9dbdb2409..909d33c36d16 100644 --- a/packages/client-runtime/src/connection/connectivity.ts +++ b/packages/client-runtime/src/connection/connectivity.ts @@ -1,9 +1,13 @@ import * as Context from "effect/Context"; -import type * as Effect from "effect/Effect"; +import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; -import type * as Stream from "effect/Stream"; +import * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; +import * as Semaphore from "effect/Semaphore"; +import * as Stream from "effect/Stream"; import type { NetworkStatus } from "./model.ts"; +import * as ConnectionWakeups from "./wakeups.ts"; export class Connectivity extends Context.Service< Connectivity, @@ -17,3 +21,79 @@ const make = (service: Connectivity["Service"]) => Connectivity.of(service); export const layer = (service: Connectivity["Service"]) => Layer.succeed(Connectivity, make(service)); + +/** + * Applies every reported connectivity change, plus a freshly read status each + * time the application resumes. + * + * Platform listeners drop transitions while an app is suspended, so a consumer + * that follows `changes` alone keeps a stale status until the next real + * transition — which left mobile stranded on "offline" until it was restarted. + * Reading the status is asynchronous, so a read that started before a newer + * reported change is discarded instead of applied over it. + */ +export const followNetworkStatus = Effect.fnUntraced(function* (options: { + readonly connectivity: Connectivity["Service"]; + readonly wakeups: ConnectionWakeups.ConnectionWakeups["Service"]; + readonly apply: (status: NetworkStatus) => Effect.Effect; +}) { + // Counts every report the listener delivers, including one that repeats the + // status already in effect. Such a repeat carries no new status, but it does + // prove the listener spoke more recently than a resume read still in flight, + // so it has to invalidate that read: otherwise a snapshot taken during a brief + // opposite state would land afterwards and overwrite the real status. + const reportCount = yield* Ref.make(0); + // Tracks what was last handed to `options.apply` purely to keep repeats from + // reaching consumers. Deduplication is deliberately kept separate from the + // staleness guard above. + const appliedStatus = yield* Ref.make>(Option.none()); + // Counting a report and applying it has to be indivisible with respect to the + // resume branch's guard. Otherwise a change landing between that guard and its + // apply would be overwritten by the older read. + const applyLock = yield* Semaphore.make(1); + + const applyStatus = Effect.fnUntraced(function* (status: NetworkStatus) { + const changed = yield* Ref.modify(appliedStatus, (current) => + Option.isSome(current) && current.value === status + ? ([false, current] as const) + : ([true, Option.some(status)] as const), + ); + if (changed) { + yield* options.apply(status); + } + }); + + yield* options.connectivity.changes.pipe( + Stream.runForEach((status) => + applyLock.withPermits(1)( + Ref.update(reportCount, (count) => count + 1).pipe(Effect.andThen(applyStatus(status))), + ), + ), + // Subscribe before returning so a transition reported while this is still + // being set up is not dropped. + Effect.forkScoped({ startImmediately: true }), + ); + + yield* options.wakeups.changes.pipe( + Stream.runForEach((reason) => + reason === "application-active" + ? Effect.gen(function* () { + // `runForEach` is sequential, so resume reads cannot overlap: a + // second resume does not start a read until this one has applied. + const startedAt = yield* Ref.get(reportCount); + const status = yield* options.connectivity.status; + yield* applyLock.withPermits(1)( + Effect.gen(function* () { + // Re-read under the permit: any report that arrived while the + // read was in flight is newer, so this result is stale. + if ((yield* Ref.get(reportCount)) === startedAt) { + yield* applyStatus(status); + } + }), + ); + }) + : Effect.void, + ), + Effect.forkScoped({ startImmediately: true }), + ); +}); diff --git a/packages/client-runtime/src/connection/diagnosticsLog.test.ts b/packages/client-runtime/src/connection/diagnosticsLog.test.ts new file mode 100644 index 000000000000..6ce095e769bf --- /dev/null +++ b/packages/client-runtime/src/connection/diagnosticsLog.test.ts @@ -0,0 +1,52 @@ +import { describe, expect, it } from "@effect/vitest"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; + +import { + CONNECTION_DIAGNOSTICS_STORAGE_KEY, + clearConnectionDiagnosticsForTests, + layer, + ConnectionDiagnosticsLog, +} from "./diagnosticsLog.ts"; + +describe("ConnectionDiagnosticsLog", () => { + it.effect("records events and prunes entries older than the retention window", () => + Effect.gen(function* () { + clearConnectionDiagnosticsForTests(); + const log = yield* ConnectionDiagnosticsLog; + const now = yield* DateTime.now; + const staleAt = DateTime.formatIso(DateTime.subtract(now, { hours: 13 })); + const freshAt = DateTime.formatIso(now); + + yield* log.record({ + at: staleAt, + environmentId: "env-old", + label: "old", + kind: "disconnect", + reason: "transport", + detail: "old disconnect", + }); + yield* log.record({ + at: freshAt, + environmentId: "env-new", + label: "t3vm", + kind: "disconnect", + reason: "transport", + detail: "t3vm closed (1006 abnormal).", + closeCode: 1006, + socketHost: "198.18.83.2:3773", + }); + + const events = yield* log.list; + expect(events.map((event) => event.environmentId)).toEqual(["env-new"]); + expect(events[0]?.detail).toContain("1006"); + expect(events[0]?.socketHost).toBe("198.18.83.2:3773"); + + if (typeof globalThis.localStorage !== "undefined") { + const raw = globalThis.localStorage.getItem(CONNECTION_DIAGNOSTICS_STORAGE_KEY); + expect(raw).toContain("env-new"); + expect(raw).not.toContain("env-old"); + } + }).pipe(Effect.provide(layer)), + ); +}); diff --git a/packages/client-runtime/src/connection/diagnosticsLog.ts b/packages/client-runtime/src/connection/diagnosticsLog.ts new file mode 100644 index 000000000000..6de0aa7485eb --- /dev/null +++ b/packages/client-runtime/src/connection/diagnosticsLog.ts @@ -0,0 +1,177 @@ +/** + * Short-lived connection diagnostics for post-hoc debugging of reconnect storms. + * + * Events are stored as NDJSON-ish JSON records with a hard 12-hour retention window. + * Default sink uses localStorage when available, otherwise an in-memory ring. + * Always also emits Effect.logWarning so traces/console still see the event. + */ +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; + +export const CONNECTION_DIAGNOSTICS_RETENTION_MS = 12 * 60 * 60 * 1000; +export const CONNECTION_DIAGNOSTICS_STORAGE_KEY = "t3code:connection-diagnostics:v1"; +const MAX_EVENTS = 400; + +export const ConnectionDiagnosticKind = Schema.Literals([ + "disconnect", + "connect_failed", + "backoff", + "blocked", + "probe_failed", +]); +export type ConnectionDiagnosticKind = typeof ConnectionDiagnosticKind.Type; + +export class ConnectionDiagnosticEvent extends Schema.Class( + "ConnectionDiagnosticEvent", +)({ + at: Schema.String, + environmentId: Schema.String, + label: Schema.String, + kind: ConnectionDiagnosticKind, + reason: Schema.String, + detail: Schema.String, + traceId: Schema.optionalKey(Schema.String), + closeCode: Schema.optionalKey(Schema.Number), + closeReason: Schema.optionalKey(Schema.String), + /** Hostname only — never full socket URLs (tickets). */ + socketHost: Schema.optionalKey(Schema.String), + attempt: Schema.optionalKey(Schema.Number), +}) {} + +export type ConnectionDiagnosticEventInput = { + readonly environmentId: string; + readonly label: string; + readonly kind: ConnectionDiagnosticKind; + readonly reason: string; + readonly detail: string; + readonly traceId?: string | undefined; + readonly closeCode?: number | undefined; + readonly closeReason?: string | undefined; + readonly socketHost?: string | undefined; + readonly attempt?: number | undefined; + readonly at?: string | undefined; +}; + +export class ConnectionDiagnosticsLog extends Context.Service< + ConnectionDiagnosticsLog, + { + readonly record: (event: ConnectionDiagnosticEventInput) => Effect.Effect; + readonly list: Effect.Effect>; + } +>()("@t3tools/client-runtime/connection/diagnosticsLog/ConnectionDiagnosticsLog") {} + +function pruneEvents( + events: ReadonlyArray, + nowMs: number, +): ConnectionDiagnosticEvent[] { + const cutoff = nowMs - CONNECTION_DIAGNOSTICS_RETENTION_MS; + return events + .filter((event) => { + const atMs = Date.parse(event.at); + return Number.isFinite(atMs) && atMs >= cutoff; + }) + .slice(-MAX_EVENTS); +} + +function readStorage(): ConnectionDiagnosticEvent[] { + if (typeof globalThis.localStorage === "undefined") return []; + try { + const raw = globalThis.localStorage.getItem(CONNECTION_DIAGNOSTICS_STORAGE_KEY); + if (!raw) return []; + const parsed = JSON.parse(raw) as unknown; + if (!Array.isArray(parsed)) return []; + return parsed.flatMap((item) => { + try { + return [Schema.decodeSync(ConnectionDiagnosticEvent)(item)]; + } catch { + return []; + } + }); + } catch { + return []; + } +} + +function writeStorage(events: ReadonlyArray): void { + if (typeof globalThis.localStorage === "undefined") return; + try { + globalThis.localStorage.setItem(CONNECTION_DIAGNOSTICS_STORAGE_KEY, JSON.stringify(events)); + } catch { + // Quota / private mode — drop silently; Effect.log still recorded. + } +} + +let memoryEvents: ConnectionDiagnosticEvent[] = []; + +export const make = Effect.sync(() => { + const record = (input: ConnectionDiagnosticEventInput): Effect.Effect => + Effect.gen(function* () { + const nowMs = yield* Clock.currentTimeMillis; + const event = new ConnectionDiagnosticEvent({ + at: input.at ?? DateTime.formatIso(yield* DateTime.now), + environmentId: input.environmentId, + label: input.label, + kind: input.kind, + reason: input.reason, + detail: input.detail, + ...(input.traceId !== undefined ? { traceId: input.traceId } : {}), + ...(input.closeCode !== undefined ? { closeCode: input.closeCode } : {}), + ...(input.closeReason !== undefined ? { closeReason: input.closeReason } : {}), + ...(input.socketHost !== undefined ? { socketHost: input.socketHost } : {}), + ...(input.attempt !== undefined ? { attempt: input.attempt } : {}), + }); + + yield* Effect.logWarning("connection diagnostics", { + kind: event.kind, + environmentId: event.environmentId, + label: event.label, + reason: event.reason, + detail: event.detail, + ...(event.traceId !== undefined ? { traceId: event.traceId } : {}), + ...(event.closeCode !== undefined ? { closeCode: event.closeCode } : {}), + ...(event.socketHost !== undefined ? { socketHost: event.socketHost } : {}), + ...(event.attempt !== undefined ? { attempt: event.attempt } : {}), + }); + + const previous = + typeof globalThis.localStorage !== "undefined" ? readStorage() : memoryEvents; + const next = pruneEvents([...previous, event], nowMs); + if (typeof globalThis.localStorage !== "undefined") { + writeStorage(next); + } else { + memoryEvents = next; + } + }).pipe(Effect.asVoid, Effect.ignore); + + const list = Effect.gen(function* () { + const nowMs = yield* Clock.currentTimeMillis; + const previous = typeof globalThis.localStorage !== "undefined" ? readStorage() : memoryEvents; + const next = pruneEvents(previous, nowMs); + if (typeof globalThis.localStorage !== "undefined") { + writeStorage(next); + } else { + memoryEvents = next; + } + return next; + }); + + return ConnectionDiagnosticsLog.of({ record, list }); +}); + +export const layer = Layer.effect(ConnectionDiagnosticsLog, make); + +/** Test helper: clear in-memory / localStorage diagnostics. */ +export function clearConnectionDiagnosticsForTests(): void { + memoryEvents = []; + if (typeof globalThis.localStorage !== "undefined") { + try { + globalThis.localStorage.removeItem(CONNECTION_DIAGNOSTICS_STORAGE_KEY); + } catch { + // ignore + } + } +} diff --git a/packages/client-runtime/src/connection/disconnectDetail.test.ts b/packages/client-runtime/src/connection/disconnectDetail.test.ts new file mode 100644 index 000000000000..efbda05480d8 --- /dev/null +++ b/packages/client-runtime/src/connection/disconnectDetail.test.ts @@ -0,0 +1,68 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { + describeWebSocketCloseCode, + formatDisconnectDetail, + formatDisconnectStatusFragment, +} from "./disconnectDetail.ts"; + +describe("disconnectDetail", () => { + it("maps common close codes", () => { + expect(describeWebSocketCloseCode(1000)).toBe("clean"); + expect(describeWebSocketCloseCode(1006)).toBe("abnormal"); + expect(describeWebSocketCloseCode(1012)).toBe("service restart"); + expect(describeWebSocketCloseCode(42)).toBeNull(); + }); + + it("formats a connected disconnect with close code", () => { + expect( + formatDisconnectDetail({ + label: "t3vm", + wasConnected: true, + close: { code: 1006 }, + }), + ).toBe("t3vm closed (1006 abnormal)."); + }); + + it("includes a short close reason when it adds information", () => { + expect( + formatDisconnectDetail({ + label: "t3vm", + wasConnected: true, + close: { code: 1012, reason: "service restart" }, + }), + ).toBe("t3vm closed (1012 service restart)."); + expect( + formatDisconnectDetail({ + label: "t3vm", + wasConnected: true, + close: { code: 1000, reason: "deploy rolling" }, + }), + ).toBe("t3vm closed (1000 clean: deploy rolling)."); + }); + + it("prefers ping timeout over a bare disconnect", () => { + expect( + formatDisconnectDetail({ + label: "t3vm", + wasConnected: true, + causeMessage: "ping timeout", + }), + ).toBe("t3vm ping timeout."); + }); + + it("formats open failures without claiming a prior session", () => { + expect( + formatDisconnectDetail({ + label: "t3vm", + wasConnected: false, + }), + ).toBe("t3vm could not open WebSocket."); + }); + + it("strips trailing periods for status fragments", () => { + expect(formatDisconnectStatusFragment("t3vm closed (1006 abnormal).")).toBe( + "t3vm closed (1006 abnormal)", + ); + }); +}); diff --git a/packages/client-runtime/src/connection/disconnectDetail.ts b/packages/client-runtime/src/connection/disconnectDetail.ts new file mode 100644 index 000000000000..6da377826b7d --- /dev/null +++ b/packages/client-runtime/src/connection/disconnectDetail.ts @@ -0,0 +1,129 @@ +/** + * Short, user-safe connection failure text for UI + diagnostics. + * Prefer a close code or known cause over the bare "disconnected." message. + */ + +export interface SocketCloseCapture { + readonly code?: number | undefined; + readonly reason?: string | undefined; +} + +export interface FormatDisconnectDetailInput { + readonly label: string; + readonly wasConnected: boolean; + readonly close?: SocketCloseCapture | undefined; + /** Underlying transport message when available (e.g. "ping timeout"). */ + readonly causeMessage?: string | undefined; +} + +const MAX_REASON_CHARS = 48; + +/** Well-known WebSocket close codes we surface by short name. */ +export function describeWebSocketCloseCode(code: number): string | null { + switch (code) { + case 1000: + return "clean"; + case 1001: + return "going away"; + case 1002: + return "protocol error"; + case 1003: + return "unsupported data"; + case 1005: + return "no status"; + case 1006: + return "abnormal"; + case 1007: + return "bad data"; + case 1008: + return "policy violation"; + case 1009: + return "too large"; + case 1011: + return "server error"; + case 1012: + return "service restart"; + case 1013: + return "try again later"; + case 1014: + return "bad gateway"; + case 1015: + return "TLS failed"; + default: + return null; + } +} + +function sanitizeCloseReason(reason: string | undefined): string | null { + if (typeof reason !== "string") return null; + const trimmed = reason.replace(/\s+/g, " ").trim(); + if (trimmed.length === 0) return null; + if (trimmed.length <= MAX_REASON_CHARS) return trimmed; + return `${trimmed.slice(0, MAX_REASON_CHARS - 1)}…`; +} + +function normalizeCauseMessage(message: string | undefined): string | null { + if (typeof message !== "string") return null; + const trimmed = message.replace(/\s+/g, " ").trim(); + if (trimmed.length === 0) return null; + // Drop generic Effect wrappers; keep the useful tail. + const lower = trimmed.toLowerCase(); + if (lower.includes("ping timeout")) return "ping timeout"; + if (lower.includes("socketcloseerror")) { + const match = trimmed.match(/SocketCloseError[:\s]*([^\n]+)/i); + return match?.[1]?.trim() ?? "socket closed"; + } + if (lower.includes("socketopenerror")) return "socket open failed"; + if (lower === "socket is not connected") return "socket not connected"; + return null; +} + +/** + * Full detail string stored on ConnectionTransientError / shown as secondary UI text. + */ +export function formatDisconnectDetail(input: FormatDisconnectDetailInput): string { + const label = input.label.trim() || "Environment"; + const cause = normalizeCauseMessage(input.causeMessage); + const code = input.close?.code; + const codeName = + typeof code === "number" && Number.isFinite(code) ? describeWebSocketCloseCode(code) : null; + const closeReason = sanitizeCloseReason(input.close?.reason); + + if (!input.wasConnected) { + if (cause) return `${label} could not open WebSocket (${cause}).`; + // Our open-timeout path closes with 1000; that is not useful "clean" signal. + const usefulOpenClose = + typeof code === "number" && !(code === 1000 && (closeReason === null || closeReason === "")); + if (usefulOpenClose) { + const bits = [`${code}${codeName ? ` ${codeName}` : ""}`, closeReason].filter(Boolean); + return `${label} could not open WebSocket (${bits.join(": ")}).`; + } + return `${label} could not open WebSocket.`; + } + + if (cause === "ping timeout") { + return `${label} ping timeout.`; + } + + if (typeof code === "number") { + const head = `${code}${codeName ? ` ${codeName}` : ""}`; + if ( + closeReason && + closeReason.toLowerCase() !== (codeName ?? "").toLowerCase() && + !head.toLowerCase().includes(closeReason.toLowerCase()) + ) { + return `${label} closed (${head}: ${closeReason}).`; + } + return `${label} closed (${head}).`; + } + + if (cause) return `${label} disconnected (${cause}).`; + return `${label} disconnected.`; +} + +/** + * Compact fragment for inline status lines (no trailing period). + */ +export function formatDisconnectStatusFragment(detail: string): string { + return detail.replace(/\.$/, "").trim(); +} diff --git a/packages/client-runtime/src/connection/index.ts b/packages/client-runtime/src/connection/index.ts index 127a6288fa1b..edc2b2cbd33b 100644 --- a/packages/client-runtime/src/connection/index.ts +++ b/packages/client-runtime/src/connection/index.ts @@ -20,3 +20,19 @@ export { } from "./registry.ts"; export { EnvironmentSupervisor, type EnvironmentSupervisorOptions } from "./supervisor.ts"; export * as Wakeups from "./wakeups.ts"; +export { + CONNECTION_DIAGNOSTICS_RETENTION_MS, + CONNECTION_DIAGNOSTICS_STORAGE_KEY, + ConnectionDiagnosticEvent, + ConnectionDiagnosticsLog, + type ConnectionDiagnosticEventInput, + type ConnectionDiagnosticKind, + clearConnectionDiagnosticsForTests, +} from "./diagnosticsLog.ts"; +export { + describeWebSocketCloseCode, + formatDisconnectDetail, + formatDisconnectStatusFragment, + type FormatDisconnectDetailInput, + type SocketCloseCapture, +} from "./disconnectDetail.ts"; diff --git a/packages/client-runtime/src/connection/layer.ts b/packages/client-runtime/src/connection/layer.ts index 43153838df35..cff403cb40ea 100644 --- a/packages/client-runtime/src/connection/layer.ts +++ b/packages/client-runtime/src/connection/layer.ts @@ -6,21 +6,33 @@ import * as ConnectionResolver from "./resolver.ts"; import * as ConnectionDriver from "./driver.ts"; import * as EnvironmentRegistry from "./registry.ts"; import * as ConnectionOnboarding from "./onboarding.ts"; +import * as ConnectionDiagnosticsLog from "./diagnosticsLog.ts"; import * as PlatformConnectionSource from "../platform/source.ts"; import * as RelayEnvironmentDiscovery from "../relay/discovery.ts"; import * as RemoteEnvironmentAuthorization from "../authorization/service.ts"; import * as RpcSession from "../rpc/session.ts"; +const diagnosticsLogLayer = ConnectionDiagnosticsLog.layer; + export function layerWithOptions(options: RpcSession.RpcSessionOptions) { const driverLayer = ConnectionDriver.layer.pipe( - Layer.provide(Layer.mergeAll(ConnectionResolver.layer, RpcSession.layerWithOptions(options))), + Layer.provide( + Layer.mergeAll( + ConnectionResolver.layer, + RpcSession.layerWithOptions(options), + diagnosticsLogLayer, + ), + ), + ); + const registryLayer = EnvironmentRegistry.layer.pipe( + Layer.provide(Layer.mergeAll(driverLayer, diagnosticsLogLayer)), ); - const registryLayer = EnvironmentRegistry.layer.pipe(Layer.provide(driverLayer)); const onboardingLayer = ConnectionOnboarding.layer.pipe(Layer.provide(registryLayer)); const connectionServicesLayer = Layer.mergeAll( registryLayer, RelayEnvironmentDiscovery.layer, onboardingLayer, + diagnosticsLogLayer, ); const connectionStartupLayer = Layer.effectDiscard( Effect.gen(function* () { diff --git a/packages/client-runtime/src/connection/presentation.test.ts b/packages/client-runtime/src/connection/presentation.test.ts index 80ce8a374a9c..97ca0e05613e 100644 --- a/packages/client-runtime/src/connection/presentation.test.ts +++ b/packages/client-runtime/src/connection/presentation.test.ts @@ -124,10 +124,8 @@ describe("connection presentation", () => { error: "Relay request timed out.", traceId: "trace-retry", } as const; - expect(connectionStatusText(connection)).toBe( - "Failed to connect. Reconnecting... Reason: Relay request timed out.", - ); - expect(connectionStatusTitle(connection)).toBe("Failed to connect. Reconnecting..."); + expect(connectionStatusText(connection)).toBe("Reconnecting… · Relay request timed out"); + expect(connectionStatusTitle(connection)).toBe("Reconnecting..."); }); it("presents the supervisor's offline state without consulting shell state", () => { diff --git a/packages/client-runtime/src/connection/presentation.ts b/packages/client-runtime/src/connection/presentation.ts index 4093167d333c..4c53f41b6b61 100644 --- a/packages/client-runtime/src/connection/presentation.ts +++ b/packages/client-runtime/src/connection/presentation.ts @@ -55,6 +55,10 @@ export function presentConnectionState( } } +function compactConnectionError(error: string): string { + return error.replace(/\.$/, "").trim(); +} + export function connectionStatusText(connection: EnvironmentConnectionPresentation): string { switch (connection.phase) { case "available": @@ -64,21 +68,25 @@ export function connectionStatusText(connection: EnvironmentConnectionPresentati case "connecting": return "Connecting..."; case "reconnecting": + // Keep the primary line short; put the useful bit after a middle dot. return connection.error - ? `Failed to connect. Reconnecting... Reason: ${connection.error}` + ? `Reconnecting… · ${compactConnectionError(connection.error)}` : "Reconnecting..."; case "connected": return "Connected"; case "error": return connection.error - ? `Connection failed. Reason: ${connection.error}` + ? `Connection failed · ${compactConnectionError(connection.error)}` : "Connection failed"; } } export function connectionStatusTitle(connection: EnvironmentConnectionPresentation): string { - if (connection.phase === "reconnecting" && connection.error) { - return "Failed to connect. Reconnecting..."; + if (connection.phase === "reconnecting") { + return "Reconnecting..."; + } + if (connection.phase === "error") { + return "Connection failed"; } return connectionStatusText({ ...connection, error: null }); } diff --git a/packages/client-runtime/src/connection/registry.test.ts b/packages/client-runtime/src/connection/registry.test.ts index 15df040643ea..fb1fd6c713b2 100644 --- a/packages/client-runtime/src/connection/registry.test.ts +++ b/packages/client-runtime/src/connection/registry.test.ts @@ -274,8 +274,12 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* ( Ref.update(ownedDataClears, (environmentIds) => [...environmentIds, environmentId]), }); const networkStatus = yield* SubscriptionRef.make<"unknown" | "offline" | "online">("online"); + // Status reads come from a separate ref so a test can simulate a platform + // listener that missed a transition while the app was suspended. + const liveNetworkStatus = yield* Ref.make<"unknown" | "offline" | "online">("online"); + const wakeups = yield* SubscriptionRef.make(0); const connectivity = Connectivity.Connectivity.of({ - status: SubscriptionRef.get(networkStatus), + status: Ref.get(liveNetworkStatus), changes: SubscriptionRef.changes(networkStatus), }); const profileStore = ConnectionProfileStore.ConnectionProfileStore.of({ @@ -384,7 +388,12 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* ( Layer.succeed(Connectivity.Connectivity, connectivity), Layer.succeed( ConnectionWakeups.ConnectionWakeups, - ConnectionWakeups.ConnectionWakeups.of({ changes: Stream.never }), + ConnectionWakeups.ConnectionWakeups.of({ + changes: SubscriptionRef.changes(wakeups).pipe( + Stream.drop(1), + Stream.map(() => "application-active" as const), + ), + }), ), Layer.succeed(ConnectionDriver.ConnectionDriver, driver), cacheLayer, @@ -407,6 +416,11 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* ( storedRemoteTokens, disconnectedSshTargets, networkStatus, + // Changes the network the device is actually on without emitting a change + // event, mimicking a listener that was suspended while backgrounded. + setLiveNetworkStatus: (status: "unknown" | "offline" | "online") => + Ref.set(liveNetworkStatus, status), + resume: SubscriptionRef.update(wakeups, (count) => count + 1), }; }); @@ -514,6 +528,41 @@ describe("EnvironmentRegistry", () => { }), ); + it.effect("recovers the network status a suspended listener never reported", () => + Effect.gen(function* () { + const harness = yield* makeHarness([]); + + yield* Effect.gen(function* () { + const registry = yield* EnvironmentRegistry.EnvironmentRegistry; + const offline = yield* Effect.forkChild( + SubscriptionRef.changes(registry.networkStatus).pipe( + Stream.filter((status) => status === "offline"), + Stream.runHead, + ), + ); + yield* SubscriptionRef.set(harness.networkStatus, "offline"); + yield* Fiber.join(offline); + + // The device came back online while backgrounded and the listener never + // reported the transition, so only a fresh read can observe it. + yield* harness.setLiveNetworkStatus("online"); + // The forked listener subscribes after `start`, so repeat the resume + // until it is observed rather than racing the first one. + yield* harness.resume.pipe( + Effect.andThen(Effect.yieldNow), + Effect.repeat({ + while: () => + SubscriptionRef.get(registry.networkStatus).pipe( + Effect.map((status) => status !== "online"), + ), + }), + ); + + expect(yield* SubscriptionRef.get(registry.networkStatus)).toBe("online"); + }).pipe(Effect.provide(harness.layer), Effect.scoped); + }), + ); + it.effect("starts persisted environments independently", () => Effect.gen(function* () { const bothLoadsStarted = yield* Deferred.make(); diff --git a/packages/client-runtime/src/connection/registry.ts b/packages/client-runtime/src/connection/registry.ts index 16983fcbcc9f..34fb97845e98 100644 --- a/packages/client-runtime/src/connection/registry.ts +++ b/packages/client-runtime/src/connection/registry.ts @@ -654,10 +654,14 @@ export const make = Effect.gen(function* () { ), ), ); - yield* connectivity.changes.pipe( - Stream.runForEach((status) => SubscriptionRef.set(networkStatus, status)), - Effect.forkScoped, - ); + // `networkStatus` feeds the connection UI and readiness checks, so it has to + // recover from a transition dropped while the app was suspended just like the + // supervisors do. Otherwise a reconnected environment still reads as offline. + yield* Connectivity.followNetworkStatus({ + connectivity, + wakeups, + apply: (status) => SubscriptionRef.set(networkStatus, status), + }); return EnvironmentRegistry.of({ entries, diff --git a/packages/client-runtime/src/connection/resolver.test.ts b/packages/client-runtime/src/connection/resolver.test.ts index d1fc270f21fe..ca844f38b71b 100644 --- a/packages/client-runtime/src/connection/resolver.test.ts +++ b/packages/client-runtime/src/connection/resolver.test.ts @@ -168,15 +168,20 @@ describe("ConnectionResolver", () => { wsBaseUrl: "ws://127.0.0.1:3777", }); - expect(yield* broker.prepare(catalogEntry(target))).toEqual({ + const prepared = yield* broker.prepare(catalogEntry(target)); + expect(prepared).toMatchObject({ environmentId: ENVIRONMENT_ID, label: "Primary", httpBaseUrl: "http://127.0.0.1:3777", - socketUrl: - "ws://127.0.0.1:3777/ws?clientSurface=web&clientDeviceType=desktop&connectionMethod=direct", httpAuthorization: null, target, }); + expect(prepared.socketUrl.startsWith("ws://127.0.0.1:3777/ws?")).toBe(true); + const socketUrl = new URL(prepared.socketUrl); + expect(socketUrl.searchParams.get("productFamily")).toBe("omegent-t3"); + expect(socketUrl.searchParams.get("clientSurface")).toBe("web"); + expect(socketUrl.searchParams.get("clientDeviceType")).toBe("desktop"); + expect(socketUrl.searchParams.get("connectionMethod")).toBe("direct"); }), ); diff --git a/packages/client-runtime/src/connection/resolver.ts b/packages/client-runtime/src/connection/resolver.ts index 885529249a62..fdd2dca7709b 100644 --- a/packages/client-runtime/src/connection/resolver.ts +++ b/packages/client-runtime/src/connection/resolver.ts @@ -1,4 +1,5 @@ import type { AuthClientPresentationMetadata } from "@t3tools/contracts"; +import { appendOmegentT3ProductHandshake } from "@t3tools/shared/productFamily"; import { withRelayClientTracing } from "@t3tools/shared/relayTracing"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; @@ -50,7 +51,7 @@ function primarySocketUrl( url.pathname = "/ws"; } appendClientConnectionParams(url, clientMetadata, "direct"); - return url.toString(); + return appendOmegentT3ProductHandshake(url.toString()); } const makePrimaryBroker = Effect.fn("clientRuntime.connection.broker.makePrimary")(function* () { diff --git a/packages/client-runtime/src/connection/supervisor.test.ts b/packages/client-runtime/src/connection/supervisor.test.ts index 2da7a68bd3ca..6df1c6c4ff8d 100644 --- a/packages/client-runtime/src/connection/supervisor.test.ts +++ b/packages/client-runtime/src/connection/supervisor.test.ts @@ -37,6 +37,7 @@ import { type SupervisorConnectionState, } from "./model.ts"; import * as RpcSession from "../rpc/session.ts"; +import * as ConnectionDiagnosticsLog from "./diagnosticsLog.ts"; import * as EnvironmentSupervisor from "./supervisor.ts"; import * as ConnectionWakeups from "./wakeups.ts"; import { NETWORK_BLOCKING_HINT } from "../errors/network.ts"; @@ -127,9 +128,13 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?: readonly ready?: (attempt: number) => Effect.Effect; readonly probe?: (attempt: number) => Effect.Effect; }) { - const networkStatus = yield* SubscriptionRef.make( + // `reportedNetworkStatus` drives the change stream while `liveNetworkStatus` + // answers status reads, so a test can simulate a platform listener that missed + // a transition while the app was suspended. + const reportedNetworkStatus = yield* SubscriptionRef.make( options?.networkStatus ?? "online", ); + const liveNetworkStatus = yield* Ref.make(options?.networkStatus ?? "online"); const prepareCount = yield* Ref.make(0); const sessionCount = yield* Ref.make(0); const releaseCount = yield* Ref.make(0); @@ -145,8 +150,8 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?: >([]); const connectivity = Connectivity.Connectivity.of({ - status: SubscriptionRef.get(networkStatus), - changes: SubscriptionRef.changes(networkStatus), + status: Ref.get(liveNetworkStatus), + changes: SubscriptionRef.changes(reportedNetworkStatus), }); const prepare = Effect.fn("TestConnectionDriver.prepare")(function* (target: ConnectionTarget) { @@ -202,6 +207,7 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?: ConnectionDriver.ConnectionDriver, ConnectionDriver.ConnectionDriver.of({ connect }), ), + ConnectionDiagnosticsLog.layer, ); return { @@ -209,7 +215,13 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?: prepareCount, sessionCount, releaseCount, - setNetworkStatus: (status: NetworkStatus) => SubscriptionRef.set(networkStatus, status), + setNetworkStatus: (status: NetworkStatus) => + Ref.set(liveNetworkStatus, status).pipe( + Effect.andThen(SubscriptionRef.set(reportedNetworkStatus, status)), + ), + // Changes the network the device is actually on without emitting a change + // event, mimicking a listener that was suspended while backgrounded. + setNetworkStatusWithoutNotifying: (status: NetworkStatus) => Ref.set(liveNetworkStatus, status), wake: (reason: ConnectionWakeups.ConnectionWakeup) => SubscriptionRef.update(wakeups, (event) => ({ sequence: event.sequence + 1, @@ -355,6 +367,42 @@ describe("EnvironmentSupervisor", () => { }), ); + it.effect("recovers from a network change the platform dropped while suspended", () => + Effect.gen(function* () { + const harness = yield* makeHarness({ networkStatus: "offline" }); + const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, { + initiallyDesired: true, + }).pipe(Effect.provide(harness.dependencies)); + + yield* awaitState(supervisor.state, (state) => state.phase === "offline"); + + // The device regained connectivity while backgrounded, but the listener + // was suspended and never reported the transition. + yield* harness.setNetworkStatusWithoutNotifying("online"); + + // The supervisor reaches its offline state before the forked wakeup + // listener subscribes, so repeat the resume until it is observed. + yield* harness.wake("application-active").pipe( + Effect.andThen(Effect.yieldNow), + Effect.repeat({ + while: () => + SubscriptionRef.get(supervisor.state).pipe( + Effect.map((state) => state.phase === "offline"), + ), + }), + ); + + const ready = yield* awaitState(supervisor.state, (state) => state.phase === "connected"); + expect(ready).toMatchObject({ + desired: true, + network: "online", + phase: "connected", + lastFailure: null, + }); + expect(yield* Ref.get(harness.prepareCount)).toBe(1); + }), + ); + it.effect("retries forever with exponential backoff capped at sixteen seconds", () => Effect.gen(function* () { const harness = yield* makeHarness({ @@ -1057,7 +1105,7 @@ describe("EnvironmentSupervisor", () => { }).pipe(Effect.provide(TestClock.layer())), ); - it.effect("quickly times out a stalled mobile foreground liveness probe", () => + it.effect("quickly replaces a stalled mobile session after a probe timeout", () => Effect.gen(function* () { const harness = yield* makeHarness({ probe: (attempt) => (attempt === 1 ? Effect.never : Effect.void), @@ -1077,6 +1125,7 @@ describe("EnvironmentSupervisor", () => { ); expect(yield* Ref.get(harness.sessionCount)).toBe(2); + expect(yield* Ref.get(harness.releaseCount)).toBe(1); }).pipe(Effect.provide(TestClock.layer())), ); diff --git a/packages/client-runtime/src/connection/supervisor.ts b/packages/client-runtime/src/connection/supervisor.ts index 45ef02292056..9a9af5eba9f1 100644 --- a/packages/client-runtime/src/connection/supervisor.ts +++ b/packages/client-runtime/src/connection/supervisor.ts @@ -25,8 +25,9 @@ import { type SupervisorConnectionState, } from "./model.ts"; import * as RpcSession from "../rpc/session.ts"; -import { safeErrorLogAttributes } from "../errors/safeLog.ts"; import { NETWORK_BLOCKING_HINT } from "../errors/network.ts"; +import { safeErrorLogAttributes } from "../errors/safeLog.ts"; +import * as ConnectionDiagnosticsLog from "./diagnosticsLog.ts"; import * as ConnectionWakeups from "./wakeups.ts"; const RETRY_DELAYS_MS = [3_000, 4_000, 8_000, 16_000] as const; @@ -228,6 +229,28 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( const connectivity = yield* Connectivity.Connectivity; const driver = yield* ConnectionDriver.ConnectionDriver; const wakeups = yield* ConnectionWakeups.ConnectionWakeups; + const diagnosticsLog = yield* Effect.serviceOption( + ConnectionDiagnosticsLog.ConnectionDiagnosticsLog, + ); + + const recordDiagnostic = (input: { + readonly kind: ConnectionDiagnosticsLog.ConnectionDiagnosticKind; + readonly error: ConnectionAttemptError; + readonly attempt: number; + }) => + Option.match(diagnosticsLog, { + onNone: () => Effect.void, + onSome: (log) => + log.record({ + environmentId: target.environmentId, + label: target.label, + kind: input.kind, + reason: input.error.reason, + detail: input.error.detail, + traceId: input.error.traceId, + attempt: input.attempt, + }), + }); const initialIntent: SupervisorIntent = { desired: options?.initiallyDesired ?? false, network: yield* connectivity.status, @@ -432,6 +455,21 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( }), ), }), + // Logged, not swallowed. The fork previously kept the lease on a + // failed probe to stop reconnect churn during server stalls; + // upstream #5561 solves the same problem with a finer model + // (probe-only vs force-reconnect wake kinds, tolerance windows, + // and a ladder skip on the first post-probe attempt), so the + // failure must reach `wakeProbeFailed` below. + Effect.tapCause((cause) => + Effect.logWarning("Foreground connection health check failed.").pipe( + Effect.annotateLogs({ + "environment.id": target.environmentId, + "environment.label": target.label, + ...safeErrorLogAttributes(cause), + }), + ), + ), Effect.forkChild, ); for (;;) { @@ -689,9 +727,21 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( } const attemptSpan: Option.Option = outcome.failure.attemptSpan; - const error: ConnectionAttemptError = outcome.failure.error; + let error: ConnectionAttemptError = outcome.failure.error; + // Attach the environment label to short transport messages from the RPC layer. + if ( + error._tag === "ConnectionTransientError" && + (error.detail === "ping timeout" || error.detail === "ping timeout.") + ) { + error = new ConnectionTransientError({ + reason: error.reason, + detail: `${target.label} ping timeout.`, + ...(error.traceId !== undefined ? { traceId: error.traceId } : {}), + }); + } latestFailure = error; if (error._tag === "ConnectionBlockedError") { + yield* recordDiagnostic({ kind: "blocked", error, attempt }); const blockedIntent = yield* Ref.get(intent); yield* setState({ desired: blockedIntent.desired, @@ -728,6 +778,11 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( delayMs, reason: error.reason, })); + yield* recordDiagnostic({ + kind: outcome.established ? "disconnect" : "connect_failed", + error, + attempt, + }); const failedIntent = yield* Ref.get(intent); yield* setState({ desired: failedIntent.desired, @@ -746,18 +801,23 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( } }); - yield* connectivity.changes.pipe( - Stream.runForEach((network) => - Ref.modify(intent, (current) => - current.network === network ? [false, current] : ([true, { ...current, network }] as const), - ).pipe( - Effect.flatMap((changed) => - changed ? signal({ _tag: "NetworkChanged", network }) : Effect.void, - ), - ), - ), - Effect.forkScoped, - ); + const applyNetworkStatus = Effect.fnUntraced(function* (network: NetworkStatus) { + const changed = yield* Ref.modify(intent, (current) => + current.network === network ? [false, current] : ([true, { ...current, network }] as const), + ); + if (changed) { + yield* signal({ _tag: "NetworkChanged", network }); + } + }); + + // The offline branch of `run` only waits for signals and re-reads the same + // cached network value, so a transition dropped while the app was suspended + // would otherwise strand this supervisor until the app restarted. + yield* Connectivity.followNetworkStatus({ + connectivity, + wakeups, + apply: applyNetworkStatus, + }); yield* wakeups.changes.pipe( Stream.runForEach((reason) => signal({ _tag: "Wakeup", reason })), Effect.forkScoped, diff --git a/packages/client-runtime/src/operations/commands.ts b/packages/client-runtime/src/operations/commands.ts index 78c16a025d35..60dc669a1518 100644 --- a/packages/client-runtime/src/operations/commands.ts +++ b/packages/client-runtime/src/operations/commands.ts @@ -50,6 +50,9 @@ export type SetThreadRuntimeModeInput = CommandInput<"thread.runtime-mode.set">; export type SetThreadInteractionModeInput = CommandInput<"thread.interaction-mode.set">; export type StartThreadTurnInput = CommandInput<"thread.turn.start">; export type InterruptThreadTurnInput = CommandInput<"thread.turn.interrupt">; +export type SteerQueuedMessageInput = CommandInput<"thread.queue.steer">; +export type RemoveQueuedMessageInput = CommandInput<"thread.queue.remove">; +export type UpdateQueuedMessageInput = CommandInput<"thread.queue.update">; export type RespondToThreadApprovalInput = CommandInput<"thread.approval.respond">; export type RespondToThreadUserInputInput = CommandInput<"thread.user-input.respond">; export type DismissThreadUserInputInput = CommandInput<"thread.user-input.dismiss">; @@ -319,6 +322,42 @@ export const interruptThreadTurn: (input: InterruptThreadTurnInput) => CommandEf }); }); +export const steerQueuedMessage: (input: SteerQueuedMessageInput) => CommandEffect = Effect.fn( + "EnvironmentCommands.steerQueuedMessage", +)(function* (input) { + const metadata = yield* timestampedCommandMetadata(input); + return yield* dispatch({ + ...input, + type: "thread.queue.steer", + commandId: metadata.commandId, + createdAt: metadata.createdAt, + }); +}); + +export const removeQueuedMessage: (input: RemoveQueuedMessageInput) => CommandEffect = Effect.fn( + "EnvironmentCommands.removeQueuedMessage", +)(function* (input) { + const metadata = yield* timestampedCommandMetadata(input); + return yield* dispatch({ + ...input, + type: "thread.queue.remove", + commandId: metadata.commandId, + createdAt: metadata.createdAt, + }); +}); + +export const updateQueuedMessage: (input: UpdateQueuedMessageInput) => CommandEffect = Effect.fn( + "EnvironmentCommands.updateQueuedMessage", +)(function* (input) { + const metadata = yield* timestampedCommandMetadata(input); + return yield* dispatch({ + ...input, + type: "thread.queue.update", + commandId: metadata.commandId, + createdAt: metadata.createdAt, + }); +}); + export const respondToThreadApproval: (input: RespondToThreadApprovalInput) => CommandEffect = Effect.fn("EnvironmentCommands.respondToThreadApproval")(function* (input) { const metadata = yield* timestampedCommandMetadata(input); diff --git a/packages/client-runtime/src/relay/discovery.ts b/packages/client-runtime/src/relay/discovery.ts index 8a8eae1d6cd9..987d1427bd74 100644 --- a/packages/client-runtime/src/relay/discovery.ts +++ b/packages/client-runtime/src/relay/discovery.ts @@ -241,7 +241,7 @@ export const make = Effect.fn("RelayEnvironmentDiscovery.make")(function* () { })); return; } - return yield* Effect.fail(failure); + return yield* failure; } const clerkToken = tokenResult.success; if ((yield* Ref.get(accountGeneration)) !== generation) { @@ -310,9 +310,15 @@ export const make = Effect.fn("RelayEnvironmentDiscovery.make")(function* () { ), ); - yield* connectivity.changes.pipe( - Stream.changes, - Stream.runForEach((networkStatus) => + // Follow resumes too: a transition dropped while the app was suspended would + // otherwise leave `offline` set, so the environment list stayed stale until + // another network event or a manual refresh. `followNetworkStatus` only + // reports actual changes, so a resume that reads the current status does not + // trigger a refresh. + yield* Connectivity.followNetworkStatus({ + connectivity, + wakeups, + apply: (networkStatus) => networkStatus === "offline" ? SubscriptionRef.update(state, (current) => ({ ...current, @@ -322,9 +328,7 @@ export const make = Effect.fn("RelayEnvironmentDiscovery.make")(function* () { : Ref.get(hasRefreshed).pipe( Effect.flatMap((shouldRefresh) => (shouldRefresh ? refresh : Effect.void)), ), - ), - Effect.forkScoped, - ); + }); yield* wakeups.changes.pipe( Stream.runForEach((reason) => reason === "credentials-changed" diff --git a/packages/client-runtime/src/relay/errorPresentation.test.ts b/packages/client-runtime/src/relay/errorPresentation.test.ts index a27810c4366e..71a9d2828dad 100644 --- a/packages/client-runtime/src/relay/errorPresentation.test.ts +++ b/packages/client-runtime/src/relay/errorPresentation.test.ts @@ -1,4 +1,7 @@ -import { RelayAuthInvalidError } from "@t3tools/contracts/relay"; +import { + RelayAuthInvalidError, + RelayEnvironmentConnectNotAuthorizedError, +} from "@t3tools/contracts/relay"; import { describe, expect, it } from "@effect/vitest"; import { @@ -54,4 +57,27 @@ describe("relayProtectedErrorMessage", () => { expect(relayProtectedErrorMessage(error)).toBe("Relay rejected the cloud session token."); }); + + it("explains a missing environment link instead of a credential failure", () => { + const error = new RelayEnvironmentConnectNotAuthorizedError({ + code: "environment_connect_not_authorized", + reason: "environment_link_not_found", + traceId: "trace-1", + }); + + expect(relayProtectedErrorMessage(error)).toBe( + "Relay has no active link for this environment. The environment server may not have re-established its link yet.", + ); + }); + + it("still decodes a not-authorized error from a relay that omits the reason", () => { + const error = new RelayEnvironmentConnectNotAuthorizedError({ + code: "environment_connect_not_authorized", + traceId: "trace-1", + }); + + expect(relayProtectedErrorMessage(error)).toBe( + "Relay rejected the environment connection request.", + ); + }); }); diff --git a/packages/client-runtime/src/rpc/client.ts b/packages/client-runtime/src/rpc/client.ts index cfabaa00c0b7..f3f3754c780a 100644 --- a/packages/client-runtime/src/rpc/client.ts +++ b/packages/client-runtime/src/rpc/client.ts @@ -53,6 +53,8 @@ export type EnvironmentSubscriptionRpcTag = | typeof WS_METHODS.subscribeDiscoveredLocalServers | typeof WS_METHODS.subscribeDeviceState | typeof WS_METHODS.subscribeResourceTelemetry + | typeof WS_METHODS.projectsWatchFile + | typeof WS_METHODS.subscribeAiUsage | typeof WS_METHODS.pullRequestsSubscribeRefreshes | typeof WS_METHODS.previewAutomationConnect | typeof WS_METHODS.subscribeVcsStatus @@ -180,6 +182,15 @@ interface SubscriptionOptions { cause: Cause.Cause>, ) => Effect.Effect; readonly retryExpectedFailureAfter?: Duration.Input; + /** + * When this returns true for an expected failure the subscription ends after + * `onExpectedFailure` instead of retrying — for failures the server reports + * as permanent (e.g. subscribing to a deleted thread), where retrying can + * never succeed. + */ + readonly isExpectedFailureTerminal?: ( + cause: Cause.Cause>, + ) => boolean; readonly resubscribe?: Stream.Stream; } @@ -273,7 +284,10 @@ function subscribeDynamicMapped( const handled = Stream.fromEffect(options.onExpectedFailure(cause)).pipe( Stream.drain, ); - if (options.retryExpectedFailureAfter === undefined) { + if ( + options.retryExpectedFailureAfter === undefined || + options.isExpectedFailureTerminal?.(cause) === true + ) { return handled; } return handled.pipe( diff --git a/packages/client-runtime/src/rpc/index.ts b/packages/client-runtime/src/rpc/index.ts index d5b1a6858f41..6894c99a8526 100644 --- a/packages/client-runtime/src/rpc/index.ts +++ b/packages/client-runtime/src/rpc/index.ts @@ -1,4 +1,4 @@ export * from "./client.ts"; export * from "./http.ts"; export * from "./protocol.ts"; -export { type RpcSession } from "./session.ts"; +export { type RpcSession, RpcSessionFactory, layer as rpcSessionFactoryLayer } from "./session.ts"; diff --git a/packages/client-runtime/src/rpc/session.test.ts b/packages/client-runtime/src/rpc/session.test.ts index 8fe76e6181b8..0fbb2c66fbbb 100644 --- a/packages/client-runtime/src/rpc/session.test.ts +++ b/packages/client-runtime/src/rpc/session.test.ts @@ -340,7 +340,7 @@ describe("RpcSessionFactory", () => { expect(error).toBeInstanceOf(ConnectionTransientError); expect(error).toMatchObject({ reason: "transport", - message: "Test environment disconnected.", + message: "Test environment closed (1012 service restart).", }); expect(configStreamError).toMatchObject({ _tag: "RpcClientError" }); yield* Effect.yieldNow; @@ -348,6 +348,57 @@ describe("RpcSessionFactory", () => { }), ); + it.effect("reports ping timeout instead of a bare disconnected message", () => + Effect.scoped( + Effect.gen(function* () { + const { factory, sockets } = yield* makeFactory(); + const session = yield* factory.connect(PREPARED); + const readyFiber = yield* Effect.forkChild(session.ready); + const socket = yield* awaitSocket(sockets); + + socket.open(); + yield* completeInitialConfig(socket); + yield* Fiber.join(readyFiber); + + // Patched Effect RPC pinger: a ping every 5s, closing only once two + // pong windows have been missed (upstream #5561), so the latch opens + // in the fourth window rather than the second. + yield* TestClock.adjust("20 seconds"); + const error = yield* Effect.flip(session.closed); + + expect(error).toBeInstanceOf(ConnectionTransientError); + expect(error).toMatchObject({ + reason: "timeout", + message: "Test environment ping timeout.", + }); + }), + ), + ); + + it.effect("reports abnormal close codes from the socket failure path", () => + Effect.scoped( + Effect.gen(function* () { + const { factory, sockets } = yield* makeFactory(); + const session = yield* factory.connect(PREPARED); + const readyFiber = yield* Effect.forkChild(session.ready); + const socket = yield* awaitSocket(sockets); + + socket.open(); + yield* completeInitialConfig(socket); + yield* Fiber.join(readyFiber); + + socket.close(1006, ""); + const error = yield* Effect.flip(session.closed); + + expect(error).toBeInstanceOf(ConnectionTransientError); + expect(error).toMatchObject({ + reason: "transport", + message: "Test environment closed (1006 abnormal).", + }); + }), + ), + ); + it.effect("closes the websocket when the session scope is released", () => Effect.gen(function* () { const { factory, sockets } = yield* makeFactory(); @@ -1080,7 +1131,9 @@ describe("RpcSessionFactory", () => { yield* TestClock.adjust("5 seconds"); const error = yield* Fiber.join(closedFiber); expect(error).toBeInstanceOf(ConnectionTransientError); - expect(error).toMatchObject({ reason: "transport" }); + // Fork: a missed-pong close is reported as a labelled ping timeout, not + // a bare transport disconnect (see the ping-timeout test above). + expect(error).toMatchObject({ reason: "timeout" }); }).pipe(Effect.scoped, Effect.provide(TestClock.layer())), ); @@ -1185,8 +1238,8 @@ describe("RpcSessionFactory", () => { expect(error).toBeInstanceOf(ConnectionTransientError); expect(error).toMatchObject({ - reason: "transport", - message: `Test environment could not establish a WebSocket connection.${relay ? ` ${NETWORK_BLOCKING_HINT}` : ""}`, + reason: "timeout", + message: `Test environment could not open WebSocket.${relay ? ` ${NETWORK_BLOCKING_HINT}` : ""}`, }); expect(sockets[0]?.readyState).toBe(TestWebSocket.CLOSED); }).pipe(Effect.provide(TestClock.layer())), diff --git a/packages/client-runtime/src/rpc/session.ts b/packages/client-runtime/src/rpc/session.ts index 3e353f6be4df..52dba9ffafde 100644 --- a/packages/client-runtime/src/rpc/session.ts +++ b/packages/client-runtime/src/rpc/session.ts @@ -29,12 +29,15 @@ import { NETWORK_BLOCKING_HINT } from "../errors/network.ts"; import type { ConnectionAttemptError, ConnectionTransientError, + ConnectionTransientReason, PreparedConnection, } from "../connection/model.ts"; import { ConnectionBlockedError, ConnectionTransientError as ConnectionTransientErrorClass, } from "../connection/model.ts"; +import { formatDisconnectDetail, type SocketCloseCapture } from "../connection/disconnectDetail.ts"; +import * as ConnectionDiagnosticsLog from "../connection/diagnosticsLog.ts"; import { applyServerConfigProjection, type ServerConfigProjection, @@ -43,6 +46,117 @@ import { const SOCKET_OPEN_TIMEOUT = "15 seconds"; +/** Mutable sink filled before onDisconnect so we never emit a bare "disconnected." */ +type DisconnectCauseSink = { + causeMessage?: string; + reason?: ConnectionTransientReason; + close?: SocketCloseCapture; +}; + +function socketHostFromUrl(socketUrl: string): string | undefined { + try { + return new URL(socketUrl).host; + } catch { + return undefined; + } +} + +function captureSocketClose( + webSocketConstructor: (url: string, protocols?: string | string[]) => globalThis.WebSocket, + sink: { current: SocketCloseCapture }, +): (url: string, protocols?: string | string[]) => globalThis.WebSocket { + return (url, protocols) => { + const socket = webSocketConstructor(url, protocols); + socket.addEventListener( + "close", + (event) => { + const closeEvent = event as CloseEvent; + sink.current = { + code: typeof closeEvent.code === "number" ? closeEvent.code : undefined, + reason: typeof closeEvent.reason === "string" ? closeEvent.reason : undefined, + }; + }, + { once: true }, + ); + return socket; + }; +} + +function causeTextOf(cause: unknown, fallback: string): string { + if (cause instanceof Error) return cause.message; + if (typeof cause === "string") return cause; + return fallback; +} + +function noteSocketError(sink: DisconnectCauseSink, error: Socket.SocketError): void { + const reason = error.reason; + switch (reason._tag) { + case "SocketCloseError": { + sink.close = { + code: reason.code, + reason: reason.closeReason, + }; + // Prefer close-code formatting over a generic SocketCloseError string. + sink.reason ??= "transport"; + return; + } + case "SocketOpenError": { + const causeText = causeTextOf(reason.cause, reason.kind); + const lower = causeText.toLowerCase(); + if (lower.includes("ping timeout")) { + sink.causeMessage = "ping timeout"; + sink.reason = "timeout"; + return; + } + // WebSocket openTimeout (not keepalive) — leave cause empty so formatters use open wording. + if (reason.kind === "Timeout" && (lower.includes("open") || lower.includes("waiting"))) { + sink.reason ??= "timeout"; + return; + } + sink.causeMessage ??= causeText; + sink.reason ??= lower.includes("timeout") ? "timeout" : "transport"; + return; + } + case "SocketReadError": + case "SocketWriteError": { + sink.causeMessage ??= causeTextOf(reason.cause, reason._tag); + sink.reason ??= "transport"; + return; + } + } +} + +function mergeCloseCapture( + fromEvent: SocketCloseCapture, + fromError: SocketCloseCapture | undefined, +): SocketCloseCapture { + return { + code: fromEvent.code ?? fromError?.code, + reason: fromEvent.reason ?? fromError?.reason, + }; +} + +/** + * Wrap a Socket so transport failures are recorded before ConnectionHooks.onDisconnect. + * onDisconnect alone only sees an empty close capture when the failure is a ping timeout + * (socket still open; browser close event fires later/async). + */ +function captureSocketFailures(socket: Socket.Socket, sink: DisconnectCauseSink): Socket.Socket { + return Socket.make({ + runRaw: (handler, options) => + socket.runRaw(handler, options).pipe( + Effect.tapError((error) => + Effect.sync(() => { + if (Socket.SocketError.is(error)) { + noteSocketError(sink, error); + } + }), + ), + ), + writer: socket.writer, + }); +} + export interface RpcSession { readonly client: WsRpcProtocolClient; readonly initialConfig: Effect.Effect; @@ -139,11 +253,19 @@ function mapSessionRpcError( reason: "remote-unavailable", detail: error.message, }); - case "RpcClientError": + case "RpcClientError": { + const lower = error.message.toLowerCase(); + if (lower.includes("ping timeout")) { + return new ConnectionTransientErrorClass({ + reason: "timeout", + detail: "ping timeout", + }); + } return new ConnectionTransientErrorClass({ reason: "transport", detail: `${error.message}${isSocketErrorReason(error.reason) ? networkHint : ""}`, }); + } } } @@ -152,6 +274,9 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* ( options: RpcSessionOptions = {}, ) { const webSocketConstructor = yield* Socket.WebSocketConstructor; + const diagnosticsLog = yield* Effect.serviceOption( + ConnectionDiagnosticsLog.ConnectionDiagnosticsLog, + ); const serverConfigInput: ServerConfigSubscriptionInput = { ...(options.environmentThemes === true ? { environmentThemes: true } : {}), ...(options.usageLimitSources === true ? { usageLimitSources: true } : {}), @@ -169,42 +294,64 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* ( const connected = yield* Deferred.make(); const disconnected = yield* Deferred.make(); + const closeCapture: { current: SocketCloseCapture } = { current: {} }; + const causeSink: DisconnectCauseSink = {}; + const trackedConstructor = captureSocketClose(webSocketConstructor, closeCapture); const hooks = RpcClient.ConnectionHooks.of({ onConnect: Deferred.succeed(connected, undefined).pipe(Effect.asVoid), + // Fork patch: runs before the protocol fails the socket with SocketOpenError(ping timeout). + onPingTimeout: Effect.sync(() => { + causeSink.causeMessage = "ping timeout"; + causeSink.reason = "timeout"; + }), onDisconnect: Deferred.isDone(connected).pipe( - Effect.flatMap((wasConnected) => - Deferred.fail( - disconnected, - new ConnectionTransientErrorClass({ - reason: "transport", - detail: `${ - wasConnected - ? `${connection.label} disconnected.` - : `${connection.label} could not establish a WebSocket connection.` - }${networkHint}`, - }), - ), - ), - Effect.asVoid, + Effect.flatMap((wasConnected) => { + const close = mergeCloseCapture(closeCapture.current, causeSink.close); + const detail = `${formatDisconnectDetail({ + label: connection.label, + wasConnected, + close, + causeMessage: causeSink.causeMessage, + })}${networkHint}`; + const error = new ConnectionTransientErrorClass({ + reason: causeSink.reason ?? "transport", + detail, + }); + const record = Option.match(diagnosticsLog, { + onNone: () => Effect.void, + onSome: (log) => + log.record({ + environmentId: connection.environmentId, + label: connection.label, + kind: wasConnected ? "disconnect" : "connect_failed", + reason: error.reason, + detail: error.detail, + closeCode: close.code, + closeReason: close.reason, + socketHost: socketHostFromUrl(connection.socketUrl), + }), + }); + return record.pipe(Effect.andThen(Deferred.fail(disconnected, error)), Effect.asVoid); + }), ), }); - const socketLayer = Socket.layerWebSocket(connection.socketUrl, { - openTimeout: SOCKET_OPEN_TIMEOUT, - }).pipe(Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor))); + // Build socket, wrap to capture SocketError (close codes / open errors), then protocol. const protocolLayer = Layer.effect( RpcClient.Protocol, - RpcClient.makeProtocolSocket({ - retryTransientErrors: false, - retryPolicy: Schedule.recurs(0), + Effect.gen(function* () { + const rawSocket = yield* Socket.makeWebSocket(connection.socketUrl, { + openTimeout: SOCKET_OPEN_TIMEOUT, + }).pipe(Effect.provideService(Socket.WebSocketConstructor, trackedConstructor)); + const socket = captureSocketFailures(rawSocket, causeSink); + return yield* RpcClient.makeProtocolSocket({ + retryTransientErrors: false, + retryPolicy: Schedule.recurs(0), + }).pipe( + Effect.provideService(Socket.Socket, socket), + Effect.provide(RpcSerialization.layerJson), + Effect.provideService(RpcClient.ConnectionHooks, hooks), + ); }), - ).pipe( - Layer.provide( - Layer.mergeAll( - socketLayer, - RpcSerialization.layerJson, - Layer.succeed(RpcClient.ConnectionHooks, hooks), - ), - ), ); const protocolContext = yield* Layer.build(protocolLayer).pipe( Effect.withSpan("environment.websocket.connect"), @@ -373,3 +520,5 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* ( export const layerWithOptions = (options: RpcSessionOptions) => Layer.effect(RpcSessionFactory, make(options)); + +export const layer = layerWithOptions({}); diff --git a/packages/client-runtime/src/state/aiUsage.ts b/packages/client-runtime/src/state/aiUsage.ts new file mode 100644 index 000000000000..362d75bcac52 --- /dev/null +++ b/packages/client-runtime/src/state/aiUsage.ts @@ -0,0 +1,21 @@ +import { WS_METHODS } from "@t3tools/contracts"; +import { Atom } from "effect/unstable/reactivity"; + +import type { EnvironmentRegistry } from "../connection/registry.ts"; +import { createEnvironmentRpcSubscriptionAtomFamily } from "./runtime.ts"; + +/** + * Environment atoms for the local `ai-usage` daemon feed. A single streaming + * subscription per environment carries the latest usage snapshot; the server + * only polls the daemon while at least one client is subscribed. + */ +export function createAiUsageEnvironmentAtoms( + runtime: Atom.AtomRuntime, +) { + return { + snapshot: createEnvironmentRpcSubscriptionAtomFamily(runtime, { + label: "environment-data:ai-usage:snapshot", + tag: WS_METHODS.subscribeAiUsage, + }), + }; +} diff --git a/packages/client-runtime/src/state/aiUsagePresentation.ts b/packages/client-runtime/src/state/aiUsagePresentation.ts new file mode 100644 index 000000000000..1233e3f5f87d --- /dev/null +++ b/packages/client-runtime/src/state/aiUsagePresentation.ts @@ -0,0 +1,322 @@ +import type { + AiUsageProviderStatus, + AiUsageSnapshot, + AiUsageWindow, + ProviderDriverKind, +} from "@t3tools/contracts"; + +/** + * Shared, pure logic for surfacing the local `ai-usage` daemon feed on + * provider icons and in the model picker. Time is passed in so everything here + * is unit-testable. + * + * This module is intentionally free of React / atom runtime so it can be used + * from web, mobile, and other clients. + */ + +export type UsageFill = "none" | "warn" | "critical"; + +/** + * A provider marker carries two independent signals: + * - `fill`: how used-up the provider is *right now* — driven by the most + * immediate window (the 5-hour cap) plus a hard "any window at 100%" block. + * This is the dot's colour. + * - `outlookAtRisk`: a softer, longer-horizon concern — a weekly/monthly + * window filling up or the daemon's pace projection saying you'll overshoot + * before it resets. This is a ring around the dot so a slow weekly burn + * never masquerades as "can't use it now". + */ +export interface UsageMarker { + readonly fill: UsageFill; + readonly outlookAtRisk: boolean; +} + +/** The immediate window is "close to running out" at or above this percentage. */ +export const USAGE_WARN_PERCENT = 80; +/** A longer-horizon window counts toward the outlook ring at or above this. */ +export const USAGE_OUTLOOK_PERCENT = 75; + +/** + * Windows ordered shortest-horizon first. The immediate window is the one that + * decides "can I use this right now", so a fresh 5-hour bucket wins over a + * nearly-full weekly one. + */ +const IMMEDIATE_WINDOW_PRIORITY = ["5h", "weekly_opus", "weekly", "monthly"]; + +/** + * Labels for spend buffers that sit *behind* the plan limits — extra usage / + * credit / on-demand pools. They are only drawn from once the plan windows are + * exhausted, so an empty (or switched-off) pool never means "unusable now". + */ +const SPEND_POOL_LABEL = + /extra usage|extra credit|\bcredits?\b|overage|on-?demand|pay[\s-]?as[\s-]?you[\s-]?go/i; +/** A window the provider has switched off, e.g. "Extra usage (off)". */ +const DISABLED_LABEL = /\(off\)/i; + +/** + * True when a window actually gates using the provider right now. Everything + * else — daemon-flagged `informational` pools, extra-usage/credit buffers, and + * windows the account has switched off — is reported as context only and must + * never drive the marker. Without this, a 100%-drained "Extra usage (off)" + * pool would paint Claude red while the 5-hour and weekly windows are wide + * open. + */ +export function isEnforcedUsageWindow(window: AiUsageWindow): boolean { + if (window.informational === true) return false; + return !SPEND_POOL_LABEL.test(window.label) && !DISABLED_LABEL.test(window.label); +} + +function enforcedWindows(item: AiUsageProviderStatus): ReadonlyArray { + return item.windows.filter(isEnforcedUsageWindow); +} + +function immediateUsageWindow(item: AiUsageProviderStatus): AiUsageWindow | undefined { + const windows = enforcedWindows(item); + for (const id of IMMEDIATE_WINDOW_PRIORITY) { + const match = windows.find((window) => window.id === id && typeof window.percent === "number"); + if (match) return match; + } + return windows.find((window) => typeof window.percent === "number"); +} + +/** + * The daemon provider slugs a driver can route to. Most drivers map 1:1, but + * the `opencode` driver hosts multiple coding plans (opencode-go and z.ai), so + * it lists both. Order is "default first" — the head is used when no model slug + * disambiguates. Drivers with no usage feed return `[]`. + */ +const USAGE_PROVIDERS_BY_DRIVER: Record = { + claudeAgent: ["claude"], + codex: ["codex"], + cursor: ["cursor"], + grok: ["grok"], + opencode: ["opencode", "zai"], +}; + +const USAGE_PROVIDER_LABELS: Record = { + claude: "Claude", + codex: "Codex", + cursor: "Cursor", + grok: "Grok", + opencode: "OpenCode", + zai: "z.ai", +}; + +/** Human label for a daemon provider slug. */ +export function usageProviderLabel(provider: string): string { + return USAGE_PROVIDER_LABELS[provider] ?? provider; +} + +/** All daemon provider slugs a driver can route to (default first). */ +export function usageProvidersForDriver( + driverKind: ProviderDriverKind | null | undefined, +): readonly string[] { + return USAGE_PROVIDERS_BY_DRIVER[driverKind as string] ?? []; +} + +/** + * Map an app driver kind + model to the single active daemon provider slug. + * z.ai runs under the `opencode` driver, so a `zai-coding-plan/*` model + * overrides opencode-go. Returns `null` for drivers with no usage feed. + */ +export function mapDriverToUsageProvider( + driverKind: ProviderDriverKind | null | undefined, + modelSlug: string | null | undefined, +): string | null { + const providers = usageProvidersForDriver(driverKind); + if (providers.length === 0) return null; + if ( + (driverKind as string) === "opencode" && + typeof modelSlug === "string" && + modelSlug.startsWith("zai-coding-plan/") + ) { + return "zai"; + } + return providers[0] ?? null; +} + +/** + * The highest percentage across a provider's *enforced* windows, or `null` if + * none. Spend pools are skipped for the same reason they never colour the + * marker: draining them is not being out of plan. + */ +export function worstUsagePercent(item: AiUsageProviderStatus): number | null { + let worst: number | null = null; + for (const window of enforcedWindows(item)) { + if (typeof window.percent === "number" && (worst === null || window.percent > worst)) { + worst = window.percent; + } + } + return worst; +} + +/** True when a window's pace projects running out before it resets. */ +function windowPaceAtRisk(window: AiUsageWindow): boolean { + return window.pace?.lasts_to_reset === false && (window.pace?.delta_percent ?? 0) > 0; +} + +/** + * The two-channel marker for a provider. `fill` reflects current usage on the + * immediate window (red at any hard 100% cap, orange at the warn threshold); + * `outlookAtRisk` reflects a longer-horizon window filling up or a pace + * overshoot, and is surfaced as a ring rather than escalating the fill. + * + * Only enforced windows count — a drained or disabled extra-usage/credit pool + * is not a limit and must not colour the marker. + */ +export function usageMarkerForItem(item: AiUsageProviderStatus): UsageMarker { + if (!item.ok) return { fill: "none", outlookAtRisk: false }; + const windows = enforcedWindows(item); + const anyMaxed = windows.some( + (window) => typeof window.percent === "number" && window.percent >= 100, + ); + const immediate = immediateUsageWindow(item); + const immediatePercent = typeof immediate?.percent === "number" ? immediate.percent : null; + const fill: UsageFill = anyMaxed + ? "critical" + : immediatePercent !== null && immediatePercent >= USAGE_WARN_PERCENT + ? "warn" + : "none"; + const outlookAtRisk = windows.some( + (window) => + windowPaceAtRisk(window) || + (window !== immediate && + typeof window.percent === "number" && + window.percent >= USAGE_OUTLOOK_PERCENT && + window.percent < 100), + ); + return { fill, outlookAtRisk }; +} + +/** Whether a marker has anything worth rendering. */ +export function hasUsageMarker(marker: UsageMarker): boolean { + return marker.fill !== "none" || marker.outlookAtRisk; +} + +/** Find the daemon status for a provider slug in a snapshot. */ +export function findUsageItem( + snapshot: AiUsageSnapshot | null | undefined, + provider: string | null, +): AiUsageProviderStatus | null { + if (snapshot == null || !snapshot.available || provider === null) return null; + return snapshot.items.find((item) => item.provider === provider) ?? null; +} + +export interface DriverUsage { + readonly provider: string; + readonly item: AiUsageProviderStatus; + readonly marker: UsageMarker; +} + +/** Resolve the usage status for a thread/instance's driver + model. */ +export function resolveDriverUsage( + snapshot: AiUsageSnapshot | null | undefined, + driverKind: ProviderDriverKind | null | undefined, + modelSlug: string | null | undefined, +): DriverUsage | null { + const provider = mapDriverToUsageProvider(driverKind, modelSlug); + const item = findUsageItem(snapshot, provider); + if (provider === null || item === null) return null; + return { provider, item, marker: usageMarkerForItem(item) }; +} + +/** + * Resolve usage for *every* daemon provider a driver hosts (e.g. opencode-go + * and z.ai for the `opencode` driver), skipping any absent from the snapshot. + * Used by the model picker to show each sub-provider's stats separately. + */ +export function resolveDriverUsages( + snapshot: AiUsageSnapshot | null | undefined, + driverKind: ProviderDriverKind | null | undefined, +): ReadonlyArray { + const usages: DriverUsage[] = []; + for (const provider of usageProvidersForDriver(driverKind)) { + const item = findUsageItem(snapshot, provider); + if (item !== null) usages.push({ provider, item, marker: usageMarkerForItem(item) }); + } + return usages; +} + +/** + * Rank a driver by the daemon's usability order (items are pre-sorted + * best-to-use-now first). Lower is better; unmapped/unknown providers sort + * last so a stable sort leaves their relative order untouched. + */ +export function usageRank( + snapshot: AiUsageSnapshot | null | undefined, + driverKind: ProviderDriverKind | null | undefined, + modelSlug: string | null | undefined, +): number { + const provider = mapDriverToUsageProvider(driverKind, modelSlug); + if (snapshot == null || !snapshot.available || provider === null) { + return Number.POSITIVE_INFINITY; + } + const index = snapshot.items.findIndex((item) => item.provider === provider); + return index < 0 ? Number.POSITIVE_INFINITY : index; +} + +/** + * Tailwind background class for the dot itself. When only the outlook is at + * risk the dot is a neutral muted colour so the (amber) ring carries the + * signal; otherwise it takes the fill colour. + */ +export function usageDotFillClass(marker: UsageMarker): string | undefined { + if (marker.fill === "critical") return "bg-destructive"; + if (marker.fill === "warn") return "bg-warning"; + if (marker.outlookAtRisk) return "bg-muted-foreground/70"; + return undefined; +} + +/** CSS colour for the outlook ring around the dot, or `undefined`. */ +export function usageDotRingColor(marker: UsageMarker): string | undefined { + return marker.outlookAtRisk ? "var(--warning)" : undefined; +} + +function formatDurationSeconds(seconds: number): string { + let remaining = Math.max(0, Math.round(seconds)); + const days = Math.floor(remaining / 86400); + remaining -= days * 86400; + const hours = Math.floor(remaining / 3600); + remaining -= hours * 3600; + const minutes = Math.floor(remaining / 60); + if (days > 0) return `${days}d ${hours}h`; + if (hours > 0) return `${hours}h ${minutes}m`; + return `${minutes}m`; +} + +/** Human "resets in …" label from an epoch-seconds timestamp. */ +export function formatResetsIn(resetsAt: number | null | undefined, nowMs: number): string | null { + if (typeof resetsAt !== "number") return null; + const seconds = Math.round(resetsAt - nowMs / 1000); + if (seconds <= 0) return "resetting"; + return formatDurationSeconds(seconds); +} + +/** The primary value label for a window (percentage, dollars, or raw usage). */ +export function formatWindowValue(window: AiUsageWindow): string { + if (typeof window.percent === "number") return `${window.percent}%`; + if (typeof window.used === "number") { + return window.unit === "$" + ? `$${window.used.toFixed(2)}` + : `${window.used}${window.unit ? ` ${window.unit}` : ""}`; + } + return "—"; +} + +/** A short pace warning for a window, or `null` when it's on/behind pace. */ +export function formatPaceNote(window: AiUsageWindow): string | null { + const pace = window.pace; + if (pace == null) return null; + const delta = pace.delta_percent; + const deltaLabel = typeof delta === "number" ? `${delta > 0 ? "+" : ""}${delta}% vs pace` : null; + if (pace.lasts_to_reset === false && typeof pace.eta_seconds === "number") { + const eta = formatDurationSeconds(pace.eta_seconds); + return deltaLabel ? `runs out in ${eta} · ${deltaLabel}` : `runs out in ${eta}`; + } + if (typeof delta === "number" && delta >= 10) { + return typeof pace.projected_percent === "number" + ? `${deltaLabel} · projected ${pace.projected_percent}%` + : deltaLabel; + } + return null; +} diff --git a/packages/client-runtime/src/state/assets.test.ts b/packages/client-runtime/src/state/assets.test.ts index bd266f261675..9fb373389732 100644 --- a/packages/client-runtime/src/state/assets.test.ts +++ b/packages/client-runtime/src/state/assets.test.ts @@ -248,7 +248,7 @@ describe("createAssetEnvironmentAtoms", () => { expect( assets.createUrls({ environmentId, - resources: [...resources].toReversed(), + resources: [...resources].reverse(), }), ).not.toBe(assets.createUrls({ environmentId, resources })); }); diff --git a/packages/client-runtime/src/state/entities.test.ts b/packages/client-runtime/src/state/entities.test.ts index 7b33a5e7ebde..e8ac161be990 100644 --- a/packages/client-runtime/src/state/entities.test.ts +++ b/packages/client-runtime/src/state/entities.test.ts @@ -213,6 +213,8 @@ describe("environment entity projections", () => { unsettledAt: "2026-03-09T10:00:00.000Z", deletedAt: null, messages, + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -389,7 +391,7 @@ describe("environment entity projections", () => { harness.registry.set( harness.shellStateAtomForEnvironment(remoteEnvironmentId), - AsyncResult.success(shellState({ ...SNAPSHOT, threads: SNAPSHOT.threads.toReversed() })), + AsyncResult.success(shellState({ ...SNAPSHOT, threads: [...SNAPSHOT.threads].reverse() })), ); expect([ ...harness.registry @@ -441,7 +443,7 @@ describe("environment entity projections", () => { const catalog = harness.registry.get(harness.catalogValueAtom); harness.registry.set(harness.catalogValueAtom, { ...catalog, - entries: new Map([...catalog.entries].toReversed()), + entries: new Map([...catalog.entries].reverse()), }); expect(harness.registry.get(listAtom)).toEqual([remote, original[3], moved, created]); harness.registry.set(harness.catalogValueAtom, { @@ -482,6 +484,8 @@ describe("environment entity projections", () => { ...THREAD_SHELL, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], diff --git a/packages/client-runtime/src/state/environmentHttpAuth.test.ts b/packages/client-runtime/src/state/environmentHttpAuth.test.ts index 2d4152356ad5..024dfa9ce012 100644 --- a/packages/client-runtime/src/state/environmentHttpAuth.test.ts +++ b/packages/client-runtime/src/state/environmentHttpAuth.test.ts @@ -94,6 +94,8 @@ const THREAD = { settledAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], diff --git a/packages/client-runtime/src/state/gitActions.test.ts b/packages/client-runtime/src/state/gitActions.test.ts new file mode 100644 index 000000000000..bcaad3f55caa --- /dev/null +++ b/packages/client-runtime/src/state/gitActions.test.ts @@ -0,0 +1,35 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { buildUnsignedCommitRetryInput } from "./gitActions.ts"; + +describe("buildUnsignedCommitRetryInput", () => { + it("preserves the requested action, custom message, and files while removing featureBranch", () => { + const filePaths = ["src/a.ts", "src/b.ts"]; + + expect( + buildUnsignedCommitRetryInput({ + action: "commit_push_pr", + commitMessage: "feat: preserve this message", + featureBranch: true, + filePaths, + }), + ).toEqual({ + action: "commit_push_pr", + commitMessage: "feat: preserve this message", + filePaths, + disableCommitSigning: true, + }); + }); + + it("leaves generated commit messages absent so they may be regenerated", () => { + expect( + buildUnsignedCommitRetryInput({ + action: "commit", + featureBranch: true, + }), + ).toEqual({ + action: "commit", + disableCommitSigning: true, + }); + }); +}); diff --git a/packages/client-runtime/src/state/gitActions.ts b/packages/client-runtime/src/state/gitActions.ts index d3571e65d2e6..e5989259171c 100644 --- a/packages/client-runtime/src/state/gitActions.ts +++ b/packages/client-runtime/src/state/gitActions.ts @@ -39,9 +39,56 @@ export type DefaultBranchConfirmableAction = export type GitActionRequestInput = Pick< GitRunStackedActionInput, - "action" | "commitMessage" | "featureBranch" | "filePaths" + "action" | "commitMessage" | "featureBranch" | "disableCommitSigning" | "filePaths" >; +export function buildUnsignedCommitRetryInput(input: GitActionRequestInput): GitActionRequestInput { + return { + action: input.action, + ...(input.commitMessage !== undefined ? { commitMessage: input.commitMessage } : {}), + ...(input.filePaths !== undefined ? { filePaths: input.filePaths } : {}), + disableCommitSigning: true, + }; +} + +export function buildGitActionProgressStages(input: { + action: GitStackedAction; + hasCustomCommitMessage: boolean; + hasWorkingTreeChanges: boolean; + pushTarget?: string; + featureBranch?: boolean; + shouldPushBeforePr?: boolean; +}): string[] { + const branchStages = input.featureBranch ? ["Preparing feature branch..."] : []; + const pushStage = input.pushTarget ? `Pushing to ${input.pushTarget}...` : "Pushing..."; + const prStages = [ + "Preparing PR...", + "Generating PR content...", + "Creating GitHub pull request...", + ]; + + if (input.action === "push") { + return [pushStage]; + } + if (input.action === "create_pr") { + return input.shouldPushBeforePr ? [pushStage, ...prStages] : prStages; + } + + const shouldIncludeCommitStages = input.action === "commit" || input.hasWorkingTreeChanges; + const commitStages = !shouldIncludeCommitStages + ? [] + : input.hasCustomCommitMessage + ? ["Committing..."] + : ["Generating commit message...", "Committing..."]; + if (input.action === "commit") { + return [...branchStages, ...commitStages]; + } + if (input.action === "commit_push") { + return [...branchStages, ...commitStages, pushStage]; + } + return [...branchStages, ...commitStages, pushStage, ...prStages]; +} + export function buildMenuItems( gitStatus: VcsStatusResult | null, isBusy: boolean, diff --git a/packages/client-runtime/src/state/hostResourcePresentation.test.ts b/packages/client-runtime/src/state/hostResourcePresentation.test.ts new file mode 100644 index 000000000000..4a58e4995394 --- /dev/null +++ b/packages/client-runtime/src/state/hostResourcePresentation.test.ts @@ -0,0 +1,81 @@ +import { describe, expect, it } from "@effect/vitest"; + +import type { ServerHostResourceSnapshot } from "@t3tools/contracts"; +import { + formatHostResourceBytes, + getHostResourceMetrics, + getHostResourcePressure, + getHostResourceRatioPressure, +} from "./hostResourcePresentation.js"; + +const snapshot = (overrides: Partial) => + ({ + status: "supported", + checkedAt: "2026-07-13T12:00:00.000Z", + source: "os", + hostname: "smart", + platform: "linux", + cpuPercent: 20, + memoryUsedPercent: 30, + memoryUsedBytes: 30, + memoryAvailableBytes: 70, + memoryTotalBytes: 100, + loadAverage: { m1: 1, m5: 1, m15: 1 }, + logicalCores: 8, + message: null, + ...overrides, + }) satisfies ServerHostResourceSnapshot; + +describe("getHostResourcePressure", () => { + it("uses CPU, memory, or normalized load pressure", () => { + expect(getHostResourcePressure(snapshot({}))).toBe("normal"); + expect(getHostResourcePressure(snapshot({ memoryUsedPercent: 75 }))).toBe("warning"); + expect(getHostResourcePressure(snapshot({ cpuPercent: 90 }))).toBe("critical"); + expect( + getHostResourcePressure( + snapshot({ loadAverage: { m1: 7.2, m5: 2, m15: 1 }, logicalCores: 8 }), + ), + ).toBe("critical"); + }); + + it("uses orange at 75% and red at 90%", () => { + expect(getHostResourceRatioPressure(0.74)).toBe("normal"); + expect(getHostResourceRatioPressure(0.75)).toBe("warning"); + expect(getHostResourceRatioPressure(0.9)).toBe("critical"); + }); +}); + +describe("getHostResourceMetrics", () => { + it("normalizes load against logical cores so its meter is comparable to the percentages", () => { + const [cpu, memory, load] = getHostResourceMetrics( + snapshot({ cpuPercent: 42.4, memoryUsedPercent: 30, loadAverage: { m1: 4, m5: 2, m15: 1 } }), + ); + + expect(cpu).toMatchObject({ label: "C", value: "42%", ratio: 0.424 }); + expect(memory).toMatchObject({ label: "M", value: "30%", ratio: 0.3 }); + expect(load).toMatchObject({ label: "L", value: "4.0", ratio: 0.5 }); + }); + + it("reports unmeasured metrics as an em dash with no meter fill", () => { + const [cpu, , load] = getHostResourceMetrics(snapshot({ cpuPercent: null, loadAverage: null })); + + expect(cpu).toMatchObject({ value: "—", ratio: null, description: "CPU —" }); + expect(load).toMatchObject({ value: "—", ratio: null, description: "Load unavailable" }); + }); + + it("leaves load unmeasured when the host reports no core count", () => { + expect(getHostResourceMetrics(snapshot({ logicalCores: null }))[2]).toMatchObject({ + value: "1.0", + ratio: null, + }); + }); +}); + +describe("formatHostResourceBytes", () => { + it("scales to the largest unit that keeps the value above 1", () => { + expect(formatHostResourceBytes(512)).toBe("512 B"); + expect(formatHostResourceBytes(2048)).toBe("2 KiB"); + expect(formatHostResourceBytes(5 * 1024 ** 3)).toBe("5.0 GiB"); + expect(formatHostResourceBytes(null)).toBe("—"); + }); +}); diff --git a/packages/client-runtime/src/state/hostResourcePresentation.ts b/packages/client-runtime/src/state/hostResourcePresentation.ts new file mode 100644 index 000000000000..82340cefadb8 --- /dev/null +++ b/packages/client-runtime/src/state/hostResourcePresentation.ts @@ -0,0 +1,86 @@ +import type { ServerHostResourceSnapshot } from "@t3tools/contracts"; + +export type HostResourcePressure = "normal" | "warning" | "critical"; + +export function getHostResourceRatioPressure(ratio: number): HostResourcePressure { + if (ratio >= 0.9) return "critical"; + if (ratio >= 0.75) return "warning"; + return "normal"; +} + +export function getHostResourceLoadRatio(snapshot: ServerHostResourceSnapshot): number | null { + const loadOne = snapshot.loadAverage?.m1 ?? null; + if (loadOne === null || !snapshot.logicalCores) return null; + return loadOne / snapshot.logicalCores; +} + +export function getHostResourcePressure( + snapshot: ServerHostResourceSnapshot, +): HostResourcePressure { + const cpu = (snapshot.cpuPercent ?? 0) / 100; + const memory = (snapshot.memoryUsedPercent ?? 0) / 100; + const load = getHostResourceLoadRatio(snapshot) ?? 0; + const pressure = Math.max(cpu, memory, load); + return getHostResourceRatioPressure(pressure); +} + +export function formatHostResourcePercent(value: number | null): string { + return value === null ? "—" : `${Math.round(value)}%`; +} + +export function formatHostResourceBytes(value: number | null): string { + if (value === null) return "—"; + const units = ["B", "KiB", "MiB", "GiB", "TiB"] as const; + let scaled = value; + let index = 0; + while (scaled >= 1024 && index < units.length - 1) { + scaled /= 1024; + index += 1; + } + return `${scaled.toFixed(index >= 3 ? 1 : 0)} ${units[index]}`; +} + +export interface HostResourceMetric { + readonly key: "cpu" | "memory" | "load"; + /** Single-character gauge label rendered next to the meter. */ + readonly label: string; + readonly value: string; + /** `0`–`1` fill for the meter, or `null` when the host did not report it. */ + readonly ratio: number | null; + readonly description: string; +} + +/** + * The compact CPU / memory / load gauges shared by every client's host status + * strip. Load is expressed as a ratio of the 1-minute average to logical cores + * so its meter is comparable with the two percentages. + */ +export function getHostResourceMetrics( + snapshot: ServerHostResourceSnapshot, +): ReadonlyArray { + const loadOne = snapshot.loadAverage?.m1 ?? null; + const loadValue = loadOne === null ? "—" : loadOne.toFixed(1); + return [ + { + key: "cpu", + label: "C", + value: formatHostResourcePercent(snapshot.cpuPercent), + ratio: snapshot.cpuPercent === null ? null : snapshot.cpuPercent / 100, + description: `CPU ${formatHostResourcePercent(snapshot.cpuPercent)}`, + }, + { + key: "memory", + label: "M", + value: formatHostResourcePercent(snapshot.memoryUsedPercent), + ratio: snapshot.memoryUsedPercent === null ? null : snapshot.memoryUsedPercent / 100, + description: `Memory ${formatHostResourcePercent(snapshot.memoryUsedPercent)}`, + }, + { + key: "load", + label: "L", + value: loadValue, + ratio: getHostResourceLoadRatio(snapshot), + description: `Load ${loadOne === null ? "unavailable" : loadValue}`, + }, + ]; +} diff --git a/packages/client-runtime/src/state/identity.test.ts b/packages/client-runtime/src/state/identity.test.ts new file mode 100644 index 000000000000..306f81cc0f4b --- /dev/null +++ b/packages/client-runtime/src/state/identity.test.ts @@ -0,0 +1,351 @@ +import { IdentityUsername, PersonId, type ThreadParticipantSummary } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + claimPersonIdForEnvironment, + filterPeopleForTypeahead, + identityClaimRequired, + isClaimedNonStarterParticipant, + threadMatchesMine, +} from "./identity.ts"; + +describe("identityClaimRequired", () => { + it("is false when identity is off", () => { + expect( + identityClaimRequired({ enabled: false, claimRequired: false, people: [] }, { claim: null }), + ).toBe(false); + }); + + it("is true when map enabled and no claim", () => { + expect( + identityClaimRequired( + { + enabled: true, + claimRequired: true, + people: [ + { + personId: "patroza" as never, + username: "patroza" as never, + links: {}, + }, + ], + }, + { claim: null }, + ), + ).toBe(true); + }); +}); + +describe("filterPeopleForTypeahead", () => { + const people = [ + { + personId: "patroza" as never, + username: "patroza" as never, + name: "Patrick Roza", + links: {}, + }, + { + personId: "julius" as never, + username: "julius" as never, + name: "Julius", + links: {}, + }, + ]; + + it("requires min chars", () => { + expect(filterPeopleForTypeahead(people, "pa", 3)).toEqual([]); + }); + + it("matches username and name after min chars", () => { + expect(filterPeopleForTypeahead(people, "pat", 3).map((p) => p.username)).toEqual(["patroza"]); + expect(filterPeopleForTypeahead(people, "roza", 3).map((p) => p.username)).toEqual(["patroza"]); + }); +}); + +describe("threadMatchesMine", () => { + it("filters mine vs theirs when threads are person-attributed", () => { + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "patroza", + mode: "mine", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + mode: "mine", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + mode: "theirs", + }), + ).toBe(true); + }); + + it("treats unattributed threads as mine (legacy / channel-only / identity off)", () => { + // No origin or participants — old threads, { channel: "desktop" } only, etc. + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: [], + mode: "mine", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: [], + mode: "theirs", + }), + ).toBe(false); + // Identity-disabled env: no claim, no person tags → Mine still shows work. + expect( + threadMatchesMine({ + claimPersonId: null, + originPersonId: undefined, + participantPersonIds: undefined, + mode: "mine", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: null, + originPersonId: undefined, + mode: "theirs", + }), + ).toBe(false); + }); + + it("treats attributed threads without a session claim as theirs", () => { + expect( + threadMatchesMine({ + claimPersonId: null, + originPersonId: "julius", + mode: "mine", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: null, + originPersonId: "julius", + mode: "theirs", + }), + ).toBe(true); + }); + + it("includes participant-only matches as mine", () => { + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["patroza"], + mode: "mine", + }), + ).toBe(true); + }); + + it("supports created / participated / both relation sub-filters", () => { + // Mine: created is origin only; participated is join-without-start + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "patroza", + participantPersonIds: ["julius"], + mode: "mine", + relation: "created", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["patroza"], + mode: "mine", + relation: "created", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["patroza"], + mode: "mine", + relation: "participated", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "patroza", + participantPersonIds: [], + mode: "mine", + relation: "participated", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["patroza"], + mode: "mine", + relation: "both", + }), + ).toBe(true); + + // Theirs never includes threads I joined — Created is not wider than Both + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["patroza"], + mode: "theirs", + relation: "created", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["patroza"], + mode: "theirs", + relation: "both", + }), + ).toBe(false); + // Foreign thread: others started → theirs for created and both + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["alice"], + mode: "theirs", + relation: "created", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: "julius", + participantPersonIds: ["alice"], + mode: "theirs", + relation: "both", + }), + ).toBe(true); + // Foreign with participants only (no origin): participated ⊆ both, not created + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: ["julius"], + mode: "theirs", + relation: "created", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: ["julius"], + mode: "theirs", + relation: "participated", + }), + ).toBe(true); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: ["julius"], + mode: "theirs", + relation: "both", + }), + ).toBe(true); + + // Fully unattributed only under mine + both + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: [], + mode: "mine", + relation: "created", + }), + ).toBe(false); + expect( + threadMatchesMine({ + claimPersonId: "patroza", + originPersonId: null, + participantPersonIds: [], + mode: "mine", + relation: "both", + }), + ).toBe(true); + }); +}); + +describe("claimPersonIdForEnvironment", () => { + it("returns the claim for the thread environment only", () => { + const map = new Map([ + ["smart", null], + ["t3vm", "patroza"], + ]); + expect(claimPersonIdForEnvironment(map, "t3vm")).toBe("patroza"); + expect(claimPersonIdForEnvironment(map, "smart")).toBeNull(); + expect(claimPersonIdForEnvironment(map, "missing")).toBeNull(); + }); +}); + +describe("isClaimedNonStarterParticipant", () => { + const participants = [ + { + personId: PersonId.make("joshua"), + username: IdentityUsername.make("joshuadima"), + firstChannel: "discord", + firstParticipatedAt: "2026-07-30T12:00:00.000Z", + }, + { + personId: PersonId.make("patroza"), + username: IdentityUsername.make("patroza"), + firstChannel: "desktop", + firstParticipatedAt: "2026-07-30T12:01:00.000Z", + }, + ] satisfies ReadonlyArray; + + it("marks a claimed person hidden among later participants", () => { + expect( + isClaimedNonStarterParticipant({ + claimPersonId: "PATROZA", + participants, + }), + ).toBe(true); + }); + + it("does not redundantly mark the visible starter", () => { + expect( + isClaimedNonStarterParticipant({ + claimPersonId: "joshua", + participants, + }), + ).toBe(false); + }); + + it("does not mark an unclaimed or absent person", () => { + expect( + isClaimedNonStarterParticipant({ + claimPersonId: null, + participants, + }), + ).toBe(false); + expect( + isClaimedNonStarterParticipant({ + claimPersonId: "someone-else", + participants, + }), + ).toBe(false); + }); +}); diff --git a/packages/client-runtime/src/state/identity.ts b/packages/client-runtime/src/state/identity.ts new file mode 100644 index 000000000000..f5af55bb837c --- /dev/null +++ b/packages/client-runtime/src/state/identity.ts @@ -0,0 +1,196 @@ +/** + * Per-environment session identity (closed-set claim against the server map). + */ +import { + WS_METHODS, + type IdentityClaimInput, + type IdentitySnapshot, + type IdentitySessionClaimResult, + type SessionIdentityClaim, + type ThreadParticipantSummary, +} from "@t3tools/contracts"; +import type { EnvironmentRegistry } from "../connection/registry.ts"; +import { Atom } from "effect/unstable/reactivity"; +import { createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily } from "./runtime.ts"; + +export function createIdentityEnvironmentAtoms( + runtime: Atom.AtomRuntime, +) { + const snapshot = createEnvironmentRpcQueryAtomFamily(runtime, { + label: "identity-snapshot", + tag: WS_METHODS.identityGetSnapshot, + staleTimeMs: 30_000, + idleTtlMs: 60_000, + }); + + const sessionClaim = createEnvironmentRpcQueryAtomFamily(runtime, { + label: "identity-session-claim", + tag: WS_METHODS.identityGetSessionClaim, + staleTimeMs: 5_000, + idleTtlMs: 60_000, + }); + + const claim = createEnvironmentRpcCommand(runtime, { + label: "identity-claim", + tag: WS_METHODS.identityClaim, + }); + + const clearClaim = createEnvironmentRpcCommand(runtime, { + label: "identity-clear-claim", + tag: WS_METHODS.identityClearClaim, + }); + + return { + snapshot, + sessionClaim, + claim, + clearClaim, + }; +} + +export type IdentityEnvironmentAtoms = ReturnType; + +export function identityClaimRequired( + snapshot: IdentitySnapshot | null | undefined, + claimResult: IdentitySessionClaimResult | null | undefined, +): boolean { + if (snapshot === null || snapshot === undefined) return false; + if (!snapshot.enabled || !snapshot.claimRequired) return false; + return claimResult?.claim == null; +} + +export function filterPeopleForTypeahead( + people: IdentitySnapshot["people"], + query: string, + minChars: number, +): IdentitySnapshot["people"] { + const q = query.trim().toLowerCase(); + if (q.length < minChars) return []; + return people.filter((person) => { + if (person.username.includes(q)) return true; + if (person.name?.toLowerCase().includes(q)) return true; + return false; + }); +} + +/** + * Sub-filter for Mine / Theirs. Always a *refinement* of the mode: + * - `both` (default) — created or participated (widest for that mode) + * - `created` — starter/origin role only + * - `participated` — joined without being the starter + * + * For a given mode, `both` is always a superset of `created` and of + * `participated`. Looking only at one field for Theirs used to invert that + * (Created could show more than Created-or-participated). + */ +export type OwnershipRelation = "created" | "participated" | "both"; + +export const DEFAULT_OWNERSHIP_RELATION: OwnershipRelation = "both"; + +export function isOwnershipRelation(value: unknown): value is OwnershipRelation { + return value === "created" || value === "participated" || value === "both"; +} + +/** + * Match a thread for Mine / Theirs ownership filters. + * + * **Mine** (relation `both`, default) includes: + * - threads the claim person started or later joined + * - threads with **no person attribution** (channel-only stamps, identity off, + * legacy) — treated as "ours" so filters stay useful offline of a map + * + * **Mine** + `created` / `participated` narrows to that role only (unattributed + * threads are not included). + * + * **Theirs** is attributed threads the claim person is not on. Relation then + * narrows by how *others* appear: origin set (`created`), non-starter + * participants (`participated`), or either (`both`). + */ +export function threadMatchesMine(input: { + readonly claimPersonId: string | null | undefined; + readonly originPersonId?: string | null | undefined; + readonly participantPersonIds?: ReadonlyArray | null | undefined; + readonly mode: "mine" | "theirs" | "any"; + /** Defaults to `both` (created or participated). */ + readonly relation?: OwnershipRelation; +}): boolean { + if (input.mode === "any") return true; + + const relation = input.relation ?? DEFAULT_OWNERSHIP_RELATION; + const origin = input.originPersonId?.trim().toLowerCase() ?? ""; + const participants = new Set(); + for (const id of input.participantPersonIds ?? []) { + const personId = id?.trim().toLowerCase() ?? ""; + if (personId.length > 0) participants.add(personId); + } + + const fullyUnattributed = origin.length === 0 && participants.size === 0; + // Unattributed stays under Mine only for the default "both" relation. + if (fullyUnattributed) { + return input.mode === "mine" && relation === "both"; + } + + const claimId = input.claimPersonId?.trim().toLowerCase() ?? ""; + const fullPeople = new Set(participants); + if (origin.length > 0) fullPeople.add(origin); + + // No session claim: attributed work is someone else's. + if (claimId.length === 0) { + if (input.mode === "mine") return false; + return matchesTheirsRelation({ relation, origin, participants }); + } + + const createdByMe = origin.length > 0 && origin === claimId; + // Joined without starting. Origin counts as created, not participated. + const participatedByMe = !createdByMe && fullPeople.has(claimId); + const involved = createdByMe || participatedByMe; + + if (input.mode === "mine") { + if (relation === "created") return createdByMe; + if (relation === "participated") return participatedByMe; + return involved; + } + + // Theirs: not on the thread at all, then refine by others' roles. + if (involved) return false; + return matchesTheirsRelation({ relation, origin, participants }); +} + +function matchesTheirsRelation(input: { + readonly relation: OwnershipRelation; + readonly origin: string; + readonly participants: ReadonlySet; +}): boolean { + const othersCreated = input.origin.length > 0; + // Participant list may restate the origin; any non-empty roster is enough + // for "someone participated" when we already know the claim is not on it. + const othersParticipated = input.participants.size > 0; + if (input.relation === "created") return othersCreated; + if (input.relation === "participated") return othersParticipated; + return othersCreated || othersParticipated; +} + +/** Whether the claimed person participated after someone else started the thread. */ +export function isClaimedNonStarterParticipant(input: { + readonly claimPersonId: string | null | undefined; + readonly participants: ReadonlyArray; +}): boolean { + const claimId = input.claimPersonId?.trim().toLowerCase() ?? ""; + if (claimId.length === 0) return false; + return input.participants + .slice(1) + .some((participant) => participant.personId.trim().toLowerCase() === claimId); +} + +/** Look up the claim person for a thread's environment (multi-env clients). */ +export function claimPersonIdForEnvironment( + claimPersonIdByEnvironment: ReadonlyMap, + environmentId: string, +): string | null { + const value = claimPersonIdByEnvironment.get(environmentId); + if (value === undefined || value === null) return null; + const trimmed = value.trim(); + return trimmed.length > 0 ? trimmed : null; +} + +export type { IdentityClaimInput, IdentitySnapshot, SessionIdentityClaim }; diff --git a/packages/client-runtime/src/state/needsAttention.test.ts b/packages/client-runtime/src/state/needsAttention.test.ts new file mode 100644 index 000000000000..90dc4ba0db22 --- /dev/null +++ b/packages/client-runtime/src/state/needsAttention.test.ts @@ -0,0 +1,116 @@ +import type { OrchestrationThreadShell } from "@t3tools/contracts"; +import { EnvironmentId, ProjectId, ProviderInstanceId, ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + buildNeedsAttentionEntries, + classifyNeedsAttention, + type NeedsAttentionThreadInput, +} from "./needsAttention.ts"; + +const environmentId = EnvironmentId.make("environment-1"); +const projectId = ProjectId.make("project-1"); +const NOW = "2026-06-10T12:00:00.000Z"; + +function makeThread( + id: string, + options: { + readonly updatedAt?: string; + readonly hasPendingApprovals?: boolean; + readonly hasPendingUserInput?: boolean; + readonly hasActionableProposedPlan?: boolean; + readonly interactionMode?: "default" | "plan"; + readonly sessionStatus?: OrchestrationThreadShell["session"] extends infer S + ? S extends { status: infer Status } + ? Status + : never + : never; + readonly settledOverride?: "settled" | "active" | null; + readonly settledAt?: string | null; + readonly archivedAt?: string | null; + } = {}, +): NeedsAttentionThreadInput { + const updatedAt = options.updatedAt ?? "2026-06-01T00:00:00.000Z"; + return { + environmentId, + id: ThreadId.make(id), + projectId, + title: `Thread ${id}`, + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, + runtimeMode: "full-access", + interactionMode: options.interactionMode ?? "default", + branch: null, + worktreePath: null, + pullRequests: [], + latestTurn: null, + createdAt: "2026-06-01T00:00:00.000Z", + updatedAt, + archivedAt: options.archivedAt ?? null, + settledOverride: options.settledOverride ?? null, + settledAt: options.settledAt ?? null, + snoozedUntil: null, + snoozedAt: null, + latestUserMessageAt: updatedAt, + hasPendingApprovals: options.hasPendingApprovals ?? false, + hasPendingUserInput: options.hasPendingUserInput ?? false, + hasActionableProposedPlan: options.hasActionableProposedPlan ?? false, + session: + options.sessionStatus === undefined + ? null + : { + threadId: ThreadId.make(id), + status: options.sessionStatus, + providerName: null, + runtimeMode: "full-access", + lastError: null, + updatedAt, + activeTurnId: null, + providerInstanceId: ProviderInstanceId.make("codex"), + }, + }; +} + +describe("classifyNeedsAttention", () => { + it("classifies blocked and working signals", () => { + expect(classifyNeedsAttention(makeThread("a", { hasPendingApprovals: true }))).toEqual({ + kind: "blocked", + statusLabel: "Pending Approval", + }); + expect(classifyNeedsAttention(makeThread("b", { sessionStatus: "running" }))).toEqual({ + kind: "working", + statusLabel: "Working", + }); + expect(classifyNeedsAttention(makeThread("idle"))).toBeNull(); + }); + + it("treats unseen completion as blocked when idle", () => { + expect(classifyNeedsAttention(makeThread("done"), { hasUnseenCompletion: true })).toEqual({ + kind: "blocked", + statusLabel: "Completed", + }); + }); +}); + +describe("buildNeedsAttentionEntries", () => { + it("sorts blocked before working and excludes idle", () => { + const project = { title: "Alpha" }; + const entries = buildNeedsAttentionEntries({ + now: NOW, + threads: [ + makeThread("idle", { updatedAt: "2026-06-05T00:00:00.000Z" }), + makeThread("work", { + sessionStatus: "running", + updatedAt: "2026-06-04T00:00:00.000Z", + }), + makeThread("block", { + hasPendingUserInput: true, + updatedAt: "2026-06-03T00:00:00.000Z", + }), + ], + resolveProject: () => project, + }); + + expect(entries.map((entry) => entry.thread.id)).toEqual(["block", "work"]); + expect(entries[0]?.kind).toBe("blocked"); + }); +}); diff --git a/packages/client-runtime/src/state/needsAttention.ts b/packages/client-runtime/src/state/needsAttention.ts new file mode 100644 index 000000000000..f725f576305e --- /dev/null +++ b/packages/client-runtime/src/state/needsAttention.ts @@ -0,0 +1,217 @@ +import type { + EnvironmentId, + OrchestrationThreadShell, + ProviderInteractionMode, +} from "@t3tools/contracts"; +import { sessionNeedsWakeUp } from "@t3tools/shared/sessionWake"; + +import { effectiveSnoozed } from "./threadSettled.ts"; +import { getThreadSortTimestamp } from "./threadSort.ts"; + +/** Status labels aligned with web `resolveThreadStatusPill` / board derivation. */ +export type NeedsAttentionStatusLabel = + | "Working" + | "Connecting" + | "Completed" + | "Pending Approval" + | "Awaiting Input" + | "Wake Required" + | "Plan Ready" + | "Error"; + +/** Why a thread appears in Needs attention (drives attention-first sort). */ +export type NeedsAttentionKind = "blocked" | "working"; + +/** + * Attention-first priority: blocked-on-you before in-motion work. + * Within a bucket, newest activity first. + */ +const KIND_RANK: Record = { + blocked: 0, + working: 1, +}; + +/** Environment-scoped shell row used by web + mobile attention strips. */ +export type NeedsAttentionThreadInput = OrchestrationThreadShell & { + readonly environmentId: EnvironmentId; +}; + +/** + * Resolves a board/sidebar-compatible status label for attention classification. + * Mirrors web `resolveThreadStatusPill` priority (without last-visited Completed + * when callers do not pass `hasUnseenCompletion`). + */ +export function resolveNeedsAttentionStatusLabel( + thread: Pick< + OrchestrationThreadShell, + | "hasPendingApprovals" + | "hasPendingUserInput" + | "hasActionableProposedPlan" + | "interactionMode" + | "latestTurn" + | "session" + >, +): NeedsAttentionStatusLabel | null { + if (thread.hasPendingApprovals) { + return "Pending Approval"; + } + if (thread.hasPendingUserInput) { + return "Awaiting Input"; + } + if ( + thread.interactionMode === ("plan" satisfies ProviderInteractionMode) && + thread.hasActionableProposedPlan && + !thread.hasPendingUserInput + ) { + return "Plan Ready"; + } + if (thread.session?.status === "running") { + return "Working"; + } + if (thread.session?.status === "starting") { + return "Connecting"; + } + if ( + sessionNeedsWakeUp({ + sessionStatus: thread.session?.status ?? null, + activeTurnId: thread.session?.activeTurnId ?? null, + latestTurnState: thread.latestTurn?.state ?? null, + latestTurnCompletedAt: thread.latestTurn?.completedAt ?? null, + }) + ) { + return "Wake Required"; + } + if (thread.session?.status === "error" || thread.latestTurn?.state === "error") { + return "Error"; + } + return null; +} + +/** + * Classifies a live thread for Needs attention strips (web sidebar + mobile home). + * + * Tighter than the full board **Review** column: idle threads with no status + * are excluded. Working + clear human-attention signals only. + */ +export function classifyNeedsAttention( + thread: Pick< + OrchestrationThreadShell, + | "hasPendingApprovals" + | "hasPendingUserInput" + | "hasActionableProposedPlan" + | "interactionMode" + | "latestTurn" + | "session" + >, + options?: { + /** When true (e.g. web unseen completion), treat as blocked attention. */ + readonly hasUnseenCompletion?: boolean; + }, +): { + readonly kind: NeedsAttentionKind; + readonly statusLabel: NeedsAttentionStatusLabel | null; +} | null { + if (options?.hasUnseenCompletion === true) { + const statusLabel = resolveNeedsAttentionStatusLabel(thread); + // Unseen completion only applies when nothing more urgent is showing. + if (statusLabel === null || statusLabel === "Completed") { + return { kind: "blocked", statusLabel: statusLabel ?? "Completed" }; + } + } + + const statusLabel = resolveNeedsAttentionStatusLabel(thread); + switch (statusLabel) { + case "Pending Approval": + case "Awaiting Input": + case "Plan Ready": + case "Wake Required": + case "Completed": + case "Error": + return { kind: "blocked", statusLabel }; + case "Working": + case "Connecting": + return { kind: "working", statusLabel }; + case null: + return null; + default: { + const exhaustive: never = statusLabel; + return exhaustive; + } + } +} + +export interface NeedsAttentionEntry { + readonly thread: TThread; + readonly project: TProject; + readonly kind: NeedsAttentionKind; + readonly statusLabel: NeedsAttentionStatusLabel | null; +} + +/** + * Builds Needs attention entries: board Working ∪ blocked Review signals, + * attention-first sort. Shared by web classic sidebar and mobile home list. + * + * Callers must pass `now` (ISO) so this stays pure and free of wall-clock + * construction — same contract as server-stamped `settledOverride`. + */ +export function buildNeedsAttentionEntries< + TThread extends NeedsAttentionThreadInput, + TProject, +>(input: { + readonly threads: ReadonlyArray; + readonly resolveProject: (thread: TThread) => TProject | null; + /** + * Optional project membership filter (e.g. environment/project scope). + * Return false to exclude. + */ + readonly includeThread?: (thread: TThread) => boolean; + readonly settlementEnvironmentIds?: ReadonlySet; + readonly snoozeEnvironmentIds?: ReadonlySet; + readonly autoSettleAfterDays?: number | null; + /** Required clock for settle/snooze classification. */ + readonly now: string; + /** Per-thread unseen completion (web last-visited). */ + readonly hasUnseenCompletion?: (thread: TThread) => boolean; +}): ReadonlyArray> { + const now = input.now; + const entries: NeedsAttentionEntry[] = []; + + for (const thread of input.threads) { + if (thread.archivedAt !== null) continue; + if (input.includeThread && !input.includeThread(thread)) continue; + + const supportsSnooze = input.snoozeEnvironmentIds?.has(thread.environmentId) ?? true; + if (supportsSnooze && effectiveSnoozed(thread, { now })) { + continue; + } + + const supportsSettlement = input.settlementEnvironmentIds?.has(thread.environmentId) ?? true; + if (supportsSettlement && thread.settledOverride === "settled") { + continue; + } + + const classification = classifyNeedsAttention(thread, { + hasUnseenCompletion: input.hasUnseenCompletion?.(thread) === true, + }); + if (classification === null) continue; + + const project = input.resolveProject(thread); + if (project === null) continue; + + entries.push({ + thread, + project, + kind: classification.kind, + statusLabel: classification.statusLabel, + }); + } + + return entries.sort((left, right) => { + const kindDelta = KIND_RANK[left.kind] - KIND_RANK[right.kind]; + if (kindDelta !== 0) return kindDelta; + const leftTs = getThreadSortTimestamp(left.thread, "updated_at"); + const rightTs = getThreadSortTimestamp(right.thread, "updated_at"); + if (leftTs !== rightTs) return rightTs > leftTs ? 1 : -1; + return left.thread.id < right.thread.id ? -1 : left.thread.id > right.thread.id ? 1 : 0; + }); +} diff --git a/packages/client-runtime/src/state/orchestration.ts b/packages/client-runtime/src/state/orchestration.ts index ba80275bffb3..7301526de4f9 100644 --- a/packages/client-runtime/src/state/orchestration.ts +++ b/packages/client-runtime/src/state/orchestration.ts @@ -1,7 +1,7 @@ import { ORCHESTRATION_WS_METHODS } from "@t3tools/contracts"; import { Atom } from "effect/unstable/reactivity"; -import { createEnvironmentRpcQueryAtomFamily } from "./runtime.ts"; +import { createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily } from "./runtime.ts"; import type { EnvironmentRegistry } from "../connection/registry.ts"; export function createOrchestrationEnvironmentAtoms( @@ -19,6 +19,11 @@ export function createOrchestrationEnvironmentAtoms( staleTimeMs: 300_000, idleTtlMs: 300_000, }), + // Imperative lazy-load of older thread activities (infinite scroll-up). + loadThreadActivities: createEnvironmentRpcCommand(runtime, { + label: "environment-data:orchestration:thread-activities", + tag: ORCHESTRATION_WS_METHODS.getThreadActivities, + }), fullThreadDiff: createEnvironmentRpcQueryAtomFamily(runtime, { label: "environment-data:orchestration:full-thread-diff", tag: ORCHESTRATION_WS_METHODS.getFullThreadDiff, diff --git a/packages/client-runtime/src/state/preview.ts b/packages/client-runtime/src/state/preview.ts index 86ca157047ba..a53675472077 100644 --- a/packages/client-runtime/src/state/preview.ts +++ b/packages/client-runtime/src/state/preview.ts @@ -83,6 +83,22 @@ export function createPreviewEnvironmentAtoms( scheduler: lifecycleScheduler, concurrency: lifecycleConcurrency, }), + /** + * Asks the environment for a URL this client can actually open for one of + * its local ports. Deduped per port rather than serialized with the tab + * lifecycle: resolving may publish a tailnet route, and two tabs opening + * the same port must not race to publish it twice. + */ + resolvePort: createEnvironmentRpcCommand(runtime, { + label: "environment-data:preview:resolve-port", + tag: WS_METHODS.previewResolvePort, + scheduler: lifecycleScheduler, + concurrency: { + mode: "singleFlight", + key: ({ environmentId, input }: { environmentId: string; input: { port: number } }) => + JSON.stringify([environmentId, input.port]), + }, + }), reportStatus: createEnvironmentRpcCommand(runtime, { label: "environment-data:preview:report-status", tag: WS_METHODS.previewReportStatus, diff --git a/packages/client-runtime/src/state/projectCommands.ts b/packages/client-runtime/src/state/projectCommands.ts index 3defcc321547..75fb65f6d5be 100644 --- a/packages/client-runtime/src/state/projectCommands.ts +++ b/packages/client-runtime/src/state/projectCommands.ts @@ -7,6 +7,8 @@ import { createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, + createEnvironmentRpcSubscriptionAtomFamily, + refreshQueryOnSuccess, } from "./runtime.ts"; import { type CreateProjectInput, @@ -54,6 +56,32 @@ export function createProjectEnvironmentAtoms( key: ({ environmentId, input }: { environmentId: string; input: { projectId: string } }) => JSON.stringify([environmentId, input.projectId]), }; + const readFileQuery = createEnvironmentRpcQueryAtomFamily(runtime, { + label: "environment-data:projects:read-file-query", + tag: WS_METHODS.projectsReadFile, + // Workspace files can change outside T3 Code, so always revalidate cached reads on mount. + staleTimeMs: 0, + idleTtlMs: 0, + }); + const fileChanges = createEnvironmentRpcSubscriptionAtomFamily(runtime, { + label: "environment-data:projects:file-changes", + tag: WS_METHODS.projectsWatchFile, + idleTtlMs: 0, + }); + type ReadFileAtom = ReturnType; + const liveReadFileAtoms = new WeakMap(); + const readFile = (target: Parameters[0]): ReadFileAtom => { + const queryAtom = readFileQuery(target); + const cached = liveReadFileAtoms.get(queryAtom); + if (cached) return cached; + + const changesAtom = fileChanges(target); + const liveAtom = refreshQueryOnSuccess(queryAtom, changesAtom).pipe( + Atom.withLabel(`environment-data:projects:read-file:${target.input.relativePath}`), + ); + liveReadFileAtoms.set(queryAtom, liveAtom); + return liveAtom; + }; return { searchEntries: createEnvironmentRpcQueryAtomFamily(runtime, { label: "environment-data:projects:search-entries", @@ -66,12 +94,7 @@ export function createProjectEnvironmentAtoms( staleTimeMs: 30_000, idleTtlMs: 5 * 60_000, }), - readFile: createEnvironmentRpcQueryAtomFamily(runtime, { - label: "environment-data:projects:read-file", - tag: WS_METHODS.projectsReadFile, - staleTimeMs: 30_000, - idleTtlMs: 5 * 60_000, - }), + readFile, optimisticFile: (target: OptimisticProjectFileTarget) => optimisticFileFamily(optimisticProjectFileKey(target)), create: createEnvironmentCommand(runtime, { diff --git a/packages/client-runtime/src/state/runtime.test.ts b/packages/client-runtime/src/state/runtime.test.ts index d04f313d26e5..dfe09d04d75b 100644 --- a/packages/client-runtime/src/state/runtime.test.ts +++ b/packages/client-runtime/src/state/runtime.test.ts @@ -36,6 +36,7 @@ import { executeAtomQuery, isAtomCommandInterrupted, mapAtomCommandResult, + refreshQueryOnSuccess, runAtomCommand, settleAsyncResult, settlePromise, @@ -172,6 +173,135 @@ describe("settleAsyncResult", () => { }); }); +describe("refreshQueryOnSuccess", () => { + it.effect("refreshes the query for new success signals without replaying a cached signal", () => + Effect.gen(function* () { + let reads = 0; + const query = Atom.make( + Effect.sync(() => { + reads += 1; + return reads; + }), + ); + const signal = Atom.make>( + AsyncResult.initial(false), + ); + const liveQuery = refreshQueryOnSuccess(query, signal); + const registry = AtomRegistry.make(); + const unmount = registry.mount(liveQuery); + + expect( + yield* AtomRegistry.getResult(registry, liveQuery, { + suspendOnWaiting: true, + }), + ).toBe(1); + expect(reads).toBe(1); + + registry.set(signal, AsyncResult.success("changed")); + expect( + yield* AtomRegistry.getResult(registry, liveQuery, { + suspendOnWaiting: true, + }), + ).toBe(2); + + unmount(); + registry.dispose(); + }), + ); + + it.effect("keeps a preloaded zero-TTL query warm through the consumer handoff", () => + Effect.gen(function* () { + let reads = 0; + const query = Atom.make( + Effect.sync(() => { + reads += 1; + return reads; + }), + ).pipe(Atom.setIdleTTL(0)); + const signal = Atom.make>( + AsyncResult.initial(false), + ).pipe(Atom.setIdleTTL(0)); + const liveQuery = refreshQueryOnSuccess(query, signal); + const preloadedQuery = liveQuery.pipe(Atom.setIdleTTL(1_000)); + const registry = AtomRegistry.make(); + + const preload = yield* Effect.promise(() => + executeAtomQuery(registry, preloadedQuery, { + label: "preload", + }), + ); + expect(AsyncResult.isSuccess(preload)).toBe(true); + expect(reads).toBe(1); + + const unmountConsumer = registry.mount(liveQuery); + expect( + yield* AtomRegistry.getResult(registry, liveQuery, { + suspendOnWaiting: true, + }), + ).toBe(1); + expect(reads).toBe(1); + + unmountConsumer(); + registry.dispose(); + }), + ); + + it.effect("revalidates a stale cached query after the live query remounts", () => + Effect.gen(function* () { + let contents = "initial"; + let reads = 0; + const query = Atom.make( + Effect.sync(() => { + reads += 1; + return contents; + }), + ).pipe(Atom.swr({ staleTime: 0, revalidateOnMount: true }), Atom.setIdleTTL(0)); + const signal = Atom.make>( + AsyncResult.initial(false), + ); + const liveQuery = refreshQueryOnSuccess(query, signal); + const scheduledTasks: Array<() => void> = []; + const registry = AtomRegistry.make({ + defaultIdleTTL: 5 * 60_000, + scheduleTask: (task) => { + let active = true; + scheduledTasks.push(() => { + if (active) task(); + }); + return () => { + active = false; + }; + }, + }); + const unmountInitial = registry.mount(liveQuery); + + expect( + yield* AtomRegistry.getResult(registry, liveQuery, { + suspendOnWaiting: true, + }), + ).toBe("initial"); + const readsAfterInitialMount = reads; + + unmountInitial(); + contents = "updated"; + while (scheduledTasks.length > 0) { + scheduledTasks.shift()?.(); + } + + const unmountUpdated = registry.mount(liveQuery); + expect( + yield* AtomRegistry.getResult(registry, liveQuery, { + suspendOnWaiting: true, + }), + ).toBe("updated"); + expect(reads).toBe(readsAfterInitialMount + 1); + + unmountUpdated(); + registry.dispose(); + }), + ); +}); + describe("atom command result helpers", () => { it("maps successful command values", () => { const result = mapAtomCommandResult(AsyncResult.success(2), (value) => value * 3); diff --git a/packages/client-runtime/src/state/runtime.ts b/packages/client-runtime/src/state/runtime.ts index 46cb9fa0f115..43fbe36cec7f 100644 --- a/packages/client-runtime/src/state/runtime.ts +++ b/packages/client-runtime/src/state/runtime.ts @@ -82,6 +82,29 @@ export interface AtomCommandReporter { readonly error: (message: string, cause: Cause.Cause) => void; } +export function refreshQueryOnSuccess( + queryAtom: Atom.Atom>, + signalAtom: Atom.Atom>, +): Atom.Atom> { + return Atom.transform( + queryAtom, + (get) => { + const current = get.once(queryAtom); + get.once(signalAtom); + get.subscribe(queryAtom, (result) => { + get.setSelf(result); + }); + get.subscribe(signalAtom, (result) => { + if (AsyncResult.isSuccess(result)) { + get.refresh(queryAtom); + } + }); + return current; + }, + { initialValueTarget: queryAtom }, + ).pipe(Atom.setIdleTTL(0)); +} + export interface AtomCommand { readonly label: string; readonly run: (registry: AtomRegistry.AtomRegistry, input: W) => Promise>; diff --git a/packages/client-runtime/src/state/server.test.ts b/packages/client-runtime/src/state/server.test.ts index 878f8c902f91..30835376c5fe 100644 --- a/packages/client-runtime/src/state/server.test.ts +++ b/packages/client-runtime/src/state/server.test.ts @@ -36,6 +36,7 @@ import { makeEnvironmentServerConfigState, isLegacyUpdateHandoffLoss, matchesServerUpdateReadyEvent, + projectServerWebVersion, matchesServerUpdateResumeEvent, nudgeReconnectDuringUpdateRestart, resolveServerConfigValue, @@ -717,6 +718,30 @@ describe("server state projection", () => { }), ); + it("tracks the latest web version and ignores non-web lifecycle events", () => { + const [seeded, seededEmit] = projectServerWebVersion(Option.none(), { + type: "webVersionChanged", + payload: { webVersion: "v1" }, + }); + expect(Option.getOrThrow(seeded)).toBe("v1"); + expect(seededEmit).toEqual(["v1"]); + + // A welcome in the same stream must not clear or emit a web version. + const [afterWelcome, welcomeEmit] = projectServerWebVersion(seeded, { + type: "welcome", + payload: {}, + }); + expect(Option.getOrThrow(afterWelcome)).toBe("v1"); + expect(welcomeEmit).toEqual([]); + + const [afterSwap, swapEmit] = projectServerWebVersion(afterWelcome, { + type: "webVersionChanged", + payload: { webVersion: "v2" }, + }); + expect(Option.getOrThrow(afterSwap)).toBe("v2"); + expect(swapEmit).toEqual(["v2"]); + }); + it("prefers an active session config over cache until a live event arrives", () => { const config = (source: string, serverVersion: string) => ({ diff --git a/packages/client-runtime/src/state/server.ts b/packages/client-runtime/src/state/server.ts index 18127076ff19..82782b564984 100644 --- a/packages/client-runtime/src/state/server.ts +++ b/packages/client-runtime/src/state/server.ts @@ -485,7 +485,7 @@ export function applyServerWelcomeEvent( current: EnvironmentServerWelcomeState, session: RpcSession, event: { - readonly type: "welcome" | "ready"; + readonly type: "welcome" | "ready" | "webVersionChanged"; readonly payload: unknown; }, ): EnvironmentServerWelcomeState { @@ -596,6 +596,25 @@ function serverWelcomeStateChanges(environmentId: EnvironmentId) { ); } +/** + * Accumulates the latest served web-bundle version from the lifecycle stream. + * The first value a client observes is the version it is running; a later, + * different value means the server hot-swapped its web assets. + */ +export function projectServerWebVersion( + current: Option.Option, + event: { + readonly type: "welcome" | "ready" | "webVersionChanged"; + readonly payload: unknown; + }, +): readonly [Option.Option, ReadonlyArray] { + if (event.type !== "webVersionChanged") { + return [current, []]; + } + const { webVersion } = event.payload as { readonly webVersion: string }; + return [Option.some(webVersion), [webVersion]]; +} + export function resolveServerConfigValue( projection: ServerConfigProjection | null, initialConfig: ServerConfig | null, @@ -1040,6 +1059,10 @@ export function createServerEnvironmentAtoms( tag: WS_METHODS.serverGetResourceTelemetryHistory, staleTimeMs: 5_000, }), + hostResourceSnapshot: createEnvironmentRpcQueryAtomFamily(runtime, { + label: "environment-data:server:host-resource-snapshot", + tag: WS_METHODS.serverGetHostResourceSnapshot, + }), // A cold transcript scan is measured in seconds, so keep the result around // long enough that switching windows or re-rendering does not rescan. usageSummary: createEnvironmentRpcQueryAtomFamily(runtime, { @@ -1050,6 +1073,12 @@ export function createServerEnvironmentAtoms( }), configProjection, welcome, + webVersion: createEnvironmentRpcSubscriptionAtomFamily(runtime, { + label: "environment-data:server:web-version", + tag: WS_METHODS.subscribeServerLifecycle, + transform: (stream) => + stream.pipe(Stream.mapAccum(Option.none, projectServerWebVersion)), + }), consumeResetCredit: createEnvironmentRpcCommand(runtime, { label: "environment-data:server:consume-reset-credit", tag: WS_METHODS.providerConsumeResetCredit, diff --git a/packages/client-runtime/src/state/shellSnapshotHttp.ts b/packages/client-runtime/src/state/shellSnapshotHttp.ts index aa1ad9081e05..8770ec4ff100 100644 --- a/packages/client-runtime/src/state/shellSnapshotHttp.ts +++ b/packages/client-runtime/src/state/shellSnapshotHttp.ts @@ -11,10 +11,7 @@ import type { PreparedConnection } from "../connection/model.ts"; import { environmentEndpointUrl } from "../environment/endpoint.ts"; import { ManagedRelayDpopSigner } from "../relay/managedRelay.ts"; import { executeAuthenticatedEnvironmentHttpRequest } from "./environmentHttpAuth.ts"; - -// Bounded so a pathologically slow endpoint cannot block the (cheaper) socket -// fallback for long. The cached shell renders while this runs. -const DEFAULT_SHELL_SNAPSHOT_TIMEOUT_MS = 6_000; +import { SNAPSHOT_HTTP_TIMEOUT_MS } from "./snapshotHttpPolicy.ts"; /** * Load the environment shell snapshot (projects + thread shells) over HTTP @@ -34,7 +31,7 @@ export const fetchEnvironmentShellSnapshot = Effect.fn( ...input, method: "GET", url: (httpBaseUrl) => environmentEndpointUrl(httpBaseUrl, "/api/orchestration/shell"), - timeoutMs: input.timeoutMs ?? DEFAULT_SHELL_SNAPSHOT_TIMEOUT_MS, + timeoutMs: input.timeoutMs ?? SNAPSHOT_HTTP_TIMEOUT_MS, request: ({ client, headers }) => client.orchestration.shellSnapshot({ headers }), }); }); diff --git a/packages/client-runtime/src/state/snapshotHttpPolicy.ts b/packages/client-runtime/src/state/snapshotHttpPolicy.ts new file mode 100644 index 000000000000..fe789ef72b2b --- /dev/null +++ b/packages/client-runtime/src/state/snapshotHttpPolicy.ts @@ -0,0 +1,23 @@ +/** + * How long a snapshot may take to load over HTTP before the client gives up and + * lets the WebSocket subscription embed it instead. + * + * The socket fallback is not the cheaper path it reads as. It carries the same + * snapshot over the one connection that also carries the heartbeat and every + * live event, and it cannot be compressed by the transport the way the HTTP + * response is. A link too slow to finish the download in time is exactly the + * link that cannot absorb the same bytes on the socket: the snapshot queues + * ahead of the heartbeat, the connection is declared dead, and the reconnect + * asks for the whole snapshot again — the loop reported in #2761, where a + * heartbeat frame sat behind 72 MB of queued data. + * + * So a slow link needs a longer budget here, not a heavier channel. This is + * sized for that rather than for the multi-KB payload the original bound + * assumed: real threads have been measured at 78 MiB of encoded snapshot + * (#4005) and 254 MB of activity payloads (#4008). + * + * Slowness is the only failure this waits on. A refused connection, a 404, or + * an auth failure still fails fast and falls back immediately, so an endpoint + * that is genuinely unusable is not waited out. + */ +export const SNAPSHOT_HTTP_TIMEOUT_MS = 30_000; diff --git a/packages/client-runtime/src/state/subagentRuntime.test.ts b/packages/client-runtime/src/state/subagentRuntime.test.ts index d366d7f0d4ee..1685e16061b8 100644 --- a/packages/client-runtime/src/state/subagentRuntime.test.ts +++ b/packages/client-runtime/src/state/subagentRuntime.test.ts @@ -868,7 +868,7 @@ describe("task type classification is a denylist", () => { }), activity("task.started", { taskId: "a2", taskType: "some_future_agent_kind", title: "X" }), ]); - expect(agents.map((agent) => agent.id).toSorted()).toEqual(["a1", "a2"]); + expect(agents.map((agent) => agent.id).sort()).toEqual(["a1", "a2"]); }); }); diff --git a/packages/client-runtime/src/state/threadCommands.ts b/packages/client-runtime/src/state/threadCommands.ts index 1f10a0dff7ec..b7196ff0a6f1 100644 --- a/packages/client-runtime/src/state/threadCommands.ts +++ b/packages/client-runtime/src/state/threadCommands.ts @@ -13,6 +13,8 @@ import { type DeleteThreadInput, type InterruptThreadTurnInput, type LinkThreadPullRequestInput, + type RemoveQueuedMessageInput, + type UpdateQueuedMessageInput, type RespondToThreadApprovalInput, type RespondToThreadUserInputInput, type DismissThreadUserInputInput, @@ -25,6 +27,7 @@ import { type SettleThreadInput, type SnoozeThreadInput, type StartThreadTurnInput, + type SteerQueuedMessageInput, type StopThreadSessionInput, type UnarchiveThreadInput, type UnlinkThreadPullRequestInput, @@ -37,6 +40,8 @@ import { deleteThread, interruptThreadTurn, linkThreadPullRequest, + removeQueuedMessage, + updateQueuedMessage, respondToThreadApproval, respondToThreadUserInput, dismissThreadUserInput, @@ -49,6 +54,7 @@ import { settleThread, snoozeThread, startThreadTurn, + steerQueuedMessage, stopThreadSession, unarchiveThread, unlinkThreadPullRequest, @@ -65,6 +71,8 @@ export type { DeleteThreadInput, InterruptThreadTurnInput, LinkThreadPullRequestInput, + RemoveQueuedMessageInput, + UpdateQueuedMessageInput, RespondToThreadApprovalInput, RespondToThreadUserInputInput, DismissThreadUserInputInput, @@ -77,6 +85,7 @@ export type { SettleThreadInput, SnoozeThreadInput, StartThreadTurnInput, + SteerQueuedMessageInput, StopThreadSessionInput, UnarchiveThreadInput, UnlinkThreadPullRequestInput, @@ -90,6 +99,7 @@ export function createThreadEnvironmentAtoms( runtime: Atom.AtomRuntime, ) { const scheduler = createAtomCommandScheduler(); + const urgentScheduler = createAtomCommandScheduler(); const concurrency = { mode: "serial" as const, key: ({ environmentId, input }: { environmentId: string; input: { threadId: string } }) => @@ -207,6 +217,24 @@ export function createThreadEnvironmentAtoms( interruptTurn: createEnvironmentCommand(runtime, { label: "environment-data:commands:thread:interrupt-turn", execute: (input: InterruptThreadTurnInput) => interruptThreadTurn(input), + scheduler: urgentScheduler, + concurrency, + }), + steerQueuedMessage: createEnvironmentCommand(runtime, { + label: "environment-data:commands:thread:steer-queued-message", + execute: (input: SteerQueuedMessageInput) => steerQueuedMessage(input), + scheduler, + concurrency, + }), + removeQueuedMessage: createEnvironmentCommand(runtime, { + label: "environment-data:commands:thread:remove-queued-message", + execute: (input: RemoveQueuedMessageInput) => removeQueuedMessage(input), + scheduler, + concurrency, + }), + updateQueuedMessage: createEnvironmentCommand(runtime, { + label: "environment-data:commands:thread:update-queued-message", + execute: (input: UpdateQueuedMessageInput) => updateQueuedMessage(input), scheduler, concurrency, }), @@ -237,7 +265,7 @@ export function createThreadEnvironmentAtoms( stopSession: createEnvironmentCommand(runtime, { label: "environment-data:commands:thread:stop-session", execute: (input: StopThreadSessionInput) => stopThreadSession(input), - scheduler, + scheduler: urgentScheduler, concurrency, }), uploadFeedback: createEnvironmentRpcCommand(runtime, { diff --git a/packages/client-runtime/src/state/threadRecencyGroups.test.ts b/packages/client-runtime/src/state/threadRecencyGroups.test.ts new file mode 100644 index 000000000000..19a7e9439c60 --- /dev/null +++ b/packages/client-runtime/src/state/threadRecencyGroups.test.ts @@ -0,0 +1,152 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + getThreadRecencyBucketId, + groupSortedThreadsByRecency, + groupThreadsByRecency, + shouldShowRecencySectionHeaders, + startOfLocalDay, + THREAD_RECENCY_BUCKET_LABELS, +} from "./threadRecencyGroups.ts"; + +/** Local calendar fixture; Date APIs are intentional for bucket tests. */ +function localDate( + year: number, + monthIndex: number, + day: number, + hours = 0, + minutes = 0, + seconds = 0, +): Date { + // @effect-diagnostics-next-line globalDate:off + return new Date(year, monthIndex, day, hours, minutes, seconds); +} + +function dateFromMs(ms: number): Date { + // @effect-diagnostics-next-line globalDate:off + return new Date(ms); +} + +describe("getThreadRecencyBucketId", () => { + // Fixed local afternoon so last-hour and earlier-today both fit in the day. + const now = localDate(2026, 2, 15, 14, 30, 0); // 2026-03-15 14:30 local + + it("splits today into last hour vs earlier today", () => { + const startToday = startOfLocalDay(now).getTime(); + const nowMs = now.getTime(); + expect(getThreadRecencyBucketId(nowMs - 5 * 60_000, now)).toBe("last_hour"); + expect(getThreadRecencyBucketId(nowMs - 59 * 60_000, now)).toBe("last_hour"); + expect(getThreadRecencyBucketId(nowMs - 61 * 60_000, now)).toBe("earlier_today"); + expect(getThreadRecencyBucketId(startToday + 60_000, now)).toBe("earlier_today"); + }); + + it("classifies yesterday, previous 7, previous 30, and older", () => { + const startToday = startOfLocalDay(now).getTime(); + expect(getThreadRecencyBucketId(startToday - 60_000, now)).toBe("yesterday"); + expect(getThreadRecencyBucketId(startToday - 3 * 24 * 60 * 60 * 1000, now)).toBe( + "previous_7_days", + ); + expect(getThreadRecencyBucketId(startToday - 14 * 24 * 60 * 60 * 1000, now)).toBe( + "previous_30_days", + ); + expect(getThreadRecencyBucketId(startToday - 45 * 24 * 60 * 60 * 1000, now)).toBe("older"); + }); + + it("treats non-finite timestamps as older", () => { + expect(getThreadRecencyBucketId(Number.NaN, now)).toBe("older"); + }); +}); + +describe("groupThreadsByRecency", () => { + const now = localDate(2026, 2, 15, 14, 30, 0); + const startToday = startOfLocalDay(now).getTime(); + const nowMs = now.getTime(); + + it("returns only non-empty buckets in order with labels", () => { + const threads = [ + { id: "t1", at: nowMs - 10 * 60_000 }, + { id: "t2", at: startToday + 60_000 }, + { id: "t3", at: startToday - 40 * 24 * 60 * 60 * 1000 }, + ]; + const groups = groupThreadsByRecency(threads, (t) => t.at, now); + expect(groups.map((g) => g.id)).toEqual(["last_hour", "earlier_today", "older"]); + expect(groups[0]?.label).toBe(THREAD_RECENCY_BUCKET_LABELS.last_hour); + expect(groups[0]?.threads.map((t) => t.id)).toEqual(["t1"]); + expect(groups[1]?.threads.map((t) => t.id)).toEqual(["t2"]); + expect(groups[2]?.threads.map((t) => t.id)).toEqual(["t3"]); + }); + + it("preserves input order within a bucket", () => { + const threads = [ + { id: "newer", at: nowMs - 1_000 }, + { id: "older-hour", at: nowMs - 10 * 60_000 }, + ]; + const groups = groupThreadsByRecency(threads, (t) => t.at, now); + expect(groups).toHaveLength(1); + expect(groups[0]?.id).toBe("last_hour"); + expect(groups[0]?.threads.map((t) => t.id)).toEqual(["newer", "older-hour"]); + }); + + it("omits empty buckets", () => { + const groups = groupThreadsByRecency( + [{ id: "only", at: nowMs - 2 * 60_000 }], + (t) => t.at, + now, + ); + expect(groups.map((g) => g.id)).toEqual(["last_hour"]); + }); +}); + +describe("shouldShowRecencySectionHeaders", () => { + it("is false for a single non-empty bucket", () => { + expect( + shouldShowRecencySectionHeaders([ + { id: "last_hour", label: "Last Hour", threads: [{ id: "a" }] }, + ]), + ).toBe(false); + }); + + it("is true when two or more buckets have threads", () => { + expect( + shouldShowRecencySectionHeaders([ + { id: "last_hour", label: "Last Hour", threads: [{ id: "a" }] }, + { id: "yesterday", label: "Yesterday", threads: [{ id: "b" }] }, + ]), + ).toBe(true); + }); + + it("is false for an empty groups array", () => { + expect(shouldShowRecencySectionHeaders([])).toBe(false); + }); +}); + +describe("groupSortedThreadsByRecency", () => { + it("groups using activity timestamps from ThreadSortInput", () => { + const now = localDate(2026, 2, 15, 14, 30, 0); + const startToday = startOfLocalDay(now); + const lastHourIso = dateFromMs(now.getTime() - 5 * 60_000).toISOString(); + const olderIso = dateFromMs(startToday.getTime() - 40 * 24 * 60 * 60 * 1000).toISOString(); + + const groups = groupSortedThreadsByRecency( + [ + { + id: "a", + createdAt: lastHourIso, + updatedAt: lastHourIso, + latestUserMessageAt: lastHourIso, + }, + { + id: "b", + createdAt: olderIso, + updatedAt: olderIso, + latestUserMessageAt: olderIso, + }, + ], + now, + ); + + expect(groups.map((g) => g.id)).toEqual(["last_hour", "older"]); + expect(groups[0]?.threads[0]?.id).toBe("a"); + expect(groups[1]?.threads[0]?.id).toBe("b"); + }); +}); diff --git a/packages/client-runtime/src/state/threadRecencyGroups.ts b/packages/client-runtime/src/state/threadRecencyGroups.ts new file mode 100644 index 000000000000..b308ef331891 --- /dev/null +++ b/packages/client-runtime/src/state/threadRecencyGroups.ts @@ -0,0 +1,166 @@ +import { getThreadSortTimestamp, type ThreadSortInput } from "./threadSort.ts"; + +/** + * Calendar / activity buckets for cross-project thread lists grouped by recency. + * "Today" is split so busy days stay scannable (Last hour vs Earlier today). + */ +export type ThreadRecencyBucketId = + | "last_hour" + | "earlier_today" + | "yesterday" + | "previous_7_days" + | "previous_30_days" + | "older"; + +export const THREAD_RECENCY_BUCKET_ORDER = [ + "last_hour", + "earlier_today", + "yesterday", + "previous_7_days", + "previous_30_days", + "older", +] as const satisfies readonly ThreadRecencyBucketId[]; + +export const THREAD_RECENCY_BUCKET_LABELS: Record = { + last_hour: "Last Hour", + earlier_today: "Earlier Today", + yesterday: "Yesterday", + previous_7_days: "Previous 7 Days", + previous_30_days: "Previous 30 Days", + older: "Older", +}; + +const MS_PER_HOUR = 60 * 60 * 1000; +const MS_PER_DAY = 24 * MS_PER_HOUR; + +function makeLocalDate( + year: number, + monthIndex: number, + day: number, + hours = 0, + minutes = 0, + seconds = 0, +): Date { + // @effect-diagnostics-next-line globalDate:off + return new Date(year, monthIndex, day, hours, minutes, seconds); +} + +function makeDateFromEpochMs(ms: number): Date { + // @effect-diagnostics-next-line globalDate:off + return new Date(ms); +} + +function makeNow(): Date { + // @effect-diagnostics-next-line globalDate:off + return new Date(); +} + +export function startOfLocalDay(date: Date): Date { + return makeLocalDate(date.getFullYear(), date.getMonth(), date.getDate()); +} + +/** + * Classify an activity timestamp into a recency bucket using local calendar + * days plus a rolling last-hour window for dense "today" lists. + * `timestampMs` should be a finite epoch millis (activity / updated time). + */ +export function getThreadRecencyBucketId( + timestampMs: number, + now: Date = makeNow(), +): ThreadRecencyBucketId { + if (!Number.isFinite(timestampMs)) { + return "older"; + } + + const nowMs = now.getTime(); + const startToday = startOfLocalDay(now).getTime(); + + if (timestampMs >= startToday) { + if (timestampMs >= nowMs - MS_PER_HOUR) { + return "last_hour"; + } + return "earlier_today"; + } + + const startYesterday = startToday - MS_PER_DAY; + if (timestampMs >= startYesterday) { + return "yesterday"; + } + + const startPrevious7 = startToday - 7 * MS_PER_DAY; + if (timestampMs >= startPrevious7) { + return "previous_7_days"; + } + + const startPrevious30 = startToday - 30 * MS_PER_DAY; + if (timestampMs >= startPrevious30) { + return "previous_30_days"; + } + + return "older"; +} + +export interface ThreadRecencyGroup { + readonly id: ThreadRecencyBucketId; + readonly label: string; + readonly threads: readonly T[]; +} + +/** + * Whether recency section headers should render. Empty buckets are already + * omitted from `groups`; a single remaining bucket is still noise (e.g. every + * thread is "Last Hour"), so callers should render a flat list in that case. + */ +export function shouldShowRecencySectionHeaders( + groups: ReadonlyArray>, +): boolean { + return groups.length > 1; +} + +/** + * Partition already-sorted threads into non-empty recency groups. + * Preserves input order within each bucket (callers should sort first). + * Empty buckets are never returned. + */ +export function groupThreadsByRecency( + threads: readonly T[], + getTimestampMs: (thread: T) => number, + now: Date = makeNow(), +): ReadonlyArray> { + const buckets = new Map(); + for (const id of THREAD_RECENCY_BUCKET_ORDER) { + buckets.set(id, []); + } + + for (const thread of threads) { + const id = getThreadRecencyBucketId(getTimestampMs(thread), now); + buckets.get(id)?.push(thread); + } + + const groups: ThreadRecencyGroup[] = []; + for (const id of THREAD_RECENCY_BUCKET_ORDER) { + const bucketThreads = buckets.get(id) ?? []; + if (bucketThreads.length === 0) continue; + groups.push({ + id, + label: THREAD_RECENCY_BUCKET_LABELS[id], + threads: bucketThreads, + }); + } + return groups; +} + +/** + * Convenience for shells / summaries that share ThreadSortInput timestamps. + * Uses the same activity timestamp as `sortThreads(..., "updated_at")`. + */ +export function groupSortedThreadsByRecency( + threads: readonly T[], + now: Date = makeNow(), +): ReadonlyArray> { + return groupThreadsByRecency( + threads, + (thread) => getThreadSortTimestamp(thread, "updated_at"), + now, + ); +} diff --git a/packages/client-runtime/src/state/threadReducer.test.ts b/packages/client-runtime/src/state/threadReducer.test.ts index 5b70ca9ef0aa..edb8ec311142 100644 --- a/packages/client-runtime/src/state/threadReducer.test.ts +++ b/packages/client-runtime/src/state/threadReducer.test.ts @@ -4,15 +4,33 @@ import { CheckpointRef, CommandId, EventId, + IdentityUsername, MessageId, + PersonId, ProjectId, ProviderInstanceId, ThreadId, TurnId, } from "@t3tools/contracts"; -import type { OrchestrationThread } from "@t3tools/contracts"; +import type { OrchestrationThread, OrchestrationThreadActivity } from "@t3tools/contracts"; -import { applyThreadDetailEvent } from "./threadReducer.ts"; +import { + applyThreadDetailEvent, + liveWindowOldestActivityId, + oldestActivityByChronology, +} from "./threadReducer.ts"; + +const activity = (id: string, createdAt: string, sequence?: number): OrchestrationThreadActivity => + ({ + id, + tone: "tool", + kind: "command", + summary: id, + payload: {}, + turnId: TurnId.make("turn-1"), + createdAt, + ...(sequence !== undefined ? { sequence } : {}), + }) as unknown as OrchestrationThreadActivity; const baseEventFields = { eventId: EventId.make("event-1"), @@ -40,6 +58,8 @@ const baseThread: OrchestrationThread = { pullRequests: [], deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -553,6 +573,41 @@ describe("applyThreadDetailEvent", () => { } }); + it("preserves server-authored source attribution on live messages", () => { + const result = applyThreadDetailEvent(baseThread, { + ...baseEventFields, + sequence: 7, + occurredAt: "2026-04-01T06:01:00.000Z", + aggregateKind: "thread", + aggregateId: ThreadId.make("thread-1"), + type: "thread.message-sent", + payload: { + threadId: ThreadId.make("thread-1"), + messageId: MessageId.make("msg-sourced"), + role: "user", + text: "Sent from desktop", + turnId: null, + streaming: false, + source: { + channel: "desktop", + personId: PersonId.make("patroza"), + username: IdentityUsername.make("patroza"), + }, + createdAt: "2026-04-01T06:01:00.000Z", + updatedAt: "2026-04-01T06:01:00.000Z", + }, + }); + + expect(result.kind).toBe("updated"); + if (result.kind === "updated") { + expect(result.thread.messages[0]?.source).toEqual({ + channel: "desktop", + personId: "patroza", + username: "patroza", + }); + } + }); + it("keeps imported replies turnless when delivered again", () => { const event = { ...baseEventFields, @@ -839,6 +894,79 @@ describe("applyThreadDetailEvent", () => { }); }); + describe("thread.message-queued / thread.queued-message-removed", () => { + const queuedPayload = { + threadId: ThreadId.make("thread-1"), + messageId: MessageId.make("queued-1"), + text: "Queued follow-up", + attachments: [], + queuedAt: "2026-04-01T06:00:00.000Z", + }; + + it("appends a queued message and replaces an existing messageId", () => { + const queued = applyThreadDetailEvent(baseThread, { + ...baseEventFields, + sequence: 6, + occurredAt: "2026-04-01T06:00:00.000Z", + aggregateKind: "thread", + aggregateId: ThreadId.make("thread-1"), + type: "thread.message-queued", + payload: queuedPayload, + }); + + expect(queued.kind).toBe("updated"); + if (queued.kind !== "updated") return; + expect(queued.thread.queuedMessages).toHaveLength(1); + expect(queued.thread.queuedMessages[0]?.text).toBe("Queued follow-up"); + + const replaced = applyThreadDetailEvent(queued.thread, { + ...baseEventFields, + sequence: 7, + occurredAt: "2026-04-01T06:01:00.000Z", + aggregateKind: "thread", + aggregateId: ThreadId.make("thread-1"), + type: "thread.message-queued", + payload: { ...queuedPayload, text: "Edited follow-up" }, + }); + + expect(replaced.kind).toBe("updated"); + if (replaced.kind !== "updated") return; + expect(replaced.thread.queuedMessages).toHaveLength(1); + expect(replaced.thread.queuedMessages[0]?.text).toBe("Edited follow-up"); + }); + + it("removes a queued message and leaves others intact", () => { + const threadWithQueue: OrchestrationThread = { + ...baseThread, + queuedMessages: [ + { ...queuedPayload, messageId: MessageId.make("queued-1") }, + { ...queuedPayload, messageId: MessageId.make("queued-2") }, + ], + }; + + const result = applyThreadDetailEvent(threadWithQueue, { + ...baseEventFields, + sequence: 8, + occurredAt: "2026-04-01T06:02:00.000Z", + aggregateKind: "thread", + aggregateId: ThreadId.make("thread-1"), + type: "thread.queued-message-removed", + payload: { + threadId: ThreadId.make("thread-1"), + messageId: MessageId.make("queued-1"), + reason: "dispatched", + removedAt: "2026-04-01T06:02:00.000Z", + }, + }); + + expect(result.kind).toBe("updated"); + if (result.kind !== "updated") return; + expect(result.thread.queuedMessages.map((entry) => entry.messageId)).toEqual([ + MessageId.make("queued-2"), + ]); + }); + }); + describe("thread.session-set", () => { it("settles a running latestTurn when the session leaves the running status", () => { const threadWithRunningTurn: OrchestrationThread = { @@ -1577,4 +1705,61 @@ describe("applyThreadDetailEvent", () => { expect(result.kind).toBe("unchanged"); }); }); + + describe("liveWindowOldestActivityId", () => { + it("returns null for an empty window", () => { + expect(liveWindowOldestActivityId([])).toBeNull(); + }); + + it("returns the chronologically-oldest id regardless of array position", () => { + // Reducer order places the unsequenced legacy row (oldest) LAST while the + // server snapshot would list it first; the helper picks it either way. + const window = [ + activity("seq-1", "2026-04-01T10:00:01.000Z", 1), + activity("seq-2", "2026-04-01T10:00:02.000Z", 2), + activity("legacy", "2026-04-01T09:00:00.000Z"), + ]; + expect(liveWindowOldestActivityId(window)).toBe("legacy"); + }); + + it("breaks createdAt ties by id", () => { + const window = [ + activity("b", "2026-04-01T10:00:00.000Z", 2), + activity("a", "2026-04-01T10:00:00.000Z", 1), + ]; + expect(liveWindowOldestActivityId(window)).toBe("a"); + }); + + it("is stable when a newer activity is appended (no false reshape)", () => { + const before = [ + activity("legacy", "2026-04-01T09:00:00.000Z"), + activity("seq-1", "2026-04-01T10:00:01.000Z", 1), + ]; + // A live append is the newest activity and is unsequenced in the payload; + // it must not change the detected oldest boundary. + const after = [...before, activity("appended", "2026-04-01T11:00:00.000Z")]; + expect(liveWindowOldestActivityId(after)).toBe(liveWindowOldestActivityId(before)); + expect(liveWindowOldestActivityId(after)).toBe("legacy"); + }); + }); + + describe("oldestActivityByChronology", () => { + it("returns null for an empty set", () => { + expect(oldestActivityByChronology([])).toBeNull(); + }); + + it("returns the unsequenced legacy row so the pagination cursor agrees with the sentinel", () => { + // The reducer placed the legacy (unsequenced, oldest) row at the END; paging + // must cursor from it (createdAt cursor), not from index 0's sequenced row. + const merged = [ + activity("seq-5", "2026-04-01T10:00:05.000Z", 5), + activity("seq-6", "2026-04-01T10:00:06.000Z", 6), + activity("legacy", "2026-04-01T09:00:00.000Z"), + ]; + const oldest = oldestActivityByChronology(merged); + expect(oldest?.id).toBe("legacy"); + expect(oldest?.sequence).toBeUndefined(); // → drives the unsequenced cursor + expect(liveWindowOldestActivityId(merged)).toBe(oldest?.id); // sentinel agrees + }); + }); }); diff --git a/packages/client-runtime/src/state/threadReducer.ts b/packages/client-runtime/src/state/threadReducer.ts index ce9aa94b1f06..4634c6210c98 100644 --- a/packages/client-runtime/src/state/threadReducer.ts +++ b/packages/client-runtime/src/state/threadReducer.ts @@ -20,6 +20,12 @@ import { compareDateTimeStrings } from "@t3tools/shared/dateTime"; export type ThreadDetailReducerResult = | { readonly kind: "updated"; readonly thread: OrchestrationThread } | { readonly kind: "deleted" } + /** + * The cached transcript cannot be reconciled in place (a resync rewound past + * what this client holds). The caller must drop the cached snapshot and reload + * the thread rather than keep rendering stale messages. + */ + | { readonly kind: "reload-required" } | { readonly kind: "unchanged" }; /** Keep only a legacy route supplied by the server; detail events cannot resolve project hosts. */ @@ -89,6 +95,45 @@ function isResolvableContextWindowActivity(activity: OrchestrationThreadActivity return typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0; } +/** + * The oldest activity in a set, by chronology (`createdAt`, then `id`) rather + * than array position. + * + * `activities[0]` is not a stable "oldest": {@link activityOrder} sorts + * unsequenced rows to the end (a missing `sequence` is treated as newest) while + * the server snapshot lists legacy unsequenced rows first, so the first live + * append re-sorts the array and shifts index 0. Both the lazy-load *reshape* + * sentinel ({@link liveWindowOldestActivityId}) and the lazy-load *pagination + * cursor* derive from this so they agree on which row is oldest regardless of + * the reducer's placement of unsequenced rows. Returns `null` when empty. + */ +export function oldestActivityByChronology( + activities: ReadonlyArray, +): OrchestrationThreadActivity | null { + let oldest: OrchestrationThreadActivity | null = null; + for (const activity of activities) { + if ( + oldest === null || + activity.createdAt < oldest.createdAt || + (activity.createdAt === oldest.createdAt && activity.id < oldest.id) + ) { + oldest = activity; + } + } + return oldest; +} + +/** + * The id of {@link oldestActivityByChronology}, used as the lazy-load reshape + * sentinel (a reconnect re-snapshot or checkpoint revert changes it; a plain + * append does not). Returns `null` when empty. + */ +export function liveWindowOldestActivityId( + activities: ReadonlyArray, +): OrchestrationThreadActivity["id"] | null { + return oldestActivityByChronology(activities)?.id ?? null; +} + /** * Apply a single orchestration event to an `OrchestrationThread`, returning * the updated thread, a deletion signal, or an "unchanged" marker when the @@ -136,6 +181,8 @@ export function applyThreadDetailEvent( deletedAt: null, pullRequests: [], messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -344,6 +391,10 @@ export function applyThreadDetailEvent( : {}), runtimeMode: event.payload.runtimeMode, interactionMode: event.payload.interactionMode, + pendingTurnStart: { + messageId: event.payload.messageId, + requestedAt: event.payload.createdAt, + }, updatedAt: event.occurredAt, }, }; @@ -380,6 +431,7 @@ export function applyThreadDetailEvent( ...(event.payload.attachments !== undefined ? { attachments: event.payload.attachments } : {}), + ...(event.payload.source !== undefined ? { source: event.payload.source } : {}), turnId: event.payload.turnId, streaming: event.payload.streaming, createdAt: event.payload.createdAt, @@ -404,6 +456,9 @@ export function applyThreadDetailEvent( ...(message.attachments !== undefined ? { attachments: message.attachments } : {}), + ...(entry.source === undefined && message.source !== undefined + ? { source: message.source } + : {}), }, ) : Arr.append(thread.messages, message); @@ -473,6 +528,46 @@ export function applyThreadDetailEvent( }; } + // ── Queued messages ───────────────────────────────────────────── + case "thread.message-queued": { + const queuedMessage = { + messageId: event.payload.messageId, + text: event.payload.text, + attachments: event.payload.attachments, + ...(event.payload.modelSelection !== undefined + ? { modelSelection: event.payload.modelSelection } + : {}), + ...(event.payload.sourceProposedPlan !== undefined + ? { sourceProposedPlan: event.payload.sourceProposedPlan } + : {}), + ...(event.payload.source !== undefined ? { source: event.payload.source } : {}), + queuedAt: event.payload.queuedAt, + }; + return { + kind: "updated", + thread: { + ...thread, + queuedMessages: [ + ...thread.queuedMessages.filter((entry) => entry.messageId !== queuedMessage.messageId), + queuedMessage, + ], + updatedAt: event.occurredAt, + }, + }; + } + + case "thread.queued-message-removed": + return { + kind: "updated", + thread: { + ...thread, + queuedMessages: thread.queuedMessages.filter( + (entry) => entry.messageId !== event.payload.messageId, + ), + updatedAt: event.occurredAt, + }, + }; + // ── Session ───────────────────────────────────────────────────── case "thread.session-set": { // Leaving the "running" session status is the turn-end signal: settle a @@ -512,12 +607,25 @@ export function applyThreadDetailEvent( : thread.latestTurn, ); + // Mirrors the server projections' pending-turn-start clearing: a + // running session with an active turn adopts it; terminal statuses + // abandon it. + const sessionStatus = event.payload.session.status; + const pendingTurnStart = + (sessionStatus === "running" && event.payload.session.activeTurnId !== null) || + sessionStatus === "error" || + sessionStatus === "stopped" || + sessionStatus === "interrupted" + ? null + : thread.pendingTurnStart; + return { kind: "updated", thread: { ...thread, session: event.payload.session, latestTurn, + pendingTurnStart, updatedAt: event.occurredAt, }, }; @@ -610,6 +718,31 @@ export function applyThreadDetailEvent( } // ── Revert ────────────────────────────────────────────────────── + case "thread.messages-resynced": { + // Rewind to the last known-good message and replace only the tail after + // it. Everything before the anchor is untouched, so a resync costs a + // splice rather than re-downloading the whole thread. + const tail = Arr.fromIterable(event.payload.messages); + if (event.payload.afterMessageId === null) { + return { kind: "updated", thread: { ...thread, messages: tail } }; + } + const anchorIndex = thread.messages.findIndex( + (entry) => entry.id === event.payload.afterMessageId, + ); + if (anchorIndex === -1) { + // The anchor predates what we hold (or we never had it), so we cannot + // splice precisely. Reload rather than render a wrong transcript. + return { kind: "reload-required" }; + } + return { + kind: "updated", + thread: { + ...thread, + messages: [...thread.messages.slice(0, anchorIndex + 1), ...tail], + }, + }; + } + case "thread.reverted": { const checkpoints = pipe( thread.checkpoints, @@ -726,6 +859,7 @@ export function applyThreadDetailEvent( case "thread.approval-response-requested": case "thread.user-input-response-requested": case "thread.checkpoint-revert-requested": + case "thread.context-compact-requested": return { kind: "unchanged" }; } @@ -845,7 +979,7 @@ function retainMessagesAfterRevert( !retainedMessageIds.has(message.id) && (message.turnId === null || retainedTurnIds.has(message.turnId)), ) - .toSorted( + .sort( (left, right) => compareDateTimeStrings(left.createdAt, right.createdAt) || left.id.localeCompare(right.id), diff --git a/packages/client-runtime/src/state/threadSnapshotHttp.test.ts b/packages/client-runtime/src/state/threadSnapshotHttp.test.ts new file mode 100644 index 000000000000..1502fecdd3b7 --- /dev/null +++ b/packages/client-runtime/src/state/threadSnapshotHttp.test.ts @@ -0,0 +1,66 @@ +import { describe, expect, it } from "@effect/vitest"; +import { PrimaryConnectionTarget } from "../connection/model.ts"; +import { EnvironmentId, ThreadId } from "@t3tools/contracts"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Option from "effect/Option"; +import * as TestClock from "effect/testing/TestClock"; + +import type { PreparedConnection } from "../connection/model.ts"; +import { RemoteEnvironmentAuthTimeoutError, remoteHttpClientLayer } from "../rpc/http.ts"; +import { fetchEnvironmentThreadSnapshot } from "./threadSnapshotHttp.ts"; + +const TARGET = new PrimaryConnectionTarget({ + environmentId: EnvironmentId.make("environment-1"), + label: "Test environment", + httpBaseUrl: "https://environment.example.test", + wsBaseUrl: "wss://environment.example.test", +}); +const PREPARED: PreparedConnection = { + environmentId: TARGET.environmentId, + label: TARGET.label, + httpBaseUrl: TARGET.httpBaseUrl, + socketUrl: TARGET.wsBaseUrl, + httpAuthorization: null, + target: TARGET, +}; +const THREAD_ID = ThreadId.make("thread-1"); + +/** A fetch that never settles, standing in for a link too slow to finish. */ +const hangingFetch = () => (() => new Promise(() => undefined)) satisfies typeof fetch; + +const loadSnapshot = () => + fetchEnvironmentThreadSnapshot({ + prepared: PREPARED, + threadId: THREAD_ID, + signer: Option.none(), + }); + +describe("thread snapshot HTTP loads", () => { + it.effect("keeps a slow link on HTTP rather than deferring the snapshot to the socket", () => + Effect.gen(function* () { + const errorFiber = yield* loadSnapshot().pipe( + Effect.provide(remoteHttpClientLayer(hangingFetch())), + Effect.flip, + Effect.forkScoped, + ); + yield* Effect.yieldNow; + + // The previous six-second bound gave up here and let the subscription + // embed the snapshot in the socket instead — the same bytes, queued ahead + // of the heartbeat on the link least able to carry them (#2761). A load + // this slow has to stay on HTTP. + yield* TestClock.adjust(Duration.millis(6_000)); + expect(errorFiber.pollUnsafe()).toBeUndefined(); + + yield* TestClock.adjust(Duration.millis(24_000)); + const error = yield* Fiber.join(errorFiber); + + expect(error).toBeInstanceOf(RemoteEnvironmentAuthTimeoutError); + if (error._tag === "RemoteEnvironmentAuthTimeoutError") { + expect(error.timeoutMs).toBe(30_000); + } + }).pipe(Effect.provide(TestClock.layer())), + ); +}); diff --git a/packages/client-runtime/src/state/threadSnapshotHttp.ts b/packages/client-runtime/src/state/threadSnapshotHttp.ts index a82d4c1555c1..e567a08f6bf0 100644 --- a/packages/client-runtime/src/state/threadSnapshotHttp.ts +++ b/packages/client-runtime/src/state/threadSnapshotHttp.ts @@ -12,17 +12,8 @@ import { environmentEndpointUrl } from "../environment/endpoint.ts"; import { ManagedRelayDpopSigner } from "../relay/managedRelay.ts"; import type { RemoteEnvironmentRequestError } from "../rpc/http.ts"; import { executeAuthenticatedEnvironmentHttpRequest } from "./environmentHttpAuth.ts"; +import { SNAPSHOT_HTTP_TIMEOUT_MS } from "./snapshotHttpPolicy.ts"; -// Bounded so a pathologically slow endpoint cannot block the (cheaper) socket -// fallback for long. The cached thread renders while this runs, so the wait only -// delays the transition to live data on the first open, not the initial paint. -const DEFAULT_THREAD_SNAPSHOT_TIMEOUT_MS = 6_000; - -/** - * Load a thread's detail snapshot over HTTP instead of embedding it in the - * WebSocket subscription's first frame. The response is gzip-compressible by - * the transport and keeps the (potentially multi-KB) snapshot off the socket. - */ /** * Optional turn window for a snapshot fetch. Only send a window to servers * that advertise `threadSnapshotPagination`; older servers reject unknown @@ -33,6 +24,11 @@ export interface ThreadSnapshotWindow { readonly beforeCursor?: string; } +/** + * Load a thread's detail snapshot over HTTP instead of embedding it in the + * WebSocket subscription's first frame. The response is gzip-compressible by + * the transport and keeps the (potentially multi-KB) snapshot off the socket. + */ export const fetchEnvironmentThreadSnapshot = Effect.fn( "clientRuntime.state.fetchEnvironmentThreadSnapshot", )(function* (input: { @@ -48,7 +44,7 @@ export const fetchEnvironmentThreadSnapshot = Effect.fn( method: "GET", url: (httpBaseUrl) => environmentEndpointUrl(httpBaseUrl, `/api/orchestration/threads/${input.threadId}`), - timeoutMs: input.timeoutMs ?? DEFAULT_THREAD_SNAPSHOT_TIMEOUT_MS, + timeoutMs: input.timeoutMs ?? SNAPSHOT_HTTP_TIMEOUT_MS, request: ({ client, headers }) => client.orchestration.threadSnapshot({ params: { threadId: input.threadId }, diff --git a/packages/client-runtime/src/state/threadSort.test.ts b/packages/client-runtime/src/state/threadSort.test.ts index d9a2c124ee7d..19a250adffbb 100644 --- a/packages/client-runtime/src/state/threadSort.test.ts +++ b/packages/client-runtime/src/state/threadSort.test.ts @@ -338,7 +338,10 @@ describe("sortActiveThreadsByOrderKey", () => { createdAt: "2026-03-09T10:00:00.000Z", activeOrderKey: null as string | null, })); - const orderedIds = threads.map((thread) => thread.id).toReversed(); + const orderedIds = threads + .map((thread) => thread.id) + .slice() + .reverse(); const assignments = planPinnedReorder({ orderedIds, movedId: orderedIds[0]!, diff --git a/packages/client-runtime/src/state/threads-atoms.test.ts b/packages/client-runtime/src/state/threads-atoms.test.ts index 59bafcbbd8ce..b2a2dc17f68e 100644 --- a/packages/client-runtime/src/state/threads-atoms.test.ts +++ b/packages/client-runtime/src/state/threads-atoms.test.ts @@ -75,6 +75,8 @@ const THREAD: OrchestrationThread = { settledAt: null, deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], diff --git a/packages/client-runtime/src/state/threads-pagination.test.ts b/packages/client-runtime/src/state/threads-pagination.test.ts index 032f72f805ad..a71ef97f3f4b 100644 --- a/packages/client-runtime/src/state/threads-pagination.test.ts +++ b/packages/client-runtime/src/state/threads-pagination.test.ts @@ -87,6 +87,10 @@ function checkpoint(turnId: string, turnCount: number): OrchestrationThread["che } const BASE_THREAD: OrchestrationThread = { + // Fork-required fields absent from upstream's fixture: the fork added them to + // OrchestrationThread, so upstream's new test cannot construct one without them. + queuedMessages: [], + pendingTurnStart: null, id: THREAD_ID, projectId: ProjectId.make("project-1"), title: "Windowed thread", diff --git a/packages/client-runtime/src/state/threads-sync.test.ts b/packages/client-runtime/src/state/threads-sync.test.ts index ef09c92aa8e9..0fb31053c008 100644 --- a/packages/client-runtime/src/state/threads-sync.test.ts +++ b/packages/client-runtime/src/state/threads-sync.test.ts @@ -2,12 +2,14 @@ import { EnvironmentId, EventId, ORCHESTRATION_WS_METHODS, + OrchestrationGetSnapshotError, ProjectId, ProviderInstanceId, ThreadId, TurnId, type OrchestrationThread, type OrchestrationThreadDetailSnapshot, + type OrchestrationSession, type OrchestrationThreadStreamItem, } from "@t3tools/contracts"; import { describe, expect, it } from "@effect/vitest"; @@ -78,6 +80,8 @@ const BASE_THREAD: OrchestrationThread = { pullRequests: [], deletedAt: null, messages: [], + queuedMessages: [], + pendingTurnStart: null, proposedPlans: [], activities: [], checkpoints: [], @@ -146,6 +150,7 @@ const makeHarness = Effect.fn("TestEnvironmentThreads.makeHarness")(function* (o const inputs = yield* Queue.unbounded(); const observed = yield* Queue.unbounded(); const latest = yield* Ref.make(EMPTY_ENVIRONMENT_THREAD_STATE); + const statePublicationCount = yield* Ref.make(0); const retryCount = yield* Ref.make(0); const subscriptionCount = yield* Ref.make(0); const loaderCalls = yield* Ref.make(0); @@ -244,7 +249,10 @@ const makeHarness = Effect.fn("TestEnvironmentThreads.makeHarness")(function* (o ); yield* SubscriptionRef.changes(threadState).pipe( Stream.runForEach((state) => - Ref.set(latest, state).pipe(Effect.andThen(Queue.offer(observed, state))), + Ref.update(statePublicationCount, (count) => count + 1).pipe( + Effect.andThen(Ref.set(latest, state)), + Effect.andThen(Queue.offer(observed, state)), + ), ), Effect.forkScoped, ); @@ -254,6 +262,7 @@ const makeHarness = Effect.fn("TestEnvironmentThreads.makeHarness")(function* (o inputs, observed, latest, + statePublicationCount, retryCount, subscriptionCount, loaderCalls, @@ -286,6 +295,44 @@ const snapshot = (thread: OrchestrationThread): OrchestrationThreadStreamItem => const synchronized = (): OrchestrationThreadStreamItem => ({ kind: "synchronized" }); +const sessionUpdated = ( + status: OrchestrationSession["status"], + sequence: number, + activeTurnId: TurnId | null, +): OrchestrationThreadStreamItem => ({ + kind: "event", + event: { + eventId: EventId.make(`event-session-${sequence}`), + sequence, + occurredAt: + sequence === CACHED_SNAPSHOT_SEQUENCE + 1 + ? "2026-04-01T08:00:00.000Z" + : "2026-04-01T09:00:00.000Z", + commandId: null, + causationEventId: null, + correlationId: null, + metadata: {}, + aggregateKind: "thread", + aggregateId: THREAD_ID, + type: "thread.session-set", + payload: { + threadId: THREAD_ID, + session: { + threadId: THREAD_ID, + status, + providerName: "codex", + runtimeMode: "full-access", + activeTurnId, + lastError: null, + updatedAt: + sequence === CACHED_SNAPSHOT_SEQUENCE + 1 + ? "2026-04-01T08:00:00.000Z" + : "2026-04-01T09:00:00.000Z", + }, + }, + }, +}); + const titleUpdated = (title: string, sequence = 2): OrchestrationThreadStreamItem => ({ kind: "event", event: { @@ -698,6 +745,26 @@ describe("EnvironmentThreads", () => { }), ); + it.effect("does not reload a missing HTTP snapshot when the socket subscription retries", () => + Effect.gen(function* () { + const harness = yield* makeHarness(); + yield* Queue.offer(harness.inputs, new Error("Thread was not found")); + yield* awaitThreadState(harness.observed, (value) => Option.isSome(value.error)); + + expect(yield* Ref.get(harness.loaderCalls)).toBe(1); + expect(yield* Ref.get(harness.subscriptionCount)).toBe(1); + + yield* TestClock.adjust("250 millis"); + for (let attempt = 0; attempt < 100; attempt += 1) { + if ((yield* Ref.get(harness.subscriptionCount)) >= 2) break; + yield* Effect.yieldNow; + } + + expect(yield* Ref.get(harness.subscriptionCount)).toBe(2); + expect(yield* Ref.get(harness.loaderCalls)).toBe(1); + }), + ); + it.effect("ignores replayed thread events at or below the snapshot sequence", () => Effect.gen(function* () { const harness = yield* makeHarness({ cached: BASE_THREAD }); @@ -843,6 +910,84 @@ describe("EnvironmentThreads", () => { }), ); + it.effect("marks the thread deleted and stops retrying on a permanent deleted failure", () => + Effect.gen(function* () { + const harness = yield* makeHarness({ cached: BASE_THREAD }); + yield* Queue.offer( + harness.inputs, + new OrchestrationGetSnapshotError({ + message: "Thread thread-1 was deleted", + reason: "thread-deleted", + }), + ); + + const state = yield* awaitThreadState( + harness.observed, + (value) => value.status === "deleted", + ); + expect(Option.isNone(state.data)).toBe(true); + expect(yield* Ref.get(harness.removedThreads)).toEqual([THREAD_ID]); + + yield* TestClock.adjust("2 seconds"); + for (let attempt = 0; attempt < 100; attempt += 1) { + yield* Effect.yieldNow; + } + expect(yield* Ref.get(harness.subscriptionCount)).toBe(1); + }), + ); + + it.effect("keeps cached data and stops retrying when the thread is archived", () => + Effect.gen(function* () { + const harness = yield* makeHarness({ cached: BASE_THREAD }); + yield* Queue.offer( + harness.inputs, + new OrchestrationGetSnapshotError({ + message: "Thread thread-1 is archived", + reason: "thread-archived", + }), + ); + + const state = yield* awaitThreadState(harness.observed, (value) => + Option.isSome(value.error), + ); + expect(Option.getOrThrow(state.data)).toEqual(BASE_THREAD); + expect(state.status).toBe("cached"); + expect(Option.getOrThrow(state.error)).toBe("Thread thread-1 is archived"); + expect(yield* Ref.get(harness.removedThreads)).toEqual([]); + + yield* TestClock.adjust("2 seconds"); + for (let attempt = 0; attempt < 100; attempt += 1) { + yield* Effect.yieldNow; + } + expect(yield* Ref.get(harness.subscriptionCount)).toBe(1); + }), + ); + + it.effect("keeps retrying when the thread row is missing but not permanently gone", () => + Effect.gen(function* () { + const harness = yield* makeHarness(); + yield* Queue.offer( + harness.inputs, + new OrchestrationGetSnapshotError({ + message: "Thread thread-1 was not found", + reason: "thread-missing", + }), + ); + + yield* awaitThreadState(harness.observed, (value) => Option.isSome(value.error)); + expect(yield* Ref.get(harness.subscriptionCount)).toBe(1); + + yield* TestClock.adjust("250 millis"); + for (let attempt = 0; attempt < 100; attempt += 1) { + if ((yield* Ref.get(harness.subscriptionCount)) >= 2) { + break; + } + yield* Effect.yieldNow; + } + expect(yield* Ref.get(harness.subscriptionCount)).toBe(2); + }), + ); + it.effect("does not overwrite a live snapshot when the supervisor becomes ready", () => Effect.gen(function* () { const harness = yield* makeHarness({ cached: BASE_THREAD }); diff --git a/packages/client-runtime/src/state/threads.ts b/packages/client-runtime/src/state/threads.ts index 83b85bf02f09..743c4b3f416d 100644 --- a/packages/client-runtime/src/state/threads.ts +++ b/packages/client-runtime/src/state/threads.ts @@ -1,6 +1,7 @@ import { ORCHESTRATION_WS_METHODS, type EnvironmentId as EnvironmentIdType, + type OrchestrationGetSnapshotError, type OrchestrationThread, type OrchestrationThreadDetailPage, type OrchestrationThreadDetailSnapshot, @@ -126,6 +127,33 @@ function formatThreadError(cause: Cause.Cause): string { : "Could not synchronize the thread."; } +/** + * Extract a permanent snapshot-unavailable reason from a subscription failure. + * "thread-missing" is intentionally not returned: the projection row may just + * not be written yet (a freshly created thread), so it stays retriable. + */ +function terminalSnapshotReason( + cause: Cause.Cause, +): "thread-deleted" | "thread-archived" | undefined { + for (const reason of cause.reasons) { + if (reason._tag !== "Fail") { + continue; + } + const error: unknown = reason.error; + if ( + typeof error === "object" && + error !== null && + (error as { readonly _tag?: unknown })._tag === "OrchestrationGetSnapshotError" + ) { + const snapshotReason = (error as OrchestrationGetSnapshotError).reason; + if (snapshotReason === "thread-deleted" || snapshotReason === "thread-archived") { + return snapshotReason; + } + } + } + return undefined; +} + function shouldPersistThread(thread: OrchestrationThread): boolean { const status = thread.session?.status; return status !== "starting" && status !== "running"; @@ -227,6 +255,10 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make }; if (resumeCache?.owner === owner) resumeCache.snapshot = committed; const awaitingCompletion = yield* Ref.make(false); + // One HTTP fallback per state machine: a missing snapshot must not produce a + // fresh 404 on every 250ms socket retry (fork behaviour, covered by + // threads-sync.test.ts). + const httpSnapshotLoadAttempted = yield* Ref.make(false); // Bumped whenever loaded history may have been rewritten out from under an // in-flight older-page fetch (snapshot replacement, revert, deletion). A // page response captured under an older epoch is discarded, not merged. @@ -397,6 +429,9 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make } }); + // A terminal `thread-deleted` subscription failure never reaches the item + // stream, so that path publishes the deleted state itself instead of going + // through applyItem. Callers outside applyItemLocked must hold applyLock. const setDeleted = Effect.fn("EnvironmentThreadState.setDeleted")(function* () { yield* Ref.set(awaitingCompletion, false); yield* Ref.update(historyEpoch, (epoch) => epoch + 1); @@ -736,11 +771,17 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make }), ), ); - const httpSnapshot = yield* snapshotLoader.load( - prepared, - threadId, - supportsPagination ? { turnLimit: INITIAL_THREAD_USER_TURN_LIMIT } : undefined, + const alreadyAttemptedHttpSnapshotLoad = yield* Ref.getAndSet( + httpSnapshotLoadAttempted, + true, ); + const httpSnapshot = alreadyAttemptedHttpSnapshotLoad + ? Option.none() + : yield* snapshotLoader.load( + prepared, + threadId, + supportsPagination ? { turnLimit: INITIAL_THREAD_USER_TURN_LIMIT } : undefined, + ); if (Option.isSome(httpSnapshot)) { yield* applyItem({ kind: "snapshot", snapshot: httpSnapshot.value }); current = yield* SubscriptionRef.get(state); @@ -769,8 +810,18 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make }), { onDefect: () => setStreamError("Could not synchronize the thread."), - onExpectedFailure: (cause) => setStreamError(formatThreadError(cause)), + // A permanently unavailable thread must not keep resubscribing: the + // server can never satisfy it, and the 250ms retry would hammer the + // socket until the state's idle TTL expires. + // setDeleted under applyLock: every other history rewrite (snapshot + // apply, older-page merge, delta-driven deletion) is serialized by it, + // and this path must not race a mergeOlderPage commit. + onExpectedFailure: (cause) => + terminalSnapshotReason(cause) === "thread-deleted" + ? applyLock.withPermits(1)(setDeleted()) + : setStreamError(formatThreadError(cause)), retryExpectedFailureAfter: "250 millis", + isExpectedFailureTerminal: (cause) => terminalSnapshotReason(cause) !== undefined, resubscribe: foregroundResubscriptions, }, ).pipe(Stream.runForEach(applyItem)), diff --git a/packages/client-runtime/src/state/vcs.ts b/packages/client-runtime/src/state/vcs.ts index 6c93e6204dc8..5177f6b21d29 100644 --- a/packages/client-runtime/src/state/vcs.ts +++ b/packages/client-runtime/src/state/vcs.ts @@ -22,7 +22,11 @@ import { safeErrorLogAttributes } from "../errors/safeLog.ts"; import { EnvironmentCacheStore } from "../platform/persistence.ts"; import { request, subscribe, type EnvironmentRpcInput } from "../rpc/client.ts"; import { followStreamInEnvironment } from "./runtime.ts"; -import { vcsCommandConcurrency, vcsCommandScheduler } from "./vcsCommandScheduler.ts"; +import { + vcsCommandConcurrency, + vcsCommandScheduler, + vcsThreadCommandConcurrency, +} from "./vcsCommandScheduler.ts"; import { invalidateCachedVcsRefs, vcsRefsCacheStateAtom, @@ -274,21 +278,41 @@ export function createVcsEnvironmentAtoms( cwd: target.input.cwd, }); + const statusStream = (input: EnvironmentRpcInput) => + subscribe(WS_METHODS.subscribeVcsStatus, input).pipe( + Stream.mapAccum( + () => null as VcsStatusResult | null, + (current, event) => { + const next = applyGitStatusStreamEvent(current, event); + return [next, [next]] as const; + }, + ), + ); + return { listRefs, + /** + * Full VCS status (includes server remote poller). Use for the active thread / + * git chrome only — not for high-cardinality lists. + */ status: createEnvironmentSubscriptionAtomFamily(runtime, { label: "environment-data:vcs:status", idleTtlMs: VCS_STATUS_IDLE_TTL_MS, + subscribe: statusStream, + }), + /** + * List/badge VCS status: shared budgeted remote refresh on the server (keeps PR + * state fresh without per-row pollers). Shorter idle TTL so off-screen rows drop. + * Prefer for sidebar/board/thread rows; use `status` for active git chrome. + */ + listStatus: createEnvironmentSubscriptionAtomFamily(runtime, { + label: "environment-data:vcs:status-list", + idleTtlMs: 60_000, subscribe: (input: EnvironmentRpcInput) => - subscribe(WS_METHODS.subscribeVcsStatus, input).pipe( - Stream.mapAccum( - () => null as VcsStatusResult | null, - (current, event) => { - const next = applyGitStatusStreamEvent(current, event); - return [next, [next]] as const; - }, - ), - ), + statusStream({ + ...input, + mode: "list", + }), }), pull: createEnvironmentRpcCommand(runtime, { label: "environment-data:vcs:pull", @@ -318,6 +342,18 @@ export function createVcsEnvironmentAtoms( concurrency: vcsCommandConcurrency, onSettled: invalidateRefs, }), + previewWorktreeCleanup: createEnvironmentRpcCommand(runtime, { + label: "environment-data:vcs:preview-worktree-cleanup", + tag: WS_METHODS.vcsPreviewWorktreeCleanup, + scheduler: vcsCommandScheduler, + concurrency: vcsThreadCommandConcurrency, + }), + cleanupThreadWorktree: createEnvironmentRpcCommand(runtime, { + label: "environment-data:vcs:cleanup-thread-worktree", + tag: WS_METHODS.vcsCleanupThreadWorktree, + scheduler: vcsCommandScheduler, + concurrency: vcsThreadCommandConcurrency, + }), createRef: createEnvironmentRpcCommand(runtime, { label: "environment-data:vcs:create-ref", tag: WS_METHODS.vcsCreateRef, diff --git a/packages/client-runtime/src/state/vcsAction.test.ts b/packages/client-runtime/src/state/vcsAction.test.ts index 24aa314b1cff..56df233df15c 100644 --- a/packages/client-runtime/src/state/vcsAction.test.ts +++ b/packages/client-runtime/src/state/vcsAction.test.ts @@ -36,6 +36,7 @@ import { createVcsActionTransportId, EMPTY_VCS_ACTION_STATE, getVcsActionTargetKey, + isCommitSigningFailure, normalizeVcsActionProgressEvent, parseVcsActionTargetKey, VcsActionMissingTerminalEventError, @@ -261,6 +262,7 @@ describe("vcsActionState", () => { kind: "action_failed", phase: null, message: "Push failed.", + failureKind: "unknown", }), ); @@ -401,6 +403,7 @@ describe("vcsActionState", () => { kind: "action_failed", phase: "push", message: remoteMessage, + failureKind: "unknown", }, ]), { @@ -420,6 +423,7 @@ describe("vcsActionState", () => { environmentId, cwd, phase: "push", + failureKind: "unknown", remoteMessageLength: remoteMessage.length, }); expect(error).not.toHaveProperty("detail"); @@ -428,6 +432,37 @@ describe("vcsActionState", () => { }), ); + it.effect("prefers a classified terminal failure over a following stream error", () => + Effect.gen(function* () { + const target = { environmentId, cwd }; + const transportActionId = createVcsActionTransportId(target, actionId); + const transportError = new Error("rpc stream closed"); + const stream = Stream.fromIterable([ + { + actionId: transportActionId, + action, + cwd, + kind: "action_failed", + phase: "commit", + message: "Remote diagnostic that must stay sanitized.", + failureKind: "commit_signing_failed", + }, + ]).pipe(Stream.concat(Stream.fail(transportError))); + + const error = yield* consumeVcsActionProgress(stream, { + target, + transportActionId, + actionId, + action, + onProgress: () => Effect.void, + }).pipe(Effect.flip); + + expect(error).toBeInstanceOf(VcsActionRemoteFailureError); + expect(error).toMatchObject({ failureKind: "commit_signing_failed" }); + expect(isCommitSigningFailure(error)).toBe(true); + }), + ); + it.effect("reports a missing terminal event as a protocol failure", () => Effect.gen(function* () { const target = { environmentId, cwd }; @@ -612,6 +647,7 @@ describe("vcsActionState", () => { action, phase: "push", message: "push failed after creating the branch", + failureKind: "unknown", }), ), } as unknown as WsRpcProtocolClient; diff --git a/packages/client-runtime/src/state/vcsAction.ts b/packages/client-runtime/src/state/vcsAction.ts index 02a7b7426af5..46148399fe9f 100644 --- a/packages/client-runtime/src/state/vcsAction.ts +++ b/packages/client-runtime/src/state/vcsAction.ts @@ -2,6 +2,7 @@ import { EnvironmentId, type EnvironmentId as EnvironmentIdType, GitActionProgressPhase, + GitActionFailureKind, type GitActionProgressEvent, type GitRunStackedActionInput, type GitRunStackedActionResult, @@ -76,6 +77,7 @@ export interface RunVcsStackedActionInput { readonly action: GitStackedAction; readonly commitMessage?: string; readonly featureBranch?: boolean; + readonly disableCommitSigning?: boolean; readonly filePaths?: ReadonlyArray; /** The thread the action runs beside; the server links a pull request it creates to it. */ readonly threadId?: ThreadId; @@ -104,6 +106,7 @@ export class VcsActionRemoteFailureError extends Schema.TaggedError({ isRunning: false, operation: null, @@ -268,6 +279,19 @@ export function consumeVcsActionProgress( ): Effect.Effect { return Effect.suspend(() => { let terminalEvent: GitActionProgressEvent | null = null; + const remoteFailure = ( + event: Extract, + ): VcsActionRemoteFailureError => + new VcsActionRemoteFailureError({ + actionId: input.actionId, + transportActionId: input.transportActionId, + action: event.action, + environmentId: input.target.environmentId, + cwd: input.target.cwd, + phase: event.phase, + failureKind: event.failureKind, + remoteMessageLength: event.message.length, + }); return stream.pipe( Stream.runForEach((event) => { const normalized = normalizeVcsActionProgressEvent( @@ -284,22 +308,18 @@ export function consumeVcsActionProgress( } return input.onProgress(normalized); }), + Effect.catch((error) => { + const terminal = terminalEvent; + const failure: E | VcsActionRemoteFailureError = + terminal?.kind === "action_failed" ? remoteFailure(terminal) : error; + return Effect.fail(failure); + }), Effect.flatMap(() => { if (terminalEvent?.kind === "action_finished") { return Effect.succeed(terminalEvent.result); } if (terminalEvent?.kind === "action_failed") { - return Effect.fail( - new VcsActionRemoteFailureError({ - actionId: input.actionId, - transportActionId: input.transportActionId, - action: terminalEvent.action, - environmentId: input.target.environmentId, - cwd: input.target.cwd, - phase: terminalEvent.phase, - remoteMessageLength: terminalEvent.message.length, - }), - ); + return Effect.fail(remoteFailure(terminalEvent)); } return Effect.fail( new VcsActionMissingTerminalEventError({ @@ -465,6 +485,7 @@ export function createVcsActionManager( action: input.action, ...(input.commitMessage ? { commitMessage: input.commitMessage } : {}), ...(input.featureBranch ? { featureBranch: true } : {}), + ...(input.disableCommitSigning ? { disableCommitSigning: true } : {}), ...(input.filePaths?.length ? { filePaths: [...input.filePaths] } : {}), ...(input.threadId !== undefined ? { threadId: input.threadId } : {}), }; diff --git a/packages/client-runtime/src/state/vcsCommandScheduler.ts b/packages/client-runtime/src/state/vcsCommandScheduler.ts index a11b157bb2d8..d7b508709b3a 100644 --- a/packages/client-runtime/src/state/vcsCommandScheduler.ts +++ b/packages/client-runtime/src/state/vcsCommandScheduler.ts @@ -11,3 +11,11 @@ export const vcsCommandConcurrency: AtomCommandConcurrency<{ mode: "serial", key: ({ environmentId, input }) => JSON.stringify([environmentId, input.cwd]), }; + +export const vcsThreadCommandConcurrency: AtomCommandConcurrency<{ + readonly environmentId: EnvironmentId; + readonly input: { readonly threadId: string }; +}> = { + mode: "serial", + key: ({ environmentId, input }) => JSON.stringify([environmentId, input.threadId]), +}; diff --git a/packages/client-runtime/src/state/worktreeCleanup.test.ts b/packages/client-runtime/src/state/worktreeCleanup.test.ts new file mode 100644 index 000000000000..d9a3f29f28e2 --- /dev/null +++ b/packages/client-runtime/src/state/worktreeCleanup.test.ts @@ -0,0 +1,206 @@ +import { describe, expect, it, vi } from "vite-plus/test"; + +import { + formatWorktreePathForDisplay, + runArchiveWithWorktreeCleanup, + type ArchiveWorktreeCleanupCandidate, + type WorktreeCleanupConfirmation, + type WorktreeCleanupOutcome, +} from "./worktreeCleanup.ts"; + +const candidate: ArchiveWorktreeCleanupCandidate = { + worktreePath: "/tmp/worktrees/repo/feature-1", + branch: "feature-1", +}; + +function makeFlow(overrides?: { + readonly previewCandidate?: () => Promise; + readonly removalPolicy?: "confirm" | "remove"; + readonly confirmation?: WorktreeCleanupConfirmation<{ readonly _tag: "Failure" }> | null; + readonly archiveSucceeds?: boolean; + readonly cleanupOutcome?: WorktreeCleanupOutcome; +}) { + const confirmRemoval = + overrides?.confirmation === null + ? null + : vi.fn(async () => overrides?.confirmation ?? { kind: "confirmed" as const }); + const archive = vi.fn(async () => ({ + _tag: overrides?.archiveSucceeds === false ? ("Failure" as const) : ("Success" as const), + })); + const cleanup = vi.fn( + async (): Promise => + overrides?.cleanupOutcome ?? { kind: "done", status: "removed" }, + ); + const onCleanupFailed = vi.fn(); + const onCleanupRetained = vi.fn(); + const run = () => + runArchiveWithWorktreeCleanup({ + previewCandidate: overrides?.previewCandidate ?? (async () => candidate), + removalPolicy: overrides?.removalPolicy ?? "confirm", + confirmRemoval, + archive, + isArchiveSuccess: (result) => result._tag === "Success", + cleanup, + onCleanupFailed, + onCleanupRetained, + }); + return { run, confirmRemoval, archive, cleanup, onCleanupFailed, onCleanupRetained }; +} + +describe("runArchiveWithWorktreeCleanup", () => { + it("prompts with the formatted final path segment when the thread is the final active reference", async () => { + const flow = makeFlow(); + await flow.run(); + expect(flow.confirmRemoval).toHaveBeenCalledExactlyOnceWith({ + candidate, + displayWorktreePath: "feature-1", + }); + }); + + it("does not prompt when the server preview reports a shared active worktree", async () => { + const flow = makeFlow({ previewCandidate: async () => null }); + await flow.run(); + expect(flow.confirmRemoval).not.toHaveBeenCalled(); + expect(flow.archive).toHaveBeenCalledTimes(1); + expect(flow.cleanup).not.toHaveBeenCalled(); + }); + + it("does not prompt or clean up when no confirmation surface exists", async () => { + const flow = makeFlow({ confirmation: null }); + await flow.run(); + expect(flow.archive).toHaveBeenCalledTimes(1); + expect(flow.cleanup).not.toHaveBeenCalled(); + }); + + it("removes the final active worktree without prompting when confirmation is disabled", async () => { + const flow = makeFlow({ removalPolicy: "remove", confirmation: null }); + const outcome = await flow.run(); + expect(outcome).toEqual({ kind: "archived", result: { _tag: "Success" } }); + expect(flow.archive).toHaveBeenCalledTimes(1); + expect(flow.cleanup).toHaveBeenCalledTimes(1); + expect(flow.archive.mock.invocationCallOrder[0]).toBeLessThan( + flow.cleanup.mock.invocationCallOrder[0] ?? 0, + ); + }); + + it("archives without cleanup when the user declines", async () => { + const flow = makeFlow({ confirmation: { kind: "declined" } }); + const outcome = await flow.run(); + expect(outcome).toEqual({ kind: "archived", result: { _tag: "Success" } }); + expect(flow.archive).toHaveBeenCalledTimes(1); + expect(flow.cleanup).not.toHaveBeenCalled(); + }); + + it("archives and requests conditional cleanup when the user confirms", async () => { + const flow = makeFlow({ confirmation: { kind: "confirmed" } }); + const outcome = await flow.run(); + expect(outcome).toEqual({ kind: "archived", result: { _tag: "Success" } }); + expect(flow.cleanup).toHaveBeenCalledTimes(1); + expect(flow.onCleanupFailed).not.toHaveBeenCalled(); + expect(flow.onCleanupRetained).not.toHaveBeenCalled(); + // Cleanup runs only after the archive. + expect(flow.archive.mock.invocationCallOrder[0]).toBeLessThan( + flow.cleanup.mock.invocationCallOrder[0] ?? 0, + ); + }); + + it("skips cleanup when the archive itself failed", async () => { + const flow = makeFlow({ archiveSucceeds: false }); + const outcome = await flow.run(); + expect(outcome).toEqual({ kind: "archived", result: { _tag: "Failure" } }); + expect(flow.cleanup).not.toHaveBeenCalled(); + }); + + it("reports a cleanup failure as cleanup-only without failing the archive", async () => { + const flow = makeFlow({ + cleanupOutcome: { kind: "failed", message: "git worktree remove failed" }, + }); + const outcome = await flow.run(); + expect(outcome).toEqual({ kind: "archived", result: { _tag: "Success" } }); + expect(flow.onCleanupFailed).toHaveBeenCalledExactlyOnceWith( + "feature-1", + "git worktree remove failed", + ); + }); + + it("reports a retained worktree when another thread became active after the preview", async () => { + const flow = makeFlow({ cleanupOutcome: { kind: "done", status: "retained-active" } }); + await flow.run(); + expect(flow.onCleanupRetained).toHaveBeenCalledExactlyOnceWith("feature-1"); + expect(flow.onCleanupFailed).not.toHaveBeenCalled(); + }); + + it("stays silent when the worktree was already missing", async () => { + const flow = makeFlow({ cleanupOutcome: { kind: "done", status: "already-missing" } }); + await flow.run(); + expect(flow.onCleanupFailed).not.toHaveBeenCalled(); + expect(flow.onCleanupRetained).not.toHaveBeenCalled(); + }); + + it("aborts without archiving when the confirmation surface fails", async () => { + const flow = makeFlow({ confirmation: { kind: "aborted", result: { _tag: "Failure" } } }); + const outcome = await flow.run(); + expect(outcome).toEqual({ kind: "aborted", result: { _tag: "Failure" } }); + expect(flow.archive).not.toHaveBeenCalled(); + expect(flow.cleanup).not.toHaveBeenCalled(); + }); + + it("sequential bulk archive prompts only when each worktree reaches its final active reference", async () => { + // Two threads share one worktree; a third owns its own. Each archive + // requests a fresh preview, so the shared worktree only prompts once the + // earlier archive is already visible to the server. + const activeByThread = new Map([ + ["t1", { worktreePath: "/wt/shared", branch: "shared" }], + ["t2", { worktreePath: "/wt/shared", branch: "shared" }], + ["t3", { worktreePath: "/wt/solo", branch: "solo" }], + ]); + const prompts: Array = []; + + const archiveOne = (threadId: string) => + runArchiveWithWorktreeCleanup({ + previewCandidate: async () => { + const target = activeByThread.get(threadId); + if (!target) return null; + const shared = [...activeByThread.entries()].some( + ([otherId, other]) => + otherId !== threadId && other.worktreePath === target.worktreePath, + ); + return shared ? null : target; + }, + removalPolicy: "confirm", + confirmRemoval: async ({ displayWorktreePath }) => { + prompts.push(displayWorktreePath); + return { kind: "declined" }; + }, + archive: async () => { + activeByThread.delete(threadId); + return { _tag: "Success" as const }; + }, + isArchiveSuccess: (result) => result._tag === "Success", + cleanup: async () => ({ kind: "done", status: "removed" }), + onCleanupFailed: () => {}, + onCleanupRetained: () => {}, + }); + + await archiveOne("t1"); + await archiveOne("t2"); + await archiveOne("t3"); + + // t1 shares with t2 (no prompt); t2 is the final shared reference and + // t3 the only solo reference (both prompt). + expect(prompts).toEqual(["shared", "solo"]); + }); +}); + +describe("formatWorktreePathForDisplay", () => { + it("returns the final path segment across separators", () => { + expect(formatWorktreePathForDisplay("/tmp/worktrees/repo/feature-1")).toBe("feature-1"); + expect(formatWorktreePathForDisplay("/tmp/worktrees/repo/feature-1/")).toBe("feature-1"); + expect(formatWorktreePathForDisplay("C:\\worktrees\\repo\\feature-1")).toBe("feature-1"); + }); + + it("falls back to the trimmed input when no segment exists", () => { + expect(formatWorktreePathForDisplay(" ")).toBe(" "); + expect(formatWorktreePathForDisplay("///")).toBe("///"); + }); +}); diff --git a/packages/client-runtime/src/state/worktreeCleanup.ts b/packages/client-runtime/src/state/worktreeCleanup.ts new file mode 100644 index 000000000000..cd663e43c69d --- /dev/null +++ b/packages/client-runtime/src/state/worktreeCleanup.ts @@ -0,0 +1,91 @@ +/** + * Shared archive-time worktree cleanup flow. + * + * The server owns the safety decision (preview + conditional cleanup RPCs); + * this module owns the client sequencing shared by web and mobile: act only + * when the server reports a candidate, optionally confirm based on client + * policy, archive before cleanup, and report cleanup problems without + * failing the archive itself. + */ +import type { WorktreeCleanupStatus } from "@t3tools/contracts"; + +export interface ArchiveWorktreeCleanupCandidate { + readonly worktreePath: string; + readonly branch: string; +} + +/** Shortens a worktree path to its final segment for prompts and toasts. */ +export function formatWorktreePathForDisplay(worktreePath: string): string { + const trimmed = worktreePath.trim(); + if (!trimmed) { + return worktreePath; + } + const normalized = trimmed.replace(/\\/g, "/").replace(/\/+$/, ""); + const parts = normalized.split("/"); + const lastPart = parts[parts.length - 1]?.trim() ?? ""; + return lastPart.length > 0 ? lastPart : trimmed; +} + +export type WorktreeCleanupConfirmation = + | { readonly kind: "confirmed" } + | { readonly kind: "declined" } + /** The confirmation surface itself failed; the archive is not attempted. */ + | { readonly kind: "aborted"; readonly result: TAbort }; + +export type WorktreeCleanupOutcome = + | { readonly kind: "failed"; readonly message: string } + | { readonly kind: "done"; readonly status: WorktreeCleanupStatus }; + +export type ArchiveWithWorktreeCleanupResult = + | { readonly kind: "archived"; readonly result: TArchive } + | { readonly kind: "aborted"; readonly result: TAbort }; + +export type WorktreeRemovalPolicy = "confirm" | "remove"; + +export async function runArchiveWithWorktreeCleanup(input: { + /** Server-authoritative preview; null when ineligible or when the preview failed. */ + readonly previewCandidate: () => Promise; + /** Whether an eligible worktree is confirmed first or removed automatically. */ + readonly removalPolicy: WorktreeRemovalPolicy; + /** Confirmation surface, or null when none is available. */ + readonly confirmRemoval: + | ((prompt: { + readonly candidate: ArchiveWorktreeCleanupCandidate; + readonly displayWorktreePath: string; + }) => Promise>) + | null; + readonly archive: () => Promise; + readonly isArchiveSuccess: (result: TArchive) => boolean; + readonly cleanup: () => Promise; + readonly onCleanupFailed: (displayWorktreePath: string, message: string) => void; + readonly onCleanupRetained: (displayWorktreePath: string) => void; +}): Promise> { + const candidate = await input.previewCandidate(); + let shouldCleanup = false; + let displayWorktreePath: string | null = null; + if (candidate) { + displayWorktreePath = formatWorktreePathForDisplay(candidate.worktreePath); + if (input.removalPolicy === "remove") { + shouldCleanup = true; + } else if (input.confirmRemoval) { + const confirmation = await input.confirmRemoval({ candidate, displayWorktreePath }); + if (confirmation.kind === "aborted") { + return { kind: "aborted", result: confirmation.result }; + } + shouldCleanup = confirmation.kind === "confirmed"; + } + } + + const archiveResult = await input.archive(); + if (!shouldCleanup || displayWorktreePath === null || !input.isArchiveSuccess(archiveResult)) { + return { kind: "archived", result: archiveResult }; + } + + const cleanupOutcome = await input.cleanup(); + if (cleanupOutcome.kind === "failed") { + input.onCleanupFailed(displayWorktreePath, cleanupOutcome.message); + } else if (cleanupOutcome.status === "retained-active") { + input.onCleanupRetained(displayWorktreePath); + } + return { kind: "archived", result: archiveResult }; +} diff --git a/packages/client-runtime/src/work-log/presentation.ts b/packages/client-runtime/src/work-log/presentation.ts index 8d62bb0794ca..6c58e8ee1093 100644 --- a/packages/client-runtime/src/work-log/presentation.ts +++ b/packages/client-runtime/src/work-log/presentation.ts @@ -658,7 +658,7 @@ export function omitSupersededLifecycleMarkers( } } - return reversedEntries.toReversed(); + return reversedEntries.slice().reverse(); } export function toolGroupSummaryKind( diff --git a/packages/client-runtime/src/work-log/userInput.ts b/packages/client-runtime/src/work-log/userInput.ts index 355083c04836..65101df6fa9c 100644 --- a/packages/client-runtime/src/work-log/userInput.ts +++ b/packages/client-runtime/src/work-log/userInput.ts @@ -28,7 +28,7 @@ function questionFingerprint( ): string | undefined { const texts = questions.map((question) => (typeof question === "string" ? question.trim() : "")); return texts.length > 0 && texts.every(Boolean) - ? JSON.stringify([turnId, texts.toSorted()]) + ? JSON.stringify([turnId, [...texts].sort()]) : undefined; } diff --git a/packages/contracts/src/aiUsage.test.ts b/packages/contracts/src/aiUsage.test.ts new file mode 100644 index 000000000000..903f18ac8573 --- /dev/null +++ b/packages/contracts/src/aiUsage.test.ts @@ -0,0 +1,86 @@ +import { Schema } from "effect"; +import { describe, expect, it } from "vite-plus/test"; + +import { AI_USAGE_UNAVAILABLE, AiUsageProviderStatus, AiUsageSnapshot } from "./aiUsage.ts"; + +const decodeStatus = Schema.decodeUnknownSync(AiUsageProviderStatus); +const decodeSnapshot = Schema.decodeUnknownSync(AiUsageSnapshot); + +describe("AiUsageProviderStatus", () => { + it("decodes a percent provider with pace", () => { + const status = decodeStatus({ + provider: "codex", + ok: true, + plan: "prolite", + headline: "100%", + headline_label: "5-hour", + state: "critical", + score: 0, + stale: false, + stale_since: null, + error: null, + windows: [ + { + id: "5h", + label: "5-hour", + percent: 100, + used: null, + unit: null, + resets_at: 1783369185, + pace: { + expected_percent: 96, + delta_percent: 4, + projected_percent: 105, + eta_seconds: 0, + lasts_to_reset: false, + stage: "onTrack", + }, + }, + ], + }); + expect(status.provider).toBe("codex"); + expect(status.windows[0]?.percent).toBe(100); + expect(status.windows[0]?.pace?.lasts_to_reset).toBe(false); + }); + + it("decodes a dollar-based window without percent", () => { + const status = decodeStatus({ + provider: "opencode", + ok: true, + plan: "go", + windows: [{ id: "weekly", label: "Weekly ($)", used: 3.01, unit: "$", percent: 10 }], + }); + expect(status.windows[0]?.unit).toBe("$"); + expect(status.plan).toBe("go"); + }); + + it("ignores unknown extra keys from the daemon feed", () => { + const status = decodeStatus({ + provider: "zai", + ok: true, + windows: [], + raw: { anything: true }, + }); + expect(status.provider).toBe("zai"); + }); +}); + +describe("AiUsageSnapshot", () => { + it("round-trips a multi-provider snapshot", () => { + const snapshot = decodeSnapshot({ + generated_at: "2026-07-06T20:07:11.894Z", + worst_percent: 100, + available: true, + items: [ + { provider: "claude", ok: true, windows: [{ id: "weekly", label: "Weekly", percent: 84 }] }, + { provider: "codex", ok: true, windows: [{ id: "5h", label: "5-hour", percent: 100 }] }, + ], + }); + expect(snapshot.items).toHaveLength(2); + expect(snapshot.available).toBe(true); + }); + + it("decodes the unavailable sentinel", () => { + expect(decodeSnapshot(AI_USAGE_UNAVAILABLE)).toEqual(AI_USAGE_UNAVAILABLE); + }); +}); diff --git a/packages/contracts/src/aiUsage.ts b/packages/contracts/src/aiUsage.ts new file mode 100644 index 000000000000..b1ea03d2624e --- /dev/null +++ b/packages/contracts/src/aiUsage.ts @@ -0,0 +1,98 @@ +/** + * AI usage - Schemas for the local `ai-usage` daemon feed. + * + * A user-run daemon (`ai-usage serve`) exposes normalized coding-plan usage + * across providers (codex, claude, cursor, zai, opencode, grok) on a small HTTP API. + * The server polls its `/dms` endpoint on an interval and fans the latest + * snapshot to subscribers so the web can mark providers that are near or over + * their plan limits and help pick the best available AI for a new thread. + * + * The daemon is optional and machine-local: when it is unreachable the server + * still emits a snapshot with `available: false` and no items, so the UI simply + * shows no markers rather than erroring. + * + * Schemas are intentionally tolerant (nullable / optional fields) because the + * feed shape can drift across daemon versions; unknown keys are ignored. + * + * @module AiUsage + */ +import { Schema } from "effect"; + +/** + * Pace projection for a single usage window: are you burning faster than an + * even-pace line, and if so when do you hit 100%? Numeric fields are nullable + * because the daemon omits projections when no usage has accrued yet. + */ +export const AiUsagePace = Schema.Struct({ + expected_percent: Schema.optionalKey(Schema.NullOr(Schema.Number)), + delta_percent: Schema.optionalKey(Schema.NullOr(Schema.Number)), + projected_percent: Schema.optionalKey(Schema.NullOr(Schema.Number)), + eta_seconds: Schema.optionalKey(Schema.NullOr(Schema.Number)), + lasts_to_reset: Schema.optionalKey(Schema.NullOr(Schema.Boolean)), + stage: Schema.optionalKey(Schema.NullOr(Schema.String)), +}); +export type AiUsagePace = typeof AiUsagePace.Type; + +/** + * One rolling usage window for a provider (e.g. the 5-hour or weekly limit). + * `percent` is the primary signal; `used`/`unit` carry raw values for + * dollar/token/request based windows that have no percentage. + * + * `informational` marks a window the daemon does not consider a real gate on + * using the provider right now (e.g. a legacy pay-as-you-go pool); clients must + * not escalate it into a "can't use this" signal. + */ +export const AiUsageWindow = Schema.Struct({ + id: Schema.String, + label: Schema.String, + percent: Schema.optionalKey(Schema.NullOr(Schema.Number)), + used: Schema.optionalKey(Schema.NullOr(Schema.Number)), + limit: Schema.optionalKey(Schema.NullOr(Schema.Number)), + unit: Schema.optionalKey(Schema.NullOr(Schema.String)), + resets_at: Schema.optionalKey(Schema.NullOr(Schema.Number)), + pace: Schema.optionalKey(Schema.NullOr(AiUsagePace)), + informational: Schema.optionalKey(Schema.NullOr(Schema.Boolean)), +}); +export type AiUsageWindow = typeof AiUsageWindow.Type; + +/** + * Per-provider usage status. `provider` is the daemon's provider slug + * (codex/claude/cursor/zai/opencode). `state`/`score`/`headline` are the + * daemon's own glanceable summary; the web derives its own marker severity + * from the window percentages and pace. + */ +export const AiUsageProviderStatus = Schema.Struct({ + provider: Schema.String, + ok: Schema.Boolean, + plan: Schema.optionalKey(Schema.NullOr(Schema.String)), + headline: Schema.optionalKey(Schema.NullOr(Schema.String)), + headline_label: Schema.optionalKey(Schema.NullOr(Schema.String)), + state: Schema.optionalKey(Schema.NullOr(Schema.String)), + score: Schema.optionalKey(Schema.NullOr(Schema.Number)), + stale: Schema.optionalKey(Schema.NullOr(Schema.Boolean)), + stale_since: Schema.optionalKey(Schema.NullOr(Schema.Number)), + error: Schema.optionalKey(Schema.NullOr(Schema.String)), + windows: Schema.Array(AiUsageWindow), +}); +export type AiUsageProviderStatus = typeof AiUsageProviderStatus.Type; + +/** + * A full snapshot of the daemon feed. `available` is `false` when the daemon + * could not be reached; `items` is ordered best-to-use-now first (the daemon's + * usability ranking). + */ +export const AiUsageSnapshot = Schema.Struct({ + generated_at: Schema.optionalKey(Schema.NullOr(Schema.String)), + worst_percent: Schema.optionalKey(Schema.NullOr(Schema.Number)), + available: Schema.Boolean, + items: Schema.Array(AiUsageProviderStatus), +}); +export type AiUsageSnapshot = typeof AiUsageSnapshot.Type; + +/** Snapshot served when the daemon is unreachable or the feed cannot be parsed. */ +export const AI_USAGE_UNAVAILABLE: AiUsageSnapshot = { + generated_at: null, + worst_percent: null, + available: false, + items: [], +}; diff --git a/packages/contracts/src/devStack.ts b/packages/contracts/src/devStack.ts new file mode 100644 index 000000000000..949de06beb7a --- /dev/null +++ b/packages/contracts/src/devStack.ts @@ -0,0 +1,59 @@ +import * as Schema from "effect/Schema"; + +/** + * `dev-stack/1` — the on-disk format a repository uses to register long-running + * dev servers it started outside T3's process tree, so T3 can supervise them. + * + * Entries live under `/stacks///.json`, + * where the registry defaults to `$TMPDIR/dev-stacks`. T3 sweeps the whole + * registry across every project, so an entry carries **facts only** — pids, + * ports, and where each process runs. Anything that requires judgement (how long + * idle is too long, what counts as a consumer, which role a consumer connects to) + * is declared per repository under `devStacks` in `t3.json`, because it is a + * property of the repository rather than of one running instance. + * + * Repositories write these entries themselves, from whatever starts the servers. + * T3 only reads them. + */ +export const DEV_STACK_SCHEMA_VERSION = "dev-stack/1"; + +/** Default registry directory name, resolved inside the OS temp directory. */ +export const DEV_STACK_REGISTRY_DIR = "dev-stacks"; + +export const DevStackProcess = Schema.Struct({ + role: Schema.String.annotate({ + description: + 'Role within the stack, e.g. "api" or "frontend". Matched against `devStacks.entryRoles`.', + }), + pid: Schema.Int.check(Schema.isGreaterThan(0)).annotate({ + description: "PID of the process group leader. The stack is torn down by signalling the group.", + }), + port: Schema.optionalKey( + Schema.Int.check(Schema.isGreaterThan(0)).annotate({ + description: "Port the process listens on, verified by the producer's health check at start.", + }), + ), + cwd: Schema.String.annotate({ + description: + "Working directory relative to `root`. T3 confirms /proc//cwd matches before signalling, so a recycled PID is never mistaken for the stack's own process.", + }), +}).annotate({ description: "One process belonging to a registered dev stack." }); +export type DevStackProcess = typeof DevStackProcess.Type; + +export const DevStackEntry = Schema.Struct({ + schema: Schema.Literal(DEV_STACK_SCHEMA_VERSION), + project: Schema.String, + worktree: Schema.String.annotate({ description: "Stable hash of the worktree path." }), + root: Schema.String.annotate({ + description: "Absolute path of the worktree that owns the stack.", + }), + instance: Schema.String.annotate({ + description: + "What the repository shards stacks by — a company, a tenant, a variant. Opaque to T3; it only has to be unique within a worktree.", + }), + processes: Schema.Array(DevStackProcess), +}).annotate({ + title: "Dev stack registry entry", + description: "A live dev stack registered for T3 to supervise.", +}); +export type DevStackEntry = typeof DevStackEntry.Type; diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts index 9dcc844e713a..4cb45a37e3d9 100644 --- a/packages/contracts/src/environment.ts +++ b/packages/contracts/src/environment.ts @@ -183,6 +183,16 @@ export const RepositoryIdentityLocator = Schema.Struct({ }); export type RepositoryIdentityLocator = typeof RepositoryIdentityLocator.Type; +export const RepositoryIdentityRemote = Schema.Struct({ + remoteName: TrimmedNonEmptyString, + remoteUrl: TrimmedNonEmptyString, + canonicalKey: TrimmedNonEmptyString, + provider: Schema.optionalKey(TrimmedNonEmptyString), + owner: Schema.optionalKey(TrimmedNonEmptyString), + name: Schema.optionalKey(TrimmedNonEmptyString), +}); +export type RepositoryIdentityRemote = typeof RepositoryIdentityRemote.Type; + export const RepositoryIdentity = Schema.Struct({ canonicalKey: TrimmedNonEmptyString, locator: RepositoryIdentityLocator, @@ -191,6 +201,10 @@ export const RepositoryIdentity = Schema.Struct({ provider: Schema.optionalKey(TrimmedNonEmptyString), owner: Schema.optionalKey(TrimmedNonEmptyString), name: Schema.optionalKey(TrimmedNonEmptyString), + // Every configured remote, including the primary one the fields above describe. + // A fork answers to more than one repository, so identity matching cannot rely + // on the single primary remote alone. + remotes: Schema.optionalKey(Schema.Array(RepositoryIdentityRemote)), }); export type RepositoryIdentity = typeof RepositoryIdentity.Type; diff --git a/packages/contracts/src/environmentHttp.ts b/packages/contracts/src/environmentHttp.ts index 9cdd21393fea..6ea68087befb 100644 --- a/packages/contracts/src/environmentHttp.ts +++ b/packages/contracts/src/environmentHttp.ts @@ -67,6 +67,9 @@ export const EnvironmentRequestInvalidReason = Schema.Literals([ "invalid_scope", "scope_not_granted", "invalid_command", + "identity_claim_required", + "identity_unknown_person", + "identity_map_invalid", ]); export type EnvironmentRequestInvalidReason = typeof EnvironmentRequestInvalidReason.Type; diff --git a/packages/contracts/src/git.test.ts b/packages/contracts/src/git.test.ts index 5dda491b009b..30a644544810 100644 --- a/packages/contracts/src/git.test.ts +++ b/packages/contracts/src/git.test.ts @@ -3,14 +3,18 @@ import * as Schema from "effect/Schema"; import { VcsCreateWorktreeInput, + VcsStatusInput, GitPreparePullRequestThreadInput, GitPreparePullRequestThreadResult, GitRunStackedActionResult, GitRunStackedActionInput, + GitActionProgressEvent, + GitCommandError, GitResolvePullRequestResult, } from "./git.ts"; const decodeCreateWorktreeInput = Schema.decodeUnknownSync(VcsCreateWorktreeInput); +const decodeVcsStatusInput = Schema.decodeUnknownSync(VcsStatusInput); const decodePreparePullRequestThreadInput = Schema.decodeUnknownSync( GitPreparePullRequestThreadInput, ); @@ -19,8 +23,23 @@ const decodePreparePullRequestThreadResult = Schema.decodeUnknownSync( ); const decodeRunStackedActionInput = Schema.decodeUnknownSync(GitRunStackedActionInput); const decodeRunStackedActionResult = Schema.decodeUnknownSync(GitRunStackedActionResult); +const decodeActionProgressEvent = Schema.decodeUnknownSync(GitActionProgressEvent); +const decodeGitCommandError = Schema.decodeUnknownSync(GitCommandError); const decodeResolvePullRequestResult = Schema.decodeUnknownSync(GitResolvePullRequestResult); +describe("VcsStatusInput", () => { + it("accepts cwd-only input as full-mode compatible", () => { + const parsed = decodeVcsStatusInput({ cwd: "/repo" }); + expect(parsed.cwd).toBe("/repo"); + expect(parsed.mode).toBeUndefined(); + }); + + it("accepts list mode for high-cardinality list subscriptions", () => { + const parsed = decodeVcsStatusInput({ cwd: "/repo/worktree", mode: "list" }); + expect(parsed.mode).toBe("list"); + }); +}); + describe("VcsCreateWorktreeInput", () => { it("accepts omitted newRefName for existing-refName worktrees", () => { const parsed = decodeCreateWorktreeInput({ @@ -44,6 +63,17 @@ describe("VcsCreateWorktreeInput", () => { expect(parsed.baseRefName).toBe("origin/main"); }); + + it("accepts deferring dependency installation to asynchronous project setup", () => { + const parsed = decodeCreateWorktreeInput({ + cwd: "/repo", + refName: "main", + deferDependencyInstall: true, + path: "/tmp/worktree", + }); + + expect(parsed.deferDependencyInstall).toBe(true); + }); }); describe("GitPreparePullRequestThreadInput", () => { @@ -124,6 +154,102 @@ describe("GitRunStackedActionInput", () => { expect(parsed.actionId).toBe("action-1"); expect(parsed.action).toBe("create_pr"); + expect(parsed.disableCommitSigning).toBeUndefined(); + }); + + it("accepts a per-attempt commit-signing override", () => { + const parsed = decodeRunStackedActionInput({ + actionId: "action-2", + cwd: "/repo", + action: "commit", + disableCommitSigning: true, + }); + + expect(parsed.disableCommitSigning).toBe(true); + }); +}); + +describe("GitActionProgressEvent", () => { + it("defaults omitted failure classifications for older action-failure payloads", () => { + const parsed = decodeActionProgressEvent({ + actionId: "action-1", + cwd: "/repo", + action: "commit", + kind: "action_failed", + phase: "commit", + message: "Commit failed.", + }); + + expect(parsed).toMatchObject({ + kind: "action_failed", + failureKind: "unknown", + }); + }); + + it("accepts action failures with an unknown classification", () => { + const parsed = decodeActionProgressEvent({ + actionId: "action-1", + cwd: "/repo", + action: "commit", + kind: "action_failed", + phase: "commit", + message: "Commit failed.", + failureKind: "unknown", + }); + + expect(parsed.kind).toBe("action_failed"); + if (parsed.kind === "action_failed") { + expect(parsed.failureKind).toBe("unknown"); + } + }); + + it("accepts classified commit-signing failures", () => { + const parsed = decodeActionProgressEvent({ + actionId: "action-2", + cwd: "/repo", + action: "commit_push", + kind: "action_failed", + phase: "commit", + message: "Commit failed.", + failureKind: "commit_signing_failed", + }); + + expect(parsed).toMatchObject({ + kind: "action_failed", + failureKind: "commit_signing_failed", + }); + }); +}); + +describe("GitCommandError", () => { + const baseError = { + _tag: "GitCommandError", + operation: "GitVcsDriver.commit.commit", + command: "git", + cwd: "/repo", + detail: "Git command exited with a non-zero status.", + } as const; + + it("defaults omitted failure classifications for older command-error payloads", () => { + expect(decodeGitCommandError(baseError).failureKind).toBe("unknown"); + }); + + it("accepts errors with an unknown classification", () => { + expect( + decodeGitCommandError({ + ...baseError, + failureKind: "unknown", + }).failureKind, + ).toBe("unknown"); + }); + + it("accepts classified commit-signing errors", () => { + expect( + decodeGitCommandError({ + ...baseError, + failureKind: "commit_signing_failed", + }).failureKind, + ).toBe("commit_signing_failed"); }); }); diff --git a/packages/contracts/src/git.ts b/packages/contracts/src/git.ts index c5a5825e193e..60c158c6d5a7 100644 --- a/packages/contracts/src/git.ts +++ b/packages/contracts/src/git.ts @@ -29,6 +29,11 @@ export const GitActionProgressKind = Schema.Literals([ "action_failed", ]); export type GitActionProgressKind = typeof GitActionProgressKind.Type; +export const GitActionFailureKind = Schema.Literals(["unknown", "commit_signing_failed"]); +export type GitActionFailureKind = typeof GitActionFailureKind.Type; +const GitActionFailureKindWithDefault = GitActionFailureKind.pipe( + Schema.withDecodingDefaultKey(Effect.succeed("unknown" as const)), +); export const GitActionProgressStream = Schema.Literals(["stdout", "stderr"]); export type GitActionProgressStream = typeof GitActionProgressStream.Type; const GitCommitStepStatus = Schema.Literals([ @@ -100,11 +105,31 @@ export type GitResolvedPullRequest = typeof GitResolvedPullRequest.Type; // RPC Inputs +/** + * How the server should refresh remote VCS status for a subscription. + * + * - `full` (default): dedicated per-cwd remote poller (automatic git fetch interval) — + * for the active thread / git chrome. + * - `list`: still keeps remote/PR state **up to date** via a **shared budgeted** + * refresher for all list-interested worktrees (not one poller fiber per row). + * Use for sidebar/board/list PR badges. + */ +export const VcsStatusSubscribeMode = Schema.Literals(["full", "list"]); +export type VcsStatusSubscribeMode = typeof VcsStatusSubscribeMode.Type; + export const VcsStatusInput = Schema.Struct({ cwd: TrimmedNonEmptyStringSchema, + /** Omit or `full` for active surfaces; use `list` for high-cardinality list UIs. */ + mode: Schema.optionalKey(VcsStatusSubscribeMode), }); export type VcsStatusInput = typeof VcsStatusInput.Type; +export const VcsResolveBranchChangeRequestInput = Schema.Struct({ + cwd: TrimmedNonEmptyStringSchema, + refName: TrimmedNonEmptyStringSchema, +}); +export type VcsResolveBranchChangeRequestInput = typeof VcsResolveBranchChangeRequestInput.Type; + export const VcsPullInput = Schema.Struct({ cwd: TrimmedNonEmptyStringSchema, }); @@ -116,6 +141,7 @@ export const GitRunStackedActionInput = Schema.Struct({ action: GitStackedAction, commitMessage: Schema.optional(TrimmedNonEmptyStringSchema.check(Schema.isMaxLength(10_000))), featureBranch: Schema.optional(Schema.Boolean), + disableCommitSigning: Schema.optional(Schema.Boolean), filePaths: Schema.optional( Schema.Array(TrimmedNonEmptyStringSchema).check(Schema.isMinLength(1)), ), @@ -142,6 +168,7 @@ export const VcsCreateWorktreeInput = Schema.Struct({ refName: TrimmedNonEmptyStringSchema, newRefName: Schema.optional(TrimmedNonEmptyStringSchema), baseRefName: Schema.optional(TrimmedNonEmptyStringSchema), + deferDependencyInstall: Schema.optional(Schema.Boolean), path: Schema.NullOr(TrimmedNonEmptyStringSchema), }); export type VcsCreateWorktreeInput = typeof VcsCreateWorktreeInput.Type; @@ -167,6 +194,46 @@ export const VcsRemoveWorktreeInput = Schema.Struct({ }); export type VcsRemoveWorktreeInput = typeof VcsRemoveWorktreeInput.Type; +// Worktree lifecycle (thread-scoped cleanup) +// +// These inputs are keyed by thread id instead of a client-provided repository +// root and path so the server stays authoritative over which worktree (if +// any) is safe to remove or must be restored. + +export const WorktreeCleanupPreviewInput = Schema.Struct({ + threadId: ThreadId, +}); +export type WorktreeCleanupPreviewInput = typeof WorktreeCleanupPreviewInput.Type; + +export const WorktreeCleanupCandidate = Schema.Struct({ + worktreePath: TrimmedNonEmptyStringSchema, + branch: TrimmedNonEmptyStringSchema, +}); +export type WorktreeCleanupCandidate = typeof WorktreeCleanupCandidate.Type; + +export const WorktreeCleanupPreviewResult = Schema.Struct({ + candidate: Schema.NullOr(WorktreeCleanupCandidate), +}); +export type WorktreeCleanupPreviewResult = typeof WorktreeCleanupPreviewResult.Type; + +export const WorktreeCleanupInput = Schema.Struct({ + threadId: ThreadId, +}); +export type WorktreeCleanupInput = typeof WorktreeCleanupInput.Type; + +export const WorktreeCleanupStatus = Schema.Literals([ + "removed", + "retained-active", + "already-missing", +]); +export type WorktreeCleanupStatus = typeof WorktreeCleanupStatus.Type; + +export const WorktreeCleanupResult = Schema.Struct({ + status: WorktreeCleanupStatus, + worktreePath: TrimmedNonEmptyStringSchema, +}); +export type WorktreeCleanupResult = typeof WorktreeCleanupResult.Type; + export const VcsCreateRefInput = Schema.Struct({ cwd: TrimmedNonEmptyStringSchema, refName: TrimmedNonEmptyStringSchema, @@ -193,13 +260,14 @@ export type VcsInitInput = typeof VcsInitInput.Type; // RPC Results -const VcsStatusChangeRequest = Schema.Struct({ +export const VcsStatusChangeRequest = Schema.Struct({ number: PositiveInt, title: TrimmedNonEmptyStringSchema, url: Schema.String, baseRef: TrimmedNonEmptyStringSchema, headRef: TrimmedNonEmptyStringSchema, state: VcsStatusChangeRequestState, + hasFailingChecks: Schema.optional(Schema.Boolean), /** Optional for compatibility with older servers and providers. */ isDraft: Schema.optional(Schema.Boolean), /** @@ -209,6 +277,13 @@ const VcsStatusChangeRequest = Schema.Struct({ */ updatedAt: Schema.optional(Schema.NullOr(Schema.String)), }); +export type VcsStatusChangeRequest = typeof VcsStatusChangeRequest.Type; + +export const VcsResolveBranchChangeRequestResult = Schema.Struct({ + sourceControlProvider: Schema.optional(SourceControlProviderInfo), + pr: Schema.NullOr(VcsStatusChangeRequest), +}); +export type VcsResolveBranchChangeRequestResult = typeof VcsResolveBranchChangeRequestResult.Type; const VcsStatusLocalShape = { isRepo: Schema.Boolean, @@ -273,8 +348,22 @@ export const VcsListRefsResult = Schema.Struct({ }); export type VcsListRefsResult = typeof VcsListRefsResult.Type; +export const VcsWorktreePreparation = Schema.Union([ + Schema.TaggedStruct("ready", { + attempts: NonNegativeInt, + }), + Schema.TaggedStruct("degraded", { + attempts: NonNegativeInt, + command: Schema.String, + detail: Schema.String, + exitCode: Schema.optional(Schema.Number), + }), +]); +export type VcsWorktreePreparation = typeof VcsWorktreePreparation.Type; + export const VcsCreateWorktreeResult = Schema.Struct({ worktree: VcsWorktree, + preparation: Schema.optional(VcsWorktreePreparation), }); export type VcsCreateWorktreeResult = typeof VcsCreateWorktreeResult.Type; @@ -347,6 +436,7 @@ export class GitCommandError extends Schema.TaggedError()("GitC stdoutLength: Schema.optional(Schema.Number), stderrLength: Schema.optional(Schema.Number), outputLength: Schema.optional(Schema.Number), + failureKind: GitActionFailureKindWithDefault, detail: Schema.String, cause: Schema.optional(Schema.Defect()), }) { @@ -355,6 +445,20 @@ export class GitCommandError extends Schema.TaggedError()("GitC } } +export class WorktreeLifecycleError extends Schema.TaggedError()( + "WorktreeLifecycleError", + { + operation: Schema.String, + threadId: ThreadId, + detail: Schema.String, + cause: Schema.optional(Schema.Defect()), + }, +) { + override get message(): string { + return `Worktree ${this.operation} failed: ${this.detail}`; + } +} + export class TextGenerationError extends Schema.TaggedError()( "TextGenerationError", { @@ -450,6 +554,7 @@ const GitActionFailedEvent = Schema.Struct({ kind: Schema.Literal("action_failed"), phase: Schema.NullOr(GitActionProgressPhase), message: TrimmedNonEmptyStringSchema, + failureKind: GitActionFailureKindWithDefault, }); export const GitActionProgressEvent = Schema.Union([ diff --git a/packages/contracts/src/hostResources.test.ts b/packages/contracts/src/hostResources.test.ts new file mode 100644 index 000000000000..f6674087db1b --- /dev/null +++ b/packages/contracts/src/hostResources.test.ts @@ -0,0 +1,47 @@ +import { Schema } from "effect"; +import { describe, expect, it } from "vite-plus/test"; + +import { ServerHostResourceSnapshot } from "./hostResources.ts"; + +const decodeSnapshot = Schema.decodeUnknownSync(ServerHostResourceSnapshot); + +describe("ServerHostResourceSnapshot", () => { + it("decodes a supported host snapshot", () => { + expect( + decodeSnapshot({ + status: "supported", + checkedAt: "2026-07-13T10:00:00.000Z", + source: "procfs", + hostname: "smart", + platform: "linux", + cpuPercent: 25.5, + memoryUsedPercent: 62.5, + memoryUsedBytes: 5_000, + memoryAvailableBytes: 3_000, + memoryTotalBytes: 8_000, + loadAverage: { m1: 1.2, m5: 1, m15: 0.8 }, + logicalCores: 8, + message: null, + }).hostname, + ).toBe("smart"); + }); + + it("decodes an unavailable snapshot without fake values", () => { + const snapshot = decodeSnapshot({ + status: "unavailable", + checkedAt: "2026-07-13T10:00:00.000Z", + source: "unavailable", + hostname: null, + platform: null, + cpuPercent: null, + memoryUsedPercent: null, + memoryUsedBytes: null, + memoryAvailableBytes: null, + memoryTotalBytes: null, + loadAverage: null, + logicalCores: null, + message: "Unavailable", + }); + expect(snapshot.cpuPercent).toBeNull(); + }); +}); diff --git a/packages/contracts/src/hostResources.ts b/packages/contracts/src/hostResources.ts new file mode 100644 index 000000000000..ac003d17f92d --- /dev/null +++ b/packages/contracts/src/hostResources.ts @@ -0,0 +1,27 @@ +import * as Schema from "effect/Schema"; + +import { IsoDateTime, TrimmedNonEmptyString } from "./baseSchemas.ts"; + +export const ServerHostLoadAverage = Schema.Struct({ + m1: Schema.Number, + m5: Schema.Number, + m15: Schema.Number, +}); +export type ServerHostLoadAverage = typeof ServerHostLoadAverage.Type; + +export const ServerHostResourceSnapshot = Schema.Struct({ + status: Schema.Literals(["supported", "unavailable"]), + checkedAt: IsoDateTime, + source: Schema.Literals(["os", "procfs", "unavailable"]), + hostname: Schema.NullOr(TrimmedNonEmptyString), + platform: Schema.NullOr(TrimmedNonEmptyString), + cpuPercent: Schema.NullOr(Schema.Number), + memoryUsedPercent: Schema.NullOr(Schema.Number), + memoryUsedBytes: Schema.NullOr(Schema.Number), + memoryAvailableBytes: Schema.NullOr(Schema.Number), + memoryTotalBytes: Schema.NullOr(Schema.Number), + loadAverage: Schema.NullOr(ServerHostLoadAverage), + logicalCores: Schema.NullOr(Schema.Number), + message: Schema.NullOr(Schema.String), +}); +export type ServerHostResourceSnapshot = typeof ServerHostResourceSnapshot.Type; diff --git a/packages/contracts/src/identity.test.ts b/packages/contracts/src/identity.test.ts new file mode 100644 index 000000000000..5c7d50231bfc --- /dev/null +++ b/packages/contracts/src/identity.test.ts @@ -0,0 +1,161 @@ +import { describe, expect, it } from "vite-plus/test"; +import * as Schema from "effect/Schema"; + +import { + IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS, + IDENTITY_HANDLE_SOFT_MAX_LENGTH, + ClientSourceHint, + IdentityClaimInput, + IdentityError, + IdentityPersonPublic, + IdentitySnapshot, + IdentityUsername, + PersonId, + SessionIdentityClaim, + SourceRef, + ThreadParticipantSummary, +} from "./identity.ts"; +import { AuthSessionId } from "./baseSchemas.ts"; + +const decodeUsername = Schema.decodeUnknownSync(IdentityUsername); +const decodePersonId = Schema.decodeUnknownSync(PersonId); +const decodeSourceRef = Schema.decodeUnknownSync(SourceRef); +const decodeClientHint = Schema.decodeUnknownSync(ClientSourceHint); +const decodeSnapshot = Schema.decodeUnknownSync(IdentitySnapshot); +const decodeClaimInput = Schema.decodeUnknownSync(IdentityClaimInput); +const decodeClaim = Schema.decodeUnknownSync(SessionIdentityClaim); +const decodePerson = Schema.decodeUnknownSync(IdentityPersonPublic); +const decodeParticipant = Schema.decodeUnknownSync(ThreadParticipantSummary); + +describe("IdentityUsername / PersonId handles", () => { + it.each(["a", "pat", "patroza", "a_b-c", "julius", "user.name", "x1"])("accepts %s", (value) => { + expect(decodeUsername(value)).toBe(value.toLowerCase()); + expect(decodePersonId(value)).toBe(value.toLowerCase()); + }); + + it("normalizes case to lowercase", () => { + expect(decodeUsername("PatRoza")).toBe("patroza"); + expect(decodePersonId("PatRoza")).toBe("patroza"); + }); + + it("accepts usernames longer than 16 chars within soft max", () => { + const long = `a${"b".repeat(40)}`; + expect(decodeUsername(long)).toBe(long); + }); + + it.each([ + ["empty", ""], + ["spaces", "pat roza"], + ["control char", "foo\nbar"], + ["leading dash", "-pat"], + ["leading underscore", "_pat"], + ["at-sign", "pat@roza"], + ["leading dot", ".pat"], + ])("rejects %s", (_label, value) => { + expect(() => decodeUsername(value)).toThrow(); + expect(() => decodePersonId(value)).toThrow(); + }); + + it("rejects past soft max", () => { + expect(() => decodeUsername("a".repeat(IDENTITY_HANDLE_SOFT_MAX_LENGTH + 1))).toThrow(); + }); + + it("exports typeahead threshold of 3 characters", () => { + expect(IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS).toBe(3); + }); +}); + +describe("SourceRef vs ClientSourceHint", () => { + it("decodes a server stamp with person", () => { + const parsed = decodeSourceRef({ + channel: "desktop", + personId: "patroza", + username: "patroza", + }); + expect(parsed.channel).toBe("desktop"); + expect(parsed.personId).toBe("patroza"); + }); + + it("client hint has no person fields", () => { + const hint = decodeClientHint({ + channel: "discord", + location: { guildId: "1", channelId: "2" }, + actor: { platformId: "9", displayName: "Patrick" }, + }); + expect(hint.channel).toBe("discord"); + expect("personId" in hint).toBe(false); + }); + + it("rejects unknown channel", () => { + expect(() => decodeSourceRef({ channel: "irc" })).toThrow(); + }); +}); + +describe("IdentitySnapshot + claim", () => { + it("decodes an enabled map snapshot", () => { + const parsed = decodeSnapshot({ + enabled: true, + claimRequired: true, + people: [ + { + personId: "patroza", + username: "patroza", + name: "Patrick Roza", + links: { + discordId: "95218063095377920", + githubLogin: "patroza", + }, + }, + ], + }); + expect(parsed.enabled).toBe(true); + expect(parsed.people[0]?.username).toBe("patroza"); + }); + + it("defaults empty links on person", () => { + const person = decodePerson({ + personId: PersonId.make("julius"), + username: "julius", + }); + expect(person.links).toEqual({}); + }); + + it("accepts claim by username or personId with optional method", () => { + expect(decodeClaimInput({ username: "patroza" })).toEqual({ username: "patroza" }); + expect(decodeClaimInput({ personId: "patroza", method: "settings" })).toEqual({ + personId: "patroza", + method: "settings", + }); + }); + + it("decodes a session claim", () => { + const claim = decodeClaim({ + sessionId: AuthSessionId.make("00000000-0000-4000-8000-000000000001"), + personId: "patroza", + username: "patroza", + claimedAt: "2026-07-30T12:00:00.000Z", + method: "typeahead", + }); + expect(claim.method).toBe("typeahead"); + }); + + it("decodes participant summary", () => { + const row = decodeParticipant({ + personId: "patroza", + username: "patroza", + firstChannel: "discord", + channels: ["discord", "desktop"], + firstParticipatedAt: "2026-07-30T12:00:00.000Z", + }); + expect(row.firstChannel).toBe("discord"); + expect(row.channels).toEqual(["discord", "desktop"]); + }); + + it("constructs IdentityError codes", () => { + const err = new IdentityError({ + code: "identity_unknown_person", + message: "not in map", + }); + expect(err.code).toBe("identity_unknown_person"); + }); +}); diff --git a/packages/contracts/src/identity.ts b/packages/contracts/src/identity.ts new file mode 100644 index 000000000000..e2e0b71b631c --- /dev/null +++ b/packages/contracts/src/identity.ts @@ -0,0 +1,210 @@ +/** + * Session identity + message/thread source attribution. + * + * Closed-set people come from a server identity map file. Interactive clients + * claim a map person on their auth session; free-form usernames are rejected. + * + * Trust note (v1): interactive claim is **map membership only** — any paired + * session can claim any listed person. That is intentional for trusted-team + * shared environments, not anti-impersonation. “Mine” is claim-based and + * spoofable by peers with a session. Discord/Jira auto-claim binds via platform id. + * + * See docs/architecture/source-and-identity.md + */ +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; +import * as SchemaTransformation from "effect/SchemaTransformation"; +import { AuthSessionId, TrimmedNonEmptyString, IsoDateTime } from "./baseSchemas.ts"; + +// ── Username / person ────────────────────────────────────────── + +/** + * Soft max for wire abuse only — not a product length rule. + * Charset keeps handles safe for `user@channel` display and logs. + */ +export const IDENTITY_HANDLE_SOFT_MAX_LENGTH = 128; + +/** Minimum typed characters before the claim UI shows map suggestions. */ +export const IDENTITY_CLAIM_TYPEAHEAD_MIN_CHARS = 3; + +/** + * Handle charset: leading alnum, then alnum / `.` / `_` / `-`. + * No spaces or control chars. No minimum length product rule (single char OK). + */ +export const IDENTITY_HANDLE_PATTERN = /^[a-z0-9][a-z0-9._-]*$/; + +const normalizeHandle = (value: string) => value.trim().toLowerCase(); + +const IdentityHandleString = TrimmedNonEmptyString.pipe( + Schema.decodeTo( + Schema.String, + SchemaTransformation.transformOrFail({ + decode: (value) => Effect.succeed(normalizeHandle(value)), + encode: (value) => Effect.succeed(value), + }), + ), +).check( + Schema.isMaxLength(IDENTITY_HANDLE_SOFT_MAX_LENGTH), + Schema.isPattern(IDENTITY_HANDLE_PATTERN), +); + +export const IdentityUsername = IdentityHandleString.pipe(Schema.brand("IdentityUsername")); +export type IdentityUsername = typeof IdentityUsername.Type; + +/** Same normalization as username so mine/theirs compares stay case-stable. */ +export const PersonId = IdentityHandleString.pipe(Schema.brand("PersonId")); +export type PersonId = typeof PersonId.Type; + +// ── Channels / SourceRef ─────────────────────────────────────── + +export const SourceChannel = Schema.Literals([ + "desktop", + "vscode", + "web", + "mobile", + "discord", + "github", + "jira", + "slack", + "teams", + "bot", + "unknown", +]); +export type SourceChannel = typeof SourceChannel.Type; + +export const SourceLocation = Schema.Struct({ + guildId: Schema.optionalKey(TrimmedNonEmptyString), + channelId: Schema.optionalKey(TrimmedNonEmptyString), + threadId: Schema.optionalKey(TrimmedNonEmptyString), + owner: Schema.optionalKey(TrimmedNonEmptyString), + repo: Schema.optionalKey(TrimmedNonEmptyString), + number: Schema.optionalKey(Schema.Int), + kind: Schema.optionalKey(Schema.Literals(["pr", "issue"])), + projectKey: Schema.optionalKey(TrimmedNonEmptyString), + issueKey: Schema.optionalKey(TrimmedNonEmptyString), +}); +export type SourceLocation = typeof SourceLocation.Type; + +export const SourceActor = Schema.Struct({ + platformId: Schema.optionalKey(TrimmedNonEmptyString), + displayName: Schema.optionalKey(TrimmedNonEmptyString), +}); +export type SourceActor = typeof SourceActor.Type; + +/** + * Client may only hint non-person fields. Server stamps person from the + * session claim (or platform map for bots). Never trust client personId/username. + */ +export const ClientSourceHint = Schema.Struct({ + channel: Schema.optionalKey(SourceChannel), + location: Schema.optionalKey(SourceLocation), + actor: Schema.optionalKey(SourceActor), +}); +export type ClientSourceHint = typeof ClientSourceHint.Type; + +/** + * Server-authored provenance for a user-originated message / thread origin. + * personId/username absent only when an external actor is unmapped. + */ +export const SourceRef = Schema.Struct({ + channel: SourceChannel, + personId: Schema.optionalKey(PersonId), + username: Schema.optionalKey(IdentityUsername), + location: Schema.optionalKey(SourceLocation), + actor: Schema.optionalKey(SourceActor), +}); +export type SourceRef = typeof SourceRef.Type; + +/** Ordered participant on a thread shell (origin first when known). */ +export const ThreadParticipantSummary = Schema.Struct({ + personId: PersonId, + username: IdentityUsername, + name: Schema.optionalKey(TrimmedNonEmptyString), + firstChannel: Schema.optionalKey(SourceChannel), + channels: Schema.optionalKey(Schema.Array(SourceChannel)), + firstParticipatedAt: IsoDateTime, +}); +export type ThreadParticipantSummary = typeof ThreadParticipantSummary.Type; + +// ── Public identity map (client-safe) ────────────────────────── + +export const IdentityPlatformLinkPublic = Schema.Struct({ + discordId: Schema.optionalKey(TrimmedNonEmptyString), + discordUsername: Schema.optionalKey(TrimmedNonEmptyString), + githubLogin: Schema.optionalKey(TrimmedNonEmptyString), + jiraAccountId: Schema.optionalKey(TrimmedNonEmptyString), +}); +export type IdentityPlatformLinkPublic = typeof IdentityPlatformLinkPublic.Type; + +export const IdentityPersonPublic = Schema.Struct({ + personId: PersonId, + username: IdentityUsername, + name: Schema.optionalKey(TrimmedNonEmptyString), + links: IdentityPlatformLinkPublic.pipe(Schema.withDecodingDefault(Effect.succeed({}))), +}); +export type IdentityPersonPublic = typeof IdentityPersonPublic.Type; + +/** + * Snapshot of the closed identity set. + * v1: `claimRequired === enabled` (both true when map has people). + * Full people[] is intentional roster share for typeahead (not privacy isolation). + */ +export const IdentitySnapshot = Schema.Struct({ + /** False when map file missing/empty — no claim gate. */ + enabled: Schema.Boolean, + people: Schema.Array(IdentityPersonPublic), + /** v1 always equals `enabled`. */ + claimRequired: Schema.Boolean, +}); +export type IdentitySnapshot = typeof IdentitySnapshot.Type; + +export const SessionIdentityClaimMethod = Schema.Literals([ + "typeahead", + "settings", + "auto-discord", + "auto-jira", + "bootstrap", +]); +export type SessionIdentityClaimMethod = typeof SessionIdentityClaimMethod.Type; + +export const SessionIdentityClaim = Schema.Struct({ + sessionId: AuthSessionId, + personId: PersonId, + username: IdentityUsername, + claimedAt: IsoDateTime, + method: SessionIdentityClaimMethod, +}); +export type SessionIdentityClaim = typeof SessionIdentityClaim.Type; + +export const IdentityClaimInput = Schema.Union([ + Schema.Struct({ + personId: PersonId, + method: Schema.optionalKey(Schema.Literals(["typeahead", "settings", "bootstrap"])), + }), + Schema.Struct({ + username: IdentityUsername, + method: Schema.optionalKey(Schema.Literals(["typeahead", "settings", "bootstrap"])), + }), +]); +export type IdentityClaimInput = typeof IdentityClaimInput.Type; + +export const IdentityClaimResult = Schema.Struct({ + claim: SessionIdentityClaim, +}); +export type IdentityClaimResult = typeof IdentityClaimResult.Type; + +export const IdentitySessionClaimResult = Schema.Struct({ + claim: Schema.NullOr(SessionIdentityClaim), +}); +export type IdentitySessionClaimResult = typeof IdentitySessionClaimResult.Type; + +export class IdentityError extends Schema.TaggedError()("IdentityError", { + code: Schema.Literals([ + "identity_map_disabled", + "identity_unknown_person", + "identity_claim_required", + "identity_claim_missing", + "identity_map_invalid", + ]), + message: Schema.String, +}) {} diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts index 32ac53dae9ba..582a4ef32366 100644 --- a/packages/contracts/src/index.ts +++ b/packages/contracts/src/index.ts @@ -1,7 +1,7 @@ export * from "./baseSchemas.ts"; export * from "./assistantCitations.ts"; -export * from "./background.ts"; export * from "./auth.ts"; +export * from "./identity.ts"; export * from "./environment.ts"; export * from "./environmentHttp.ts"; export * from "./relayClient.ts"; @@ -26,7 +26,9 @@ export * from "./sourceControl.ts"; export * from "./pullRequest.ts"; export * from "./orchestration.ts"; export * from "./t3ProjectFile.ts"; +export * from "./devStack.ts"; export * from "./editor.ts"; +export * from "./openWith.ts"; export * from "./project.ts"; export * from "./filesystem.ts"; export * from "./agentSessions.ts"; @@ -37,6 +39,9 @@ export * from "./browserProfile.ts"; export * from "./device.ts"; export * from "./preview.ts"; export * from "./previewAutomation.ts"; +export * from "./aiUsage.ts"; +export * from "./hostResources.ts"; +export * from "./background.ts"; export * from "./resourceTelemetry.ts"; export * from "./usage.ts"; export * from "./rpc.ts"; diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts index cd906aecdfce..d1d0053c89c9 100644 --- a/packages/contracts/src/ipc.ts +++ b/packages/contracts/src/ipc.ts @@ -36,6 +36,20 @@ import type { ProjectWriteFileInput, ProjectWriteFileResult, } from "./project.ts"; +import type { ProviderInstanceId } from "./providerInstance.ts"; +import type { + ServerConfig, + ServerProcessDiagnosticsResult, + ServerProcessResourceHistoryInput, + ServerProcessResourceHistoryResult, + ServerProviderUpdateInput, + ServerProviderUpdatedPayload, + ServerRemoveKeybindingResult, + ServerSignalProcessInput, + ServerSignalProcessResult, + ServerTraceDiagnosticsResult, + ServerUpsertKeybindingResult, +} from "./server.ts"; import type { TerminalAttachInput, TerminalAttachStreamEvent, @@ -48,6 +62,7 @@ import type { TerminalSessionSnapshot, TerminalWriteInput, } from "./terminal.ts"; +import type { ServerRemoveKeybindingInput, ServerUpsertKeybindingInput } from "./server.ts"; import * as Schema from "effect/Schema"; import type { DiscoveredLocalServerList, @@ -97,12 +112,24 @@ import type { } from "./browserImport.ts"; import { AuthAccessTokenResult, AuthSessionState, AuthWebSocketTicketResult } from "./auth.ts"; import { AdvertisedEndpoint } from "./remoteAccess.ts"; +import { EditorId } from "./editor.ts"; +import type { + DesktopApplicationSelection, + DesktopOpenWithInput, + OpenWithEntryPresentation, +} from "./openWith.ts"; import { ExecutionEnvironmentDescriptor } from "./environment.ts"; -import { type ClientSettings, type QuitConfirmationMode, SnapShotShortcut } from "./settings.ts"; -import type { EditorId } from "./editor.ts"; +import { + type ClientSettings, + type QuitConfirmationMode, + type ServerSettings, + type ServerSettingsPatch, + SnapShotShortcut, +} from "./settings.ts"; import type { SourceControlCloneRepositoryInput, SourceControlCloneRepositoryResult, + SourceControlDiscoveryResult, SourceControlPublishRepositoryInput, SourceControlPublishRepositoryResult, SourceControlRepositoryInfo, @@ -1296,6 +1323,9 @@ export interface DesktopBridge { position?: { x: number; y: number }, ) => Promise; openExternal: (url: string) => Promise; + pickOpenWithApplication: () => Promise; + resolveOpenWithPresentations: () => Promise; + openWith: (input: DesktopOpenWithInput) => Promise; /** * Open a System Settings pane by identifier. Optional: older desktop builds * lack it, and callers no-op when it is missing. @@ -1437,7 +1467,7 @@ export interface ConfirmDialogOptions { * APIs bound to the local app shell, not to any particular backend environment. * * These capabilities describe the desktop/browser host that the user is - * currently running: dialogs, external-link opening, context menus, and + * currently running: dialogs, editor/external-link opening, context menus, and * app-level settings/config access. They must not be used as a proxy for * "whatever environment the user is targeting", because in a multi-environment * world the local shell and a selected backend environment are distinct @@ -1447,9 +1477,13 @@ export interface LocalApi { dialogs: { pickFolder: (options?: PickFolderOptions) => Promise; confirm: (message: string, options?: ConfirmDialogOptions) => Promise; + pickOpenWithApplication: () => Promise; }; shell: { + openInEditor: (cwd: string, editor: EditorId) => Promise; openExternal: (url: string) => Promise; + resolveOpenWithPresentations: () => Promise; + openWith: (input: DesktopOpenWithInput) => Promise; /** Opens a known System Settings pane; no-ops outside the desktop app. */ openSystemSettings: (pane: SystemSettingsPane) => Promise; }; @@ -1464,6 +1498,29 @@ export interface LocalApi { getClientSettings: () => Promise; setClientSettings: (settings: ClientSettings) => Promise; }; + server: { + getConfig: () => Promise; + /** + * Refresh provider snapshots. When `input.instanceId` is supplied only that + * configured instance is probed; otherwise every configured instance is + * refreshed (legacy untargeted refresh). + */ + refreshProviders: (input?: { + readonly instanceId?: ProviderInstanceId; + }) => Promise; + updateProvider: (input: ServerProviderUpdateInput) => Promise; + upsertKeybinding: (input: ServerUpsertKeybindingInput) => Promise; + removeKeybinding: (input: ServerRemoveKeybindingInput) => Promise; + getSettings: () => Promise; + updateSettings: (patch: ServerSettingsPatch) => Promise; + discoverSourceControl: () => Promise; + getTraceDiagnostics: () => Promise; + getProcessDiagnostics: () => Promise; + getProcessResourceHistory: ( + input: ServerProcessResourceHistoryInput, + ) => Promise; + signalProcess: (input: ServerSignalProcessInput) => Promise; + }; } /** diff --git a/packages/contracts/src/keybindings.ts b/packages/contracts/src/keybindings.ts index 2be8aa91f7aa..c61711ec18bf 100644 --- a/packages/contracts/src/keybindings.ts +++ b/packages/contracts/src/keybindings.ts @@ -73,6 +73,7 @@ export const STATIC_KEYBINDING_COMMANDS = [ "projectSearch.toggle", "themeEditor.toggle", "composer.stash", + "board.open", "chat.new", "chat.newLocal", "editor.openFavorite", diff --git a/packages/contracts/src/model.ts b/packages/contracts/src/model.ts index bce1a766bc9b..0bde8d97e7b5 100644 --- a/packages/contracts/src/model.ts +++ b/packages/contracts/src/model.ts @@ -147,10 +147,17 @@ const CODEX_DRIVER_KIND = ProviderDriverKind.make("codex"); const CLAUDE_DRIVER_KIND = ProviderDriverKind.make("claudeAgent"); const CURSOR_DRIVER_KIND = ProviderDriverKind.make("cursor"); const GROK_DRIVER_KIND = ProviderDriverKind.make("grok"); +const KIMI_DRIVER_KIND = ProviderDriverKind.make("kimi"); const OPENCODE_DRIVER_KIND = ProviderDriverKind.make("opencode"); export const DEFAULT_MODEL = "gpt-5.6-sol"; +/** + * Grok's default model. Grok Build held this slot from the original Grok + * integration; 4.6 is the frontier model Grok's own session default reports. + */ +export const GROK_DEFAULT_MODEL = "grok-4.6"; + /** * Codex default-model preference, most preferred first. The provider snapshot * marks the first of these present in the live `model/list` response as @@ -167,10 +174,10 @@ export const DEFAULT_TEXT_GENERATION_REASONING_EFFORT = "low"; export const DEFAULT_MODEL_BY_PROVIDER: Partial> = { [CODEX_DRIVER_KIND]: DEFAULT_MODEL, - [CLAUDE_DRIVER_KIND]: "claude-sonnet-5", + [CLAUDE_DRIVER_KIND]: "claude-opus-4-8", [CURSOR_DRIVER_KIND]: "auto", - // Product slug, not an ACP model id. The Grok adapter treats it as "the session's current model". - [GROK_DRIVER_KIND]: "grok-build", + [GROK_DRIVER_KIND]: GROK_DEFAULT_MODEL, + [KIMI_DRIVER_KIND]: "kimi-code/k3", [OPENCODE_DRIVER_KIND]: "openai/gpt-5", [ProviderDriverKind.make("antigravity")]: ANTIGRAVITY_DEFAULT_MODEL, }; @@ -183,6 +190,7 @@ export const DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER: Partial< [ProviderDriverKind.make("antigravity")]: ANTIGRAVITY_DEFAULT_MODEL, [CLAUDE_DRIVER_KIND]: "claude-haiku-4-5", [CURSOR_DRIVER_KIND]: "composer-2", + [KIMI_DRIVER_KIND]: "kimi-code/k3", [OPENCODE_DRIVER_KIND]: "openai/gpt-5", }; diff --git a/packages/contracts/src/openWith.test.ts b/packages/contracts/src/openWith.test.ts new file mode 100644 index 000000000000..afee2f74d783 --- /dev/null +++ b/packages/contracts/src/openWith.test.ts @@ -0,0 +1,77 @@ +import { describe, expect, it } from "vite-plus/test"; +import * as Schema from "effect/Schema"; + +import { + MAX_OPEN_WITH_ARGUMENTS, + OpenWithEntry, + OpenWithEntries, + OpenWithEntryRef, +} from "./openWith.ts"; + +const decodeEntry = Schema.decodeUnknownSync(OpenWithEntry); +const encodeEntry = Schema.encodeSync(OpenWithEntry); +const decodeEntries = Schema.decodeUnknownSync(OpenWithEntries); +const decodeEntryRef = Schema.decodeUnknownSync(OpenWithEntryRef); + +describe("Open With contracts", () => { + it("round-trips macOS application and command entries", () => { + const entries = [ + { + id: "terminal", + name: "Terminal", + kind: "terminal", + invocation: { type: "mac-application", applicationPath: "/Applications/Terminal.app" }, + directoryMode: "open-target", + arguments: [], + }, + { + id: "zed-cli", + name: "Zed CLI", + kind: "editor", + invocation: { type: "command", executable: "zed" }, + directoryMode: "custom-arguments", + arguments: ["--new", "{directory}"], + }, + ] as const; + + expect(entries.map((entry) => encodeEntry(decodeEntry(entry)))).toEqual(entries); + }); + + it("rejects malformed ids, empty names, excessive arguments, and invocation variants", () => { + const valid = { + id: "terminal", + name: "Terminal", + kind: "terminal", + invocation: { type: "command", executable: "open" }, + directoryMode: "open-target", + arguments: [], + }; + expect(() => decodeEntry({ ...valid, id: "Terminal App" })).toThrow(); + expect(() => decodeEntry({ ...valid, name: " " })).toThrow(); + expect(() => + decodeEntry({ + ...valid, + arguments: Array.from({ length: MAX_OPEN_WITH_ARGUMENTS + 1 }, () => "x"), + }), + ).toThrow(); + expect(() => + decodeEntry({ ...valid, invocation: { type: "shell", command: "open" } }), + ).toThrow(); + }); + + it("bounds the entry list and validates preference references", () => { + const entry = decodeEntry({ + id: "terminal", + name: "Terminal", + kind: "terminal", + invocation: { type: "command", executable: "open" }, + directoryMode: "open-target", + arguments: [], + }); + expect(() => decodeEntries(Array.from({ length: 65 }, () => entry))).toThrow(); + expect(decodeEntryRef({ type: "builtin", id: "vscode" })).toEqual({ + type: "builtin", + id: "vscode", + }); + }); +}); diff --git a/packages/contracts/src/openWith.ts b/packages/contracts/src/openWith.ts new file mode 100644 index 000000000000..03d497ca6e28 --- /dev/null +++ b/packages/contracts/src/openWith.ts @@ -0,0 +1,157 @@ +import * as Schema from "effect/Schema"; + +import { EnvironmentId, TrimmedNonEmptyString } from "./baseSchemas.ts"; +import { EditorId } from "./editor.ts"; + +export const MAX_OPEN_WITH_ENTRIES = 64; +export const MAX_OPEN_WITH_ARGUMENTS = 64; +export const MAX_OPEN_WITH_ID_LENGTH = 64; +export const MAX_OPEN_WITH_NAME_LENGTH = 120; +export const MAX_OPEN_WITH_PATH_LENGTH = 4_096; +export const MAX_OPEN_WITH_ARGUMENT_LENGTH = 4_096; + +export const OpenWithEntryId = TrimmedNonEmptyString.check( + Schema.isMaxLength(MAX_OPEN_WITH_ID_LENGTH), + Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/), +).pipe(Schema.brand("OpenWithEntryId")); +export type OpenWithEntryId = typeof OpenWithEntryId.Type; + +export const OpenWithEntryKind = Schema.Literals(["editor", "terminal", "file-manager", "other"]); +export type OpenWithEntryKind = typeof OpenWithEntryKind.Type; + +export const OpenWithDirectoryMode = Schema.Literals([ + "open-target", + "working-directory", + "custom-arguments", +]); +export type OpenWithDirectoryMode = typeof OpenWithDirectoryMode.Type; + +const OpenWithPath = TrimmedNonEmptyString.check(Schema.isMaxLength(MAX_OPEN_WITH_PATH_LENGTH)); +const OpenWithArgument = Schema.String.check(Schema.isMaxLength(MAX_OPEN_WITH_ARGUMENT_LENGTH)); + +export const OpenWithInvocation = Schema.Union([ + Schema.Struct({ + type: Schema.Literal("mac-application"), + applicationPath: OpenWithPath, + }), + Schema.Struct({ + type: Schema.Literal("command"), + executable: OpenWithPath, + }), +]); +export type OpenWithInvocation = typeof OpenWithInvocation.Type; + +export const OpenWithEntry = Schema.Struct({ + id: OpenWithEntryId, + name: TrimmedNonEmptyString.check(Schema.isMaxLength(MAX_OPEN_WITH_NAME_LENGTH)), + kind: OpenWithEntryKind, + invocation: OpenWithInvocation, + directoryMode: OpenWithDirectoryMode, + arguments: Schema.Array(OpenWithArgument).check(Schema.isMaxLength(MAX_OPEN_WITH_ARGUMENTS)), +}); +export type OpenWithEntry = typeof OpenWithEntry.Type; + +export const OpenWithEntries = Schema.Array(OpenWithEntry).check( + Schema.isMaxLength(MAX_OPEN_WITH_ENTRIES), +); + +export const OpenWithEntryRef = Schema.Union([ + Schema.Struct({ type: Schema.Literal("builtin"), id: EditorId }), + Schema.Struct({ type: Schema.Literal("custom"), id: OpenWithEntryId }), +]); +export type OpenWithEntryRef = typeof OpenWithEntryRef.Type; + +export const DesktopApplicationSelection = Schema.Struct({ + applicationPath: OpenWithPath, + suggestedName: TrimmedNonEmptyString.check(Schema.isMaxLength(MAX_OPEN_WITH_NAME_LENGTH)), + iconDataUrl: Schema.NullOr(Schema.String), +}); +export type DesktopApplicationSelection = typeof DesktopApplicationSelection.Type; + +export const OpenWithEntryPresentation = Schema.Struct({ + entryId: OpenWithEntryId, + available: Schema.Boolean, + iconDataUrl: Schema.NullOr(Schema.String), + unavailableReason: Schema.optionalKey(TrimmedNonEmptyString), +}); +export type OpenWithEntryPresentation = typeof OpenWithEntryPresentation.Type; + +export const DesktopOpenWithInput = Schema.Struct({ + environmentId: EnvironmentId, + entryId: OpenWithEntryId, + directory: OpenWithPath, +}); +export type DesktopOpenWithInput = typeof DesktopOpenWithInput.Type; + +export class OpenWithEnvironmentError extends Schema.TaggedError()( + "OpenWithEnvironmentError", + { environmentId: EnvironmentId }, +) { + override get message(): string { + return "Custom applications are only available in the primary desktop environment."; + } +} + +export class OpenWithMissingEntryError extends Schema.TaggedError()( + "OpenWithMissingEntryError", + { entryId: OpenWithEntryId }, +) { + override get message(): string { + return `The configured application '${this.entryId}' no longer exists.`; + } +} + +export const OpenWithInvalidTargetReason = Schema.Literals([ + "relative", + "missing", + "not-directory", +]); +export type OpenWithInvalidTargetReason = typeof OpenWithInvalidTargetReason.Type; + +export class OpenWithInvalidTargetError extends Schema.TaggedError()( + "OpenWithInvalidTargetError", + { directory: Schema.String, reason: OpenWithInvalidTargetReason }, +) { + override get message(): string { + return `Cannot open '${this.directory}' because it is ${ + this.reason === "relative" + ? "not an absolute path" + : this.reason === "missing" + ? "missing" + : "not a directory" + }.`; + } +} + +export class OpenWithUnavailableApplicationError extends Schema.TaggedError()( + "OpenWithUnavailableApplicationError", + { entryId: OpenWithEntryId, executable: Schema.String }, +) { + override get message(): string { + return `The application configured for '${this.entryId}' is unavailable: ${this.executable}`; + } +} + +export class OpenWithSpawnError extends Schema.TaggedError()( + "OpenWithSpawnError", + { + entryId: OpenWithEntryId, + command: Schema.String, + args: Schema.Array(Schema.String), + cwd: Schema.NullOr(Schema.String), + cause: Schema.Defect(), + }, +) { + override get message(): string { + return `Failed to launch '${this.entryId}' with '${this.command}'.`; + } +} + +export const OpenWithLaunchError = Schema.Union([ + OpenWithEnvironmentError, + OpenWithMissingEntryError, + OpenWithInvalidTargetError, + OpenWithUnavailableApplicationError, + OpenWithSpawnError, +]); +export type OpenWithLaunchError = typeof OpenWithLaunchError.Type; diff --git a/packages/contracts/src/orchestration.test.ts b/packages/contracts/src/orchestration.test.ts index b8c8358813d4..98867a1430bb 100644 --- a/packages/contracts/src/orchestration.test.ts +++ b/packages/contracts/src/orchestration.test.ts @@ -1146,11 +1146,13 @@ it.effect("accepts an internal title regeneration completion", () => threadId: "thread-1", requestId: "cmd-title-regenerate", title: "Updated title", + createdAt: "2026-01-01T00:00:00.000Z", }); assert.strictEqual(parsed.type, "thread.title.regeneration.complete"); if (parsed.type === "thread.title.regeneration.complete") { assert.strictEqual(parsed.requestId, "cmd-title-regenerate"); assert.strictEqual(parsed.title, "Updated title"); + assert.strictEqual(parsed.createdAt, "2026-01-01T00:00:00.000Z"); } }), ); diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts index 56a29b8f65f0..f5f267d633cb 100644 --- a/packages/contracts/src/orchestration.ts +++ b/packages/contracts/src/orchestration.ts @@ -23,6 +23,7 @@ import { TurnId, } from "./baseSchemas.ts"; import { ProviderInstanceId } from "./providerInstance.ts"; +import { ClientSourceHint, SourceRef, ThreadParticipantSummary } from "./identity.ts"; import { PullRequestActor, PullRequestChecksState, @@ -35,6 +36,7 @@ export const ORCHESTRATION_WS_METHODS = { dispatchCommand: "orchestration.dispatchCommand", getWorkflowScript: "orchestration.getWorkflowScript", getTurnDiff: "orchestration.getTurnDiff", + getThreadActivities: "orchestration.getThreadActivities", getFullThreadDiff: "orchestration.getFullThreadDiff", searchThreads: "orchestration.searchThreads", getArchivedShellSnapshot: "orchestration.getArchivedShellSnapshot", @@ -396,6 +398,17 @@ export const ProjectScript = Schema.Struct({ command: TrimmedNonEmptyString, icon: ProjectScriptIcon, runOnWorktreeCreate: Schema.Boolean, + /** + * When true, the script runs (and must exit 0) before a worktree is removed. + * Absent/undefined means false so older stored scripts keep decoding. + */ + runOnWorktreeRemove: Schema.optional(Schema.Boolean), + /** + * When true, the script runs when T3 observes the branch change request + * transition to merged (status poll), independent of worktree removal. + * Absent/undefined means false so older stored scripts keep decoding. + */ + runOnPrMerged: Schema.optional(Schema.Boolean), /** * URL to open in the in-app browser preview when this script runs (or * when the user explicitly requests a preview). Optional; only honored on @@ -490,6 +503,8 @@ export const OrchestrationMessage = Schema.Struct({ attachments: Schema.optional(Schema.Array(ChatAttachment)), turnId: Schema.NullOr(TurnId), streaming: Schema.Boolean, + /** Server-authored provenance; absent on legacy / assistant messages. */ + source: Schema.optional(SourceRef), createdAt: IsoDateTime, updatedAt: IsoDateTime, }); @@ -605,6 +620,23 @@ export const ThreadTitleRegeneration = Schema.Struct({ startedAt: IsoDateTime, }); export type ThreadTitleRegeneration = typeof ThreadTitleRegeneration.Type; +/** + * A follow-up message held server-side while a turn is running. Queued + * messages are not part of the thread timeline; they enter it via the + * normal `thread.message-sent` event when dispatched (auto-drain on turn + * completion, or an explicit `thread.queue.steer`). + */ +export const OrchestrationQueuedMessage = Schema.Struct({ + messageId: MessageId, + text: Schema.String, + attachments: Schema.Array(ChatAttachment), + modelSelection: Schema.optional(ModelSelection), + sourceProposedPlan: Schema.optional(SourceProposedPlanReference), + /** Server-stamped at enqueue; preserved when the queue drains to message-sent. */ + source: Schema.optional(SourceRef), + queuedAt: IsoDateTime, +}); +export type OrchestrationQueuedMessage = typeof OrchestrationQueuedMessage.Type; /** * Legacy single-PR link. Still emitted as the thread's derived current pull @@ -745,12 +777,35 @@ export const OrchestrationThread = Schema.Struct({ titleRegeneration: Schema.optional(Schema.NullOr(ThreadTitleRegeneration)), deletedAt: Schema.NullOr(IsoDateTime), messages: Schema.Array(OrchestrationMessage), + queuedMessages: Schema.Array(OrchestrationQueuedMessage).pipe( + Schema.withDecodingDefault(Effect.succeed([])), + ), + /** + * The turn start that was requested but not yet adopted by a provider + * session. Non-null between `thread.turn-start-requested` and the session + * reporting running (or a terminal status / start failure). While set, + * follow-up sends queue and drains hold — the session status alone cannot + * see this window. Read-model twin of the SQL pending-turn-start row. + */ + pendingTurnStart: Schema.NullOr( + Schema.Struct({ + messageId: MessageId, + requestedAt: IsoDateTime, + }), + ).pipe(Schema.withDecodingDefault(Effect.succeed(null))), proposedPlans: Schema.Array(OrchestrationProposedPlan).pipe( Schema.withDecodingDefault(Effect.succeed([])), ), activities: Schema.Array(OrchestrationThreadActivity), + // The detail snapshot windows `activities` to the most recent page; this is + // true when older activities exist beyond the window and can be lazy-loaded + // via the getThreadActivities RPC. Absent on lightweight (shell) threads. + hasMoreActivities: Schema.optional(Schema.Boolean), checkpoints: Schema.Array(OrchestrationCheckpointSummary), session: Schema.NullOr(OrchestrationSession), + originSource: Schema.optional(Schema.NullOr(SourceRef)), + // Optional without default so legacy fixtures omit the field; clients use ?? []. + participantSummaries: Schema.optional(Schema.Array(ThreadParticipantSummary)), }); export type OrchestrationThread = typeof OrchestrationThread.Type; @@ -816,6 +871,13 @@ export const OrchestrationThreadShell = Schema.Struct({ hasPendingApprovals: Schema.Boolean, hasPendingUserInput: Schema.Boolean, hasActionableProposedPlan: Schema.Boolean, + /** First user message SourceRef; null/absent on legacy threads. */ + originSource: Schema.optional(Schema.NullOr(SourceRef)), + /** + * Distinct people on user messages: origin person first, then first-participation order. + * Used for creator + +N participant stack. Absent on legacy shells (clients use ?? []). + */ + participantSummaries: Schema.optional(Schema.Array(ThreadParticipantSummary)), /** * Native background work alive after the turn settles: "working" while * subagents/workflows run, "monitoring" when watch loops are the only @@ -1191,6 +1253,9 @@ const ThreadTurnStartBootstrapPrepareWorktree = Schema.Struct({ baseBranch: TrimmedNonEmptyString, branch: Schema.optional(TrimmedNonEmptyString), startFromOrigin: Schema.optional(Schema.Boolean), + // Check out `baseBranch` in the worktree instead of creating a new branch + // from it. Wins over `branch`/`startFromOrigin` when set. + reuseBaseBranch: Schema.optional(Schema.Boolean), }); const ThreadTurnStartBootstrap = Schema.Struct({ @@ -1219,6 +1284,17 @@ export const ThreadTurnStartCommand = Schema.Struct({ ), bootstrap: Schema.optional(ThreadTurnStartBootstrap), sourceProposedPlan: Schema.optional(SourceProposedPlanReference), + /** + * Server-authored only. Gate layer stamps from session claim + deviceType + * or resolves platform actors from `sourceHint` (bots / integrations). + * Clients must not send trusted person fields. + */ + source: Schema.optional(SourceRef), + /** + * Non-person hints from trusted integrations (Discord bot, etc.). + * Server resolves personId via the identity map; never trusts client person fields. + */ + sourceHint: Schema.optional(ClientSourceHint), createdAt: IsoDateTime, }); @@ -1238,6 +1314,8 @@ const ClientThreadTurnStartCommand = Schema.Struct({ interactionMode: ProviderInteractionMode, bootstrap: Schema.optional(ThreadTurnStartBootstrap), sourceProposedPlan: Schema.optional(SourceProposedPlanReference), + /** Platform actor/location only — server stamps person from the identity map. */ + sourceHint: Schema.optional(ClientSourceHint), createdAt: IsoDateTime, }); @@ -1249,6 +1327,46 @@ const ThreadTurnInterruptCommand = Schema.Struct({ createdAt: IsoDateTime, }); +/** + * Request provider context compaction for a thread session. + * Adapters that support manual compact run it; others surface an unsupported error. + */ +const ThreadContextCompactCommand = Schema.Struct({ + type: Schema.Literal("thread.context.compact"), + commandId: CommandId, + threadId: ThreadId, + createdAt: IsoDateTime, +}); + +/** + * Send a queued message immediately, steering the active turn. Degrades to + * a normal turn start when the thread is idle by the time it is processed. + */ +const ThreadQueueSteerCommand = Schema.Struct({ + type: Schema.Literal("thread.queue.steer"), + commandId: CommandId, + threadId: ThreadId, + messageId: MessageId, + createdAt: IsoDateTime, +}); + +const ThreadQueueRemoveCommand = Schema.Struct({ + type: Schema.Literal("thread.queue.remove"), + commandId: CommandId, + threadId: ThreadId, + messageId: MessageId, + createdAt: IsoDateTime, +}); + +const ThreadQueueUpdateCommand = Schema.Struct({ + type: Schema.Literal("thread.queue.update"), + commandId: CommandId, + threadId: ThreadId, + messageId: MessageId, + text: Schema.String, + createdAt: IsoDateTime, +}); + const ThreadApprovalRespondCommand = Schema.Struct({ type: Schema.Literal("thread.approval.respond"), commandId: CommandId, @@ -1323,6 +1441,10 @@ const DispatchableClientOrchestrationCommand = Schema.Union([ ThreadInteractionModeSetCommand, ThreadTurnStartCommand, ThreadTurnInterruptCommand, + ThreadContextCompactCommand, + ThreadQueueSteerCommand, + ThreadQueueRemoveCommand, + ThreadQueueUpdateCommand, ThreadApprovalRespondCommand, ThreadUserInputRespondCommand, ThreadUserInputDismissCommand, @@ -1355,6 +1477,10 @@ export const ClientOrchestrationCommand = Schema.Union([ ThreadInteractionModeSetCommand, ClientThreadTurnStartCommand, ThreadTurnInterruptCommand, + ThreadContextCompactCommand, + ThreadQueueSteerCommand, + ThreadQueueRemoveCommand, + ThreadQueueUpdateCommand, ThreadApprovalRespondCommand, ThreadUserInputRespondCommand, ThreadUserInputDismissCommand, @@ -1434,6 +1560,18 @@ const ThreadActivityAppendCommand = Schema.Struct({ createdAt: IsoDateTime, }); +/** + * Server-internal: dispatch the queued-message head as a turn after a + * natural (non-interrupted) turn completion. Rejected when the queue is + * empty or the thread is busy again; the dispatcher ignores the rejection. + */ +const ThreadQueueDrainCommand = Schema.Struct({ + type: Schema.Literal("thread.queue.drain"), + commandId: CommandId, + threadId: ThreadId, + createdAt: IsoDateTime, +}); + const ThreadRevertCompleteCommand = Schema.Struct({ type: Schema.Literal("thread.revert.complete"), commandId: CommandId, @@ -1448,6 +1586,25 @@ const ThreadTitleRegenerationCompleteCommand = Schema.Struct({ threadId: ThreadId, requestId: CommandId, title: Schema.optional(TrimmedNonEmptyString), + createdAt: IsoDateTime, +}); + +/** + * Rebuild a thread's transcript tail from an authoritative external source. + * + * Server-internal: raised when T3 notices a provider's own session log has run + * ahead of the thread (the ACP stream dropped updates, or the session was driven + * from another client). See ThreadMessagesResyncedPayload for the rewind + * semantics. + */ +const ThreadMessagesResyncCommand = Schema.Struct({ + type: Schema.Literal("thread.messages.resync"), + commandId: CommandId, + threadId: ThreadId, + afterMessageId: Schema.NullOr(MessageId), + messages: Schema.Array(OrchestrationMessage), + reason: TrimmedNonEmptyString, + createdAt: IsoDateTime, }); const ThreadPullRequestSyncCommand = Schema.Struct({ @@ -1487,8 +1644,10 @@ const InternalOrchestrationCommand = Schema.Union([ ThreadProposedPlanUpsertCommand, ThreadTurnDiffCompleteCommand, ThreadActivityAppendCommand, + ThreadQueueDrainCommand, ThreadRevertCompleteCommand, ThreadTitleRegenerationCompleteCommand, + ThreadMessagesResyncCommand, ThreadPullRequestSyncCommand, ThreadPullRequestLinkSyncCommand, ]); @@ -1522,12 +1681,16 @@ export const OrchestrationEventType = Schema.Literals([ "thread.runtime-mode-set", "thread.interaction-mode-set", "thread.message-sent", + "thread.message-queued", + "thread.queued-message-removed", "thread.turn-start-requested", "thread.turn-interrupt-requested", + "thread.context-compact-requested", "thread.approval-response-requested", "thread.user-input-response-requested", "thread.checkpoint-revert-requested", "thread.reverted", + "thread.messages-resynced", "thread.session-stop-requested", "thread.session-set", "thread.proposed-plan-upserted", @@ -1721,10 +1884,34 @@ export const ThreadMessageSentPayload = Schema.Struct({ attachments: Schema.optional(Schema.Array(ChatAttachment)), turnId: Schema.NullOr(TurnId), streaming: Schema.Boolean, + /** Server-authored only; clients must not invent person fields. */ + source: Schema.optional(SourceRef), createdAt: IsoDateTime, updatedAt: IsoDateTime, }); +export const ThreadMessageQueuedPayload = Schema.Struct({ + threadId: ThreadId, + messageId: MessageId, + text: Schema.String, + attachments: Schema.Array(ChatAttachment), + modelSelection: Schema.optional(ModelSelection), + sourceProposedPlan: Schema.optional(SourceProposedPlanReference), + /** Server-stamped provenance for the queued user message. */ + source: Schema.optional(SourceRef), + queuedAt: IsoDateTime, +}); + +export const ThreadQueuedMessageRemovedReason = Schema.Literals(["user", "dispatched"]); +export type ThreadQueuedMessageRemovedReason = typeof ThreadQueuedMessageRemovedReason.Type; + +export const ThreadQueuedMessageRemovedPayload = Schema.Struct({ + threadId: ThreadId, + messageId: MessageId, + reason: ThreadQueuedMessageRemovedReason, + removedAt: IsoDateTime, +}); + export const ThreadTurnStartRequestedPayload = Schema.Struct({ threadId: ThreadId, messageId: MessageId, @@ -1744,6 +1931,11 @@ export const ThreadTurnInterruptRequestedPayload = Schema.Struct({ createdAt: IsoDateTime, }); +export const ThreadContextCompactRequestedPayload = Schema.Struct({ + threadId: ThreadId, + createdAt: IsoDateTime, +}); + export const ThreadApprovalResponseRequestedPayload = Schema.Struct({ threadId: ThreadId, requestId: ApprovalRequestId, @@ -1770,6 +1962,28 @@ export const ThreadRevertedPayload = Schema.Struct({ turnCount: NonNegativeInt, }); +/** + * A thread's transcript was rebuilt from an authoritative external source (e.g. + * a grok session backfill after the ACP stream dropped updates). + * + * Out-of-band writes straight to the projection are invisible to clients: a + * warm-cache client resumes from `afterSequence` and only ever receives events + * past that cursor. This event is what makes such a rebuild observable — it + * lands past every client's cursor, so the existing catch-up replay delivers it. + * + * It carries a rewind point rather than a whole snapshot: everything up to and + * including `afterMessageId` is known-good and untouched; only the tail after it + * is replaced by `messages`. `afterMessageId: null` replaces the whole + * transcript. A client that does not hold `afterMessageId` cannot rewind + * precisely and must reload the thread instead. + */ +export const ThreadMessagesResyncedPayload = Schema.Struct({ + threadId: ThreadId, + afterMessageId: Schema.NullOr(MessageId), + messages: Schema.Array(OrchestrationMessage), + reason: TrimmedNonEmptyString, +}); + export const ThreadSessionStopRequestedPayload = Schema.Struct({ threadId: ThreadId, createdAt: IsoDateTime, @@ -1942,6 +2156,16 @@ export const OrchestrationEvent = Schema.Union([ type: Schema.Literal("thread.message-sent"), payload: ThreadMessageSentPayload, }), + Schema.Struct({ + ...EventBaseFields, + type: Schema.Literal("thread.message-queued"), + payload: ThreadMessageQueuedPayload, + }), + Schema.Struct({ + ...EventBaseFields, + type: Schema.Literal("thread.queued-message-removed"), + payload: ThreadQueuedMessageRemovedPayload, + }), Schema.Struct({ ...EventBaseFields, type: Schema.Literal("thread.turn-start-requested"), @@ -1952,6 +2176,11 @@ export const OrchestrationEvent = Schema.Union([ type: Schema.Literal("thread.turn-interrupt-requested"), payload: ThreadTurnInterruptRequestedPayload, }), + Schema.Struct({ + ...EventBaseFields, + type: Schema.Literal("thread.context-compact-requested"), + payload: ThreadContextCompactRequestedPayload, + }), Schema.Struct({ ...EventBaseFields, type: Schema.Literal("thread.approval-response-requested"), @@ -1972,6 +2201,11 @@ export const OrchestrationEvent = Schema.Union([ type: Schema.Literal("thread.reverted"), payload: ThreadRevertedPayload, }), + Schema.Struct({ + ...EventBaseFields, + type: Schema.Literal("thread.messages-resynced"), + payload: ThreadMessagesResyncedPayload, + }), Schema.Struct({ ...EventBaseFields, type: Schema.Literal("thread.session-stop-requested"), @@ -2091,6 +2325,37 @@ export type OrchestrationGetTurnDiffInput = typeof OrchestrationGetTurnDiffInput export const OrchestrationGetTurnDiffResult = ThreadTurnDiff; export type OrchestrationGetTurnDiffResult = typeof OrchestrationGetTurnDiffResult.Type; +/** + * Cursor-paginated load of a thread's OLDER activities (lazy-load / infinite + * scroll). Sequenced activity uses `beforeSequence`, the `sequence` of the + * oldest activity the client currently holds. Legacy unsequenced activity uses + * the `(beforeCreatedAt, beforeActivityId)` pair from the oldest loaded + * activity. The server returns the page of activities immediately older than the + * cursor (chronological ascending) plus whether any remain beyond that. + */ +export const OrchestrationGetThreadActivitiesInput = Schema.Union([ + Schema.Struct({ + threadId: ThreadId, + beforeSequence: NonNegativeInt, + limit: Schema.optional(NonNegativeInt), + }), + Schema.Struct({ + threadId: ThreadId, + beforeCreatedAt: IsoDateTime, + beforeActivityId: EventId, + limit: Schema.optional(NonNegativeInt), + }), +]); +export type OrchestrationGetThreadActivitiesInput = + typeof OrchestrationGetThreadActivitiesInput.Type; + +export const OrchestrationGetThreadActivitiesResult = Schema.Struct({ + activities: Schema.Array(OrchestrationThreadActivity), + hasMore: Schema.Boolean, +}); +export type OrchestrationGetThreadActivitiesResult = + typeof OrchestrationGetThreadActivitiesResult.Type; + export const OrchestrationGetFullThreadDiffInput = Schema.Struct({ threadId: ThreadId, toTurnCount: NonNegativeInt, @@ -2187,6 +2452,10 @@ export const OrchestrationRpcSchemas = { input: OrchestrationGetTurnDiffInput, output: OrchestrationGetTurnDiffResult, }, + getThreadActivities: { + input: OrchestrationGetThreadActivitiesInput, + output: OrchestrationGetThreadActivitiesResult, + }, getFullThreadDiff: { input: OrchestrationGetFullThreadDiffInput, output: OrchestrationGetFullThreadDiffResult, @@ -2209,11 +2478,26 @@ export const OrchestrationRpcSchemas = { }, } as const; +/** + * Why a thread snapshot could not be produced. Lets subscribers distinguish a + * permanently unavailable thread ("thread-deleted"/"thread-archived" — stop + * retrying) from a potentially transient miss ("thread-missing" — the + * projection row may simply not be written yet, so retrying is correct). + */ +export const OrchestrationSnapshotUnavailableReason = Schema.Literals([ + "thread-deleted", + "thread-archived", + "thread-missing", +]); +export type OrchestrationSnapshotUnavailableReason = + typeof OrchestrationSnapshotUnavailableReason.Type; + export class OrchestrationGetSnapshotError extends Schema.TaggedError()( "OrchestrationGetSnapshotError", { message: TrimmedNonEmptyString, cause: Schema.optional(Schema.Defect()), + reason: Schema.optional(OrchestrationSnapshotUnavailableReason), }, ) {} @@ -2221,6 +2505,8 @@ export class OrchestrationDispatchCommandError extends Schema.TaggedError()( + "OrchestrationGetThreadActivitiesError", + { + message: TrimmedNonEmptyString, + cause: Schema.optional(Schema.Defect()), + }, +) {} + export class OrchestrationGetFullThreadDiffError extends Schema.TaggedError()( "OrchestrationGetFullThreadDiffError", { diff --git a/packages/contracts/src/preview.ts b/packages/contracts/src/preview.ts index 6e4154301a19..f6cdf6d14e13 100644 --- a/packages/contracts/src/preview.ts +++ b/packages/contracts/src/preview.ts @@ -323,6 +323,71 @@ export const DiscoveredLocalServerList = Schema.Struct({ }); export type DiscoveredLocalServerList = typeof DiscoveredLocalServerList.Type; +export const PreviewPortResolveRequest = Schema.Struct({ + port: Schema.Int.check(Schema.isGreaterThan(0)).check(Schema.isLessThan(65536)), + /** + * The environment base URL this client is actually connected through. + * + * Reachability is a property of the pair (client, port), not of the port + * alone: a client on loopback wants `localhost`, one on the tailnet needs a + * tailnet route. The client is the only side that knows which it is, so it + * says so rather than letting the server infer it from a request header that + * a proxy may have rewritten. + */ + clientBaseUrl: Url, +}); +export type PreviewPortResolveRequest = typeof PreviewPortResolveRequest.Type; + +export const PreviewPortExposureStrategy = Schema.Literals([ + "loopback", + /** + * The port already answers on the environment's own address — a dev server + * bound to a wildcard or interface address, reached over WSL, a LAN, or an + * existing tunnel. Nothing is published for these. + */ + "direct-private-network", + "tailnet-serve", +]); +export type PreviewPortExposureStrategy = typeof PreviewPortExposureStrategy.Type; + +export const PreviewPortResolution = Schema.Struct({ + /** Origin only — the caller keeps its own path, query, and hash. */ + origin: Url, + strategy: PreviewPortExposureStrategy, + /** True when this call created the tailnet mapping rather than reusing one. */ + createdExposure: Schema.Boolean, +}); +export type PreviewPortResolution = typeof PreviewPortResolution.Type; + +/** + * Why a local port cannot be reached from this client. + * + * Carries a `remedy` because the consumer is frequently an agent driving the + * preview: without a next action it retries the same unreachable URL. The + * reasons are a closed set so the UI can special-case them, and `remedy` never + * quotes raw CLI stderr (tailscale prints auth keys there). + */ +export class PreviewPortUnreachableError extends Schema.TaggedError()( + "PreviewPortUnreachableError", + { + port: Schema.Int, + reason: Schema.Literals([ + "tailscale-unavailable", + "tailscale-not-logged-in", + "tailscale-permission-denied", + "serve-port-conflict", + "exposure-failed", + "not-listening", + "not-reachable", + ]), + remedy: TrimmedNonEmptyString, + }, +) { + override get message() { + return `Port ${this.port} is not reachable from this client (${this.reason}). ${this.remedy}`; + } +} + export class PreviewSessionLookupError extends Schema.TaggedError()( "PreviewSessionLookupError", { diff --git a/packages/contracts/src/previewAutomation.ts b/packages/contracts/src/previewAutomation.ts index 59387fdacfd9..8346dfd71234 100644 --- a/packages/contracts/src/previewAutomation.ts +++ b/packages/contracts/src/previewAutomation.ts @@ -542,6 +542,7 @@ export const PreviewAutomationSnapshot = Schema.Struct({ data: Schema.String, width: Schema.Int, height: Schema.Int, + path: Schema.optional(Schema.String), }), }); export type PreviewAutomationSnapshot = typeof PreviewAutomationSnapshot.Type; @@ -590,6 +591,7 @@ export const PreviewAutomationHostFocus = Schema.Struct({ ...PreviewAutomationHostIdentity.fields, connectionId: PreviewAutomationConnectionId, focused: Schema.Boolean, + threadId: Schema.optional(ThreadId), }); export type PreviewAutomationHostFocus = typeof PreviewAutomationHostFocus.Type; diff --git a/packages/contracts/src/project.ts b/packages/contracts/src/project.ts index bee2e70d5746..c7ecee0ad39c 100644 --- a/packages/contracts/src/project.ts +++ b/packages/contracts/src/project.ts @@ -207,6 +207,11 @@ export const ProjectReadFileResult = Schema.Struct({ }); export type ProjectReadFileResult = typeof ProjectReadFileResult.Type; +export const ProjectFileChangeEvent = Schema.Struct({ + relativePath: TrimmedNonEmptyString, +}); +export type ProjectFileChangeEvent = typeof ProjectFileChangeEvent.Type; + export const ProjectFileFailure = Schema.Literals([ "workspace_path_outside_root", "resolved_path_outside_root", @@ -219,10 +224,12 @@ export type ProjectFileFailure = typeof ProjectFileFailure.Type; export const ProjectFileOperation = Schema.Literals([ "realpath-workspace-root", "realpath-target", + "realpath-watch-directory", "open", "stat", "read", "close", + "watch", "make-directory", "write-file", ]); diff --git a/packages/contracts/src/provider.ts b/packages/contracts/src/provider.ts index df91839e8520..040181283331 100644 --- a/packages/contracts/src/provider.ts +++ b/packages/contracts/src/provider.ts @@ -95,6 +95,11 @@ export const ProviderInterruptTurnInput = Schema.Struct({ }); export type ProviderInterruptTurnInput = typeof ProviderInterruptTurnInput.Type; +export const ProviderCompactSessionInput = Schema.Struct({ + threadId: ThreadId, +}); +export type ProviderCompactSessionInput = typeof ProviderCompactSessionInput.Type; + export const ProviderStopSessionInput = Schema.Struct({ threadId: ThreadId, }); diff --git a/packages/contracts/src/providerRuntime.ts b/packages/contracts/src/providerRuntime.ts index af1baac74f9d..0ebf324ffb32 100644 --- a/packages/contracts/src/providerRuntime.ts +++ b/packages/contracts/src/providerRuntime.ts @@ -152,6 +152,7 @@ const ProviderRuntimeEventType = Schema.Literals([ "session.started", "session.configured", "session.state.changed", + "session.mode.changed", "session.exited", "thread.started", "thread.state.changed", @@ -204,6 +205,7 @@ export type ProviderRuntimeEventType = typeof ProviderRuntimeEventType.Type; const SessionStartedType = Schema.Literal("session.started"); const SessionConfiguredType = Schema.Literal("session.configured"); const SessionStateChangedType = Schema.Literal("session.state.changed"); +const SessionModeChangedType = Schema.Literal("session.mode.changed"); const SessionExitedType = Schema.Literal("session.exited"); const ThreadStartedType = Schema.Literal("thread.started"); const ThreadStateChangedType = Schema.Literal("thread.state.changed"); @@ -286,6 +288,13 @@ const SessionStateChangedPayload = Schema.Struct({ }); export type SessionStateChangedPayload = typeof SessionStateChangedPayload.Type; +const SessionModeChangedPayload = Schema.Struct({ + modeId: TrimmedNonEmptyStringSchema, + /** App-level interaction mode inferred from the provider session mode. */ + interactionMode: Schema.Literals(["default", "plan"]), +}); +export type SessionModeChangedPayload = typeof SessionModeChangedPayload.Type; + const SessionExitedPayload = Schema.Struct({ reason: Schema.optional(TrimmedNonEmptyStringSchema), recoverable: Schema.optional(Schema.Boolean), @@ -889,6 +898,14 @@ const ProviderRuntimeSessionStateChangedEvent = Schema.Struct({ export type ProviderRuntimeSessionStateChangedEvent = typeof ProviderRuntimeSessionStateChangedEvent.Type; +const ProviderRuntimeSessionModeChangedEvent = Schema.Struct({ + ...ProviderRuntimeEventBase.fields, + type: SessionModeChangedType, + payload: SessionModeChangedPayload, +}); +export type ProviderRuntimeSessionModeChangedEvent = + typeof ProviderRuntimeSessionModeChangedEvent.Type; + const ProviderRuntimeSessionExitedEvent = Schema.Struct({ ...ProviderRuntimeEventBase.fields, type: SessionExitedType, @@ -1230,6 +1247,7 @@ export const ProviderRuntimeEventV2 = Schema.Union([ ProviderRuntimeSessionStartedEvent, ProviderRuntimeSessionConfiguredEvent, ProviderRuntimeSessionStateChangedEvent, + ProviderRuntimeSessionModeChangedEvent, ProviderRuntimeSessionExitedEvent, ProviderRuntimeThreadStartedEvent, ProviderRuntimeThreadStateChangedEvent, diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts index 5e11aeb28fa3..5f358050f79e 100644 --- a/packages/contracts/src/rpc.ts +++ b/packages/contracts/src/rpc.ts @@ -18,6 +18,13 @@ import { AuthAccessStreamEvent, EnvironmentAuthorizationError, } from "./auth.ts"; +import { + IdentityClaimInput, + IdentityClaimResult, + IdentityError, + IdentitySessionClaimResult, + IdentitySnapshot, +} from "./identity.ts"; import { BackgroundPolicySnapshot, ClientActivityReportInput, @@ -70,6 +77,13 @@ import { VcsStatusInput, VcsStatusResult, VcsStatusStreamEvent, + VcsResolveBranchChangeRequestInput, + VcsResolveBranchChangeRequestResult, + WorktreeCleanupInput, + WorktreeCleanupPreviewInput, + WorktreeCleanupPreviewResult, + WorktreeCleanupResult, + WorktreeLifecycleError, } from "./git.ts"; import { ReviewDiffFileContentsInput, @@ -78,7 +92,9 @@ import { ReviewDiffPreviewInput, ReviewDiffPreviewResult, } from "./review.ts"; +import { AiUsageSnapshot } from "./aiUsage.ts"; import { KeybindingsConfigError } from "./keybindings.ts"; +import { ServerHostResourceSnapshot } from "./hostResources.ts"; import { ClientOrchestrationCommand, ORCHESTRATION_WS_METHODS, @@ -88,6 +104,8 @@ import { OrchestrationGetSnapshotError, OrchestrationSearchThreadsError, OrchestrationSearchThreadsInput, + OrchestrationGetThreadActivitiesError, + OrchestrationGetThreadActivitiesInput, OrchestrationGetTurnDiffError, OrchestrationGetTurnDiffInput, OrchestrationRpcSchemas, @@ -139,6 +157,7 @@ import { ProjectListEntriesError, ProjectListEntriesInput, ProjectListEntriesResult, + ProjectFileChangeEvent, ProjectReadFileError, ProjectReadFileInput, ProjectReadFileResult, @@ -180,6 +199,9 @@ import { PreviewReportStatusInput, PreviewResizeInput, PreviewSessionSnapshot, + PreviewPortResolveRequest, + PreviewPortResolution, + PreviewPortUnreachableError, } from "./preview.ts"; import { DeviceActionInput, @@ -260,6 +282,7 @@ export const WS_METHODS = { projectsListEntries: "projects.listEntries", projectsReadFile: "projects.readFile", projectsSearchContents: "projects.searchContents", + projectsWatchFile: "projects.watchFile", projectsSearchEntries: "projects.searchEntries", projectsWriteFile: "projects.writeFile", @@ -367,6 +390,11 @@ export const WS_METHODS = { cloudGetRelayClientStatus: "cloud.getRelayClientStatus", cloudInstallRelayClient: "cloud.installRelayClient", + // Session identity (closed-set map claim) + identityGetSnapshot: "identity.getSnapshot", + identityGetSessionClaim: "identity.getSessionClaim", + identityClaim: "identity.claim", + identityClearClaim: "identity.clearClaim", // Pull request methods pullRequestsList: "pullRequests.list", pullRequestsListStats: "pullRequests.listStats", @@ -409,6 +437,13 @@ export const WS_METHODS = { subscribeAuthAccess: "subscribeAuthAccess", subscribeBackgroundPolicy: "subscribeBackgroundPolicy", subscribeResourceTelemetry: "subscribeResourceTelemetry", + // Fork-only methods + vcsResolveBranchChangeRequest: "vcs.resolveBranchChangeRequest", + vcsPreviewWorktreeCleanup: "vcs.previewWorktreeCleanup", + vcsCleanupThreadWorktree: "vcs.cleanupThreadWorktree", + previewResolvePort: "preview.resolvePort", + serverGetHostResourceSnapshot: "server.getHostResourceSnapshot", + subscribeAiUsage: "subscribeAiUsage", } as const; const WsServerUpsertKeybindingRpc = Rpc.make(WS_METHODS.serverUpsertKeybinding, { @@ -577,6 +612,15 @@ const WsServerGetHostResourcesRpc = Rpc.make(WS_METHODS.serverGetHostResources, error: EnvironmentAuthorizationError, }); +export const WsServerGetHostResourceSnapshotRpc = Rpc.make( + WS_METHODS.serverGetHostResourceSnapshot, + { + payload: Schema.Struct({}), + success: ServerHostResourceSnapshot, + error: EnvironmentAuthorizationError, + }, +); + const WsServerGetProcessResourceHistoryRpc = Rpc.make(WS_METHODS.serverGetProcessResourceHistory, { payload: ServerProcessResourceHistoryInput, success: ServerProcessResourceHistoryResult, @@ -633,6 +677,30 @@ const WsCloudInstallRelayClientRpc = Rpc.make(WS_METHODS.cloudInstallRelayClient stream: true, }); +export const WsIdentityGetSnapshotRpc = Rpc.make(WS_METHODS.identityGetSnapshot, { + payload: Schema.Struct({}), + success: IdentitySnapshot, + error: Schema.Union([IdentityError, EnvironmentAuthorizationError]), +}); + +export const WsIdentityGetSessionClaimRpc = Rpc.make(WS_METHODS.identityGetSessionClaim, { + payload: Schema.Struct({}), + success: IdentitySessionClaimResult, + error: Schema.Union([IdentityError, EnvironmentAuthorizationError]), +}); + +export const WsIdentityClaimRpc = Rpc.make(WS_METHODS.identityClaim, { + payload: IdentityClaimInput, + success: IdentityClaimResult, + error: Schema.Union([IdentityError, EnvironmentAuthorizationError]), +}); + +export const WsIdentityClearClaimRpc = Rpc.make(WS_METHODS.identityClearClaim, { + payload: Schema.Struct({}), + success: Schema.Struct({ cleared: Schema.Boolean }), + error: Schema.Union([IdentityError, EnvironmentAuthorizationError]), +}); + const WsServerReportClientActivityRpc = Rpc.make(WS_METHODS.serverReportClientActivity, { payload: ClientActivityReportInput, error: EnvironmentAuthorizationError, @@ -847,6 +915,13 @@ const WsProjectsReadFileRpc = Rpc.make(WS_METHODS.projectsReadFile, { error: Schema.Union([ProjectReadFileError, EnvironmentAuthorizationError]), }); +export const WsProjectsWatchFileRpc = Rpc.make(WS_METHODS.projectsWatchFile, { + payload: ProjectReadFileInput, + success: ProjectFileChangeEvent, + error: Schema.Union([ProjectReadFileError, EnvironmentAuthorizationError]), + stream: true, +}); + const WsProjectsWriteFileRpc = Rpc.make(WS_METHODS.projectsWriteFile, { payload: ProjectWriteFileInput, success: ProjectWriteFileResult, @@ -959,6 +1034,27 @@ const WsVcsRemoveWorktreeRpc = Rpc.make(WS_METHODS.vcsRemoveWorktree, { error: Schema.Union([GitCommandError, EnvironmentAuthorizationError]), }); +export const WsVcsResolveBranchChangeRequestRpc = Rpc.make( + WS_METHODS.vcsResolveBranchChangeRequest, + { + payload: VcsResolveBranchChangeRequestInput, + success: VcsResolveBranchChangeRequestResult, + error: Schema.Union([GitManagerServiceError, EnvironmentAuthorizationError]), + }, +); + +export const WsVcsPreviewWorktreeCleanupRpc = Rpc.make(WS_METHODS.vcsPreviewWorktreeCleanup, { + payload: WorktreeCleanupPreviewInput, + success: WorktreeCleanupPreviewResult, + error: Schema.Union([WorktreeLifecycleError, EnvironmentAuthorizationError]), +}); + +export const WsVcsCleanupThreadWorktreeRpc = Rpc.make(WS_METHODS.vcsCleanupThreadWorktree, { + payload: WorktreeCleanupInput, + success: WorktreeCleanupResult, + error: Schema.Union([WorktreeLifecycleError, EnvironmentAuthorizationError]), +}); + const WsVcsCreateRefRpc = Rpc.make(WS_METHODS.vcsCreateRef, { payload: VcsCreateRefInput, success: VcsCreateRefResult, @@ -1071,6 +1167,12 @@ const WsPreviewReportStatusRpc = Rpc.make(WS_METHODS.previewReportStatus, { error: Schema.Union([PreviewError, EnvironmentAuthorizationError]), }); +export const WsPreviewResolvePortRpc = Rpc.make(WS_METHODS.previewResolvePort, { + payload: PreviewPortResolveRequest, + success: PreviewPortResolution, + error: Schema.Union([PreviewPortUnreachableError, EnvironmentAuthorizationError]), +}); + const WsPreviewAutomationConnectRpc = Rpc.make(WS_METHODS.previewAutomationConnect, { payload: PreviewAutomationHost, success: PreviewAutomationStreamEvent, @@ -1175,6 +1277,15 @@ const WsOrchestrationGetTurnDiffRpc = Rpc.make(ORCHESTRATION_WS_METHODS.getTurnD error: Schema.Union([OrchestrationGetTurnDiffError, EnvironmentAuthorizationError]), }); +export const WsOrchestrationGetThreadActivitiesRpc = Rpc.make( + ORCHESTRATION_WS_METHODS.getThreadActivities, + { + payload: OrchestrationGetThreadActivitiesInput, + success: OrchestrationRpcSchemas.getThreadActivities.output, + error: Schema.Union([OrchestrationGetThreadActivitiesError, EnvironmentAuthorizationError]), + }, +); + const WsOrchestrationGetFullThreadDiffRpc = Rpc.make(ORCHESTRATION_WS_METHODS.getFullThreadDiff, { payload: OrchestrationGetFullThreadDiffInput, success: OrchestrationRpcSchemas.getFullThreadDiff.output, @@ -1262,6 +1373,13 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, { stream: true, }); +export const WsSubscribeAiUsageRpc = Rpc.make(WS_METHODS.subscribeAiUsage, { + payload: Schema.Struct({}), + success: AiUsageSnapshot, + error: EnvironmentAuthorizationError, + stream: true, +}); + const WsSubscribeBackgroundPolicyRpc = Rpc.make(WS_METHODS.subscribeBackgroundPolicy, { payload: Schema.Struct({}), success: BackgroundPolicySnapshot, @@ -1303,6 +1421,7 @@ export const WsRpcGroup = RpcGroup.make( WsServerGetProcessDiagnosticsRpc, WsServerGetHostResourcesRpc, WsServerGetProcessResourceHistoryRpc, + WsServerGetHostResourceSnapshotRpc, WsServerGetResourceTelemetryHistoryRpc, WsServerRetryResourceTelemetryRpc, WsServerGetUsageSummaryRpc, @@ -1313,6 +1432,10 @@ export const WsRpcGroup = RpcGroup.make( WsServerGetBackgroundPolicyRpc, WsCloudGetRelayClientStatusRpc, WsCloudInstallRelayClientRpc, + WsIdentityGetSnapshotRpc, + WsIdentityGetSessionClaimRpc, + WsIdentityClaimRpc, + WsIdentityClearClaimRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsSummaryRpc, @@ -1342,6 +1465,7 @@ export const WsRpcGroup = RpcGroup.make( WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchContentsRpc, + WsProjectsWatchFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, @@ -1361,6 +1485,9 @@ export const WsRpcGroup = RpcGroup.make( WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, + WsVcsResolveBranchChangeRequestRpc, + WsVcsPreviewWorktreeCleanupRpc, + WsVcsCleanupThreadWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, @@ -1382,6 +1509,7 @@ export const WsRpcGroup = RpcGroup.make( WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, + WsPreviewResolvePortRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, @@ -1399,11 +1527,13 @@ export const WsRpcGroup = RpcGroup.make( WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, + WsSubscribeAiUsageRpc, WsSubscribeBackgroundPolicyRpc, WsSubscribeResourceTelemetryRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetWorkflowScriptRpc, WsOrchestrationGetTurnDiffRpc, + WsOrchestrationGetThreadActivitiesRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationSearchThreadsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts index c2fc8524ece2..998e5ec8eb3b 100644 --- a/packages/contracts/src/server.ts +++ b/packages/contracts/src/server.ts @@ -775,9 +775,27 @@ export const ServerLifecycleStreamReadyEvent = Schema.Struct({ }); export type ServerLifecycleStreamReadyEvent = typeof ServerLifecycleStreamReadyEvent.Type; +export const ServerLifecycleWebVersionPayload = Schema.Struct({ + // Identity of the served web bundle (a hash of index.html). Clients compare + // the value they booted with against later broadcasts to detect that the + // server's static assets were hot-swapped underneath them. + webVersion: TrimmedNonEmptyString, +}); +export type ServerLifecycleWebVersionPayload = typeof ServerLifecycleWebVersionPayload.Type; + +export const ServerLifecycleStreamWebVersionChangedEvent = Schema.Struct({ + version: Schema.Literal(1), + sequence: NonNegativeInt, + type: Schema.Literal("webVersionChanged"), + payload: ServerLifecycleWebVersionPayload, +}); +export type ServerLifecycleStreamWebVersionChangedEvent = + typeof ServerLifecycleStreamWebVersionChangedEvent.Type; + export const ServerLifecycleStreamEvent = Schema.Union([ ServerLifecycleStreamWelcomeEvent, ServerLifecycleStreamReadyEvent, + ServerLifecycleStreamWebVersionChangedEvent, ]); export type ServerLifecycleStreamEvent = typeof ServerLifecycleStreamEvent.Type; @@ -804,7 +822,6 @@ export class ServerProviderUpdateError extends Schema.TaggedError { }); describe("ClientSettings word wrap", () => { + it("defaults Open With settings for legacy documents", () => { + const settings = decodeClientSettings({}); + expect(settings.openWithEntries).toEqual([]); + expect(settings.preferredOpenWith).toBeNull(); + }); + it("defaults word wrap on", () => { expect(decodeClientSettings({}).wordWrap).toBe(true); }); @@ -184,6 +190,18 @@ describe("ClientSettings word wrap", () => { }); }); +describe("ClientSettings sidebarHideProviderIcons", () => { + it("defaults to false", () => { + expect(decodeClientSettings({}).sidebarHideProviderIcons).toBe(false); + }); + + it("round-trips an explicit value", () => { + expect(decodeClientSettings({ sidebarHideProviderIcons: true }).sidebarHideProviderIcons).toBe( + true, + ); + }); +}); + describe("ClientSettings window capture", () => { it("defaults capture off while keeping its feedback enabled", () => { const settings = decodeClientSettings({}); @@ -277,6 +295,18 @@ describe("ClientSettings proactive panels", () => { }); }); +describe("ClientSettings worktree removal confirmation", () => { + it("defaults confirmation on for existing settings", () => { + expect(decodeClientSettings({}).confirmWorktreeRemoval).toBe(true); + }); + + it("accepts confirmation updates", () => { + expect( + decodeClientSettingsPatch({ confirmWorktreeRemoval: false }).confirmWorktreeRemoval, + ).toBe(false); + }); +}); + describe("ClientSettings quit confirmation", () => { it("defaults to hold", () => { expect(decodeClientSettings({}).confirmQuit).toBe("hold"); @@ -389,8 +419,10 @@ describe("ClientSettings environment identification", () => { }); describe("ClientSettings sidebar", () => { - it("defaults to the current sidebar", () => { - expect(decodeClientSettings({}).legacySidebarEnabled).toBe(false); + it("defaults to the current sidebar with recent threads enabled", () => { + const settings = decodeClientSettings({}); + expect(settings.legacySidebarEnabled).toBe(false); + expect(settings.sidebarRecentThreadsEnabled).toBe(true); }); it("drops the retired sidebar v2 beta keys, resetting everyone to the default", () => { @@ -410,6 +442,12 @@ describe("ClientSettings sidebar", () => { ); }); + it("allows the recent work queue to be disabled", () => { + expect( + decodeClientSettings({ sidebarRecentThreadsEnabled: false }).sidebarRecentThreadsEnabled, + ).toBe(false); + }); + it("keeps unpin confirmation opt-in and patchable", () => { expect(decodeClientSettings({}).confirmThreadUnpin).toBe(false); expect(decodeClientSettingsPatch({ confirmThreadUnpin: true }).confirmThreadUnpin).toBe(true); @@ -607,6 +645,10 @@ describe("provider enabled defaults", () => { }); describe("ServerSettings worktree defaults", () => { + it("defaults new threads to worktree mode", () => { + expect(decodeServerSettings({}).defaultThreadEnvMode).toBe("worktree"); + }); + it("defaults start-from-origin on for legacy configs", () => { expect(decodeServerSettings({}).newWorktreesStartFromOrigin).toBe(true); }); diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts index dd6136461fc1..bff8ee1ac3ff 100644 --- a/packages/contracts/src/settings.ts +++ b/packages/contracts/src/settings.ts @@ -20,6 +20,7 @@ import { } from "./model.ts"; import { ModelSelection, ProjectScript } from "./orchestration.ts"; import { BrowserProfile, BrowserProfileId, DEFAULT_BROWSER_PROFILE_ID } from "./browserProfile.ts"; +import { OpenWithEntries, OpenWithEntryRef } from "./openWith.ts"; import { DEFAULT_PREVIEW_APPEARANCE, DEFAULT_PREVIEW_ZOOM_FACTOR, @@ -232,6 +233,7 @@ const QuitConfirmationModeSetting = Schema.Union([QuitConfirmationMode, LegacyCo export const FontFamilyPreference = Schema.String.check(Schema.isMaxLength(200)); export type FontFamilyPreference = typeof FontFamilyPreference.Type; +export const DEFAULT_SIDEBAR_HIDE_PROVIDER_ICONS = false; /** * The environment's theme, set with `t3 theme set `. Each client applies * it once per value — live when connected, on its next connect otherwise — so @@ -335,6 +337,7 @@ export const ClientSettingsSchema = Schema.Struct({ ), confirmThreadArchive: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))), confirmThreadDelete: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))), + confirmWorktreeRemoval: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))), confirmThreadUnpin: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))), dismissedProviderUpdateNotificationKeys: Schema.Array(TrimmedNonEmptyString).pipe( Schema.withDecodingDefault(Effect.succeed([])), @@ -389,6 +392,13 @@ export const ClientSettingsSchema = Schema.Struct({ model: TrimmedNonEmptyString, }), ).pipe(Schema.withDecodingDefault(Effect.succeed([]))), + providerFavorites: Schema.Array(ProviderInstanceId).pipe( + Schema.withDecodingDefault(Effect.succeed([])), + ), + openWithEntries: OpenWithEntries.pipe(Schema.withDecodingDefault(Effect.succeed([]))), + preferredOpenWith: Schema.NullOr(OpenWithEntryRef).pipe( + Schema.withDecodingDefault(Effect.succeed(null)), + ), providerModelPreferences: Schema.Record( ProviderInstanceId, Schema.Struct({ @@ -435,6 +445,16 @@ export const ClientSettingsSchema = Schema.Struct({ sidebarThreadPreviewCount: SidebarThreadPreviewCount.pipe( Schema.withDecodingDefault(Effect.succeed(DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT)), ), + sidebarHideProviderIcons: Schema.Boolean.pipe( + Schema.withDecodingDefault(Effect.succeed(DEFAULT_SIDEBAR_HIDE_PROVIDER_ICONS)), + ), + /** + * Classic sidebar strip above projects. Setting key is historical ("Recent"); + * product behavior is Needs attention (Working ∪ blocked Review). + */ + sidebarRecentThreadsEnabled: Schema.Boolean.pipe( + Schema.withDecodingDefault(Effect.succeed(true)), + ), timestampFormat: TimestampFormat.pipe( Schema.withDecodingDefault(Effect.succeed(DEFAULT_TIMESTAMP_FORMAT)), ), @@ -686,6 +706,28 @@ export const CursorSettings = makeProviderSettingsSchema( ); export type CursorSettings = typeof CursorSettings.Type; +export const KimiSettings = makeProviderSettingsSchema( + { + enabled: Schema.Boolean.pipe( + Schema.withDecodingDefault(Effect.succeed(true)), + Schema.annotateKey({ providerSettingsForm: { hidden: true } }), + ), + binaryPath: makeBinaryPathSetting("kimi").pipe( + Schema.annotateKey({ + title: "Binary path", + description: "Path to the Kimi Code CLI binary used by this instance.", + providerSettingsForm: { placeholder: "kimi", clearWhenEmpty: "omit" }, + }), + ), + customModels: Schema.Array(Schema.String).pipe( + Schema.withDecodingDefault(Effect.succeed([])), + Schema.annotateKey({ providerSettingsForm: { hidden: true } }), + ), + }, + { order: ["binaryPath", "customModels", "enabled"] }, +); +export type KimiSettings = typeof KimiSettings.Type; + export const GrokSettings = makeProviderSettingsSchema( { // Off by default (like Cursor and OpenCode): the binding is not yet @@ -1027,12 +1069,17 @@ export const ServerSettings = Schema.Struct({ Schema.withDecodingDefault(Effect.succeed(null)), ), defaultThreadEnvMode: ThreadEnvMode.pipe( - Schema.withDecodingDefault(Effect.succeed("local" as const satisfies ThreadEnvMode)), + Schema.withDecodingDefault(Effect.succeed("worktree" as const satisfies ThreadEnvMode)), ), newWorktreesStartFromOrigin: Schema.Boolean.pipe( Schema.withDecodingDefault(Effect.succeed(true)), ), addProjectBaseDirectory: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))), + // Preferred shell for integrated terminals. Empty falls back to the OS + // login shell ($SHELL, else bash/pwsh). This is read only by the terminal + // PTY spawn path — agent provider processes spawn separately and never + // inherit it, so setting a terminal shell here does not change providers. + terminalShell: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))), textGenerationModelSelection: ModelSelection.pipe( Schema.withDecodingDefault( Effect.succeed({ @@ -1064,6 +1111,7 @@ export const ServerSettings = Schema.Struct({ codex: CodexSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), claudeAgent: ClaudeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), cursor: CursorSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), + kimi: KimiSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), grok: GrokSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), opencode: OpenCodeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), antigravity: AntigravitySettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), @@ -1215,6 +1263,12 @@ const CursorSettingsPatch = Schema.Struct({ customModels: Schema.optionalKey(Schema.Array(CustomModelSetting)), }); +const KimiSettingsPatch = Schema.Struct({ + enabled: Schema.optionalKey(Schema.Boolean), + binaryPath: Schema.optionalKey(TrimmedString), + customModels: Schema.optionalKey(Schema.Array(Schema.String)), +}); + const GrokSettingsPatch = Schema.Struct({ enabled: Schema.optionalKey(Schema.Boolean), binaryPath: Schema.optionalKey(TrimmedString), @@ -1278,6 +1332,7 @@ export const ServerSettingsPatch = Schema.Struct({ defaultThreadEnvMode: Schema.optionalKey(ThreadEnvMode), newWorktreesStartFromOrigin: Schema.optionalKey(Schema.Boolean), addProjectBaseDirectory: Schema.optionalKey(TrimmedString), + terminalShell: Schema.optionalKey(TrimmedString), textGenerationModelSelection: Schema.optionalKey(ModelSelectionPatch), sourceControlWritingStyle: Schema.optionalKey( Schema.Struct({ @@ -1298,6 +1353,7 @@ export const ServerSettingsPatch = Schema.Struct({ codex: Schema.optionalKey(CodexSettingsPatch), claudeAgent: Schema.optionalKey(ClaudeSettingsPatch), cursor: Schema.optionalKey(CursorSettingsPatch), + kimi: Schema.optionalKey(KimiSettingsPatch), grok: Schema.optionalKey(GrokSettingsPatch), opencode: Schema.optionalKey(OpenCodeSettingsPatch), antigravity: Schema.optionalKey(AntigravitySettingsPatch), @@ -1338,6 +1394,7 @@ export const ClientSettingsPatch = Schema.Struct({ confirmQuit: Schema.optionalKey(QuitConfirmationMode), confirmThreadArchive: Schema.optionalKey(Schema.Boolean), confirmThreadDelete: Schema.optionalKey(Schema.Boolean), + confirmWorktreeRemoval: Schema.optionalKey(Schema.Boolean), confirmThreadUnpin: Schema.optionalKey(Schema.Boolean), diffIgnoreWhitespace: Schema.optionalKey(Schema.Boolean), diffLayout: Schema.optionalKey(DiffLayout), @@ -1361,6 +1418,9 @@ export const ClientSettingsPatch = Schema.Struct({ }), ), ), + providerFavorites: Schema.optionalKey(Schema.Array(ProviderInstanceId)), + openWithEntries: Schema.optionalKey(OpenWithEntries), + preferredOpenWith: Schema.optionalKey(Schema.NullOr(OpenWithEntryRef)), providerModelPreferences: Schema.optionalKey( Schema.Record( ProviderInstanceId, @@ -1390,6 +1450,8 @@ export const ClientSettingsPatch = Schema.Struct({ sidebarProjectSortOrder: Schema.optionalKey(SidebarProjectSortOrder), sidebarThreadSortOrder: Schema.optionalKey(SidebarThreadSortOrder), sidebarThreadPreviewCount: Schema.optionalKey(SidebarThreadPreviewCount), + sidebarHideProviderIcons: Schema.optionalKey(Schema.Boolean), + sidebarRecentThreadsEnabled: Schema.optionalKey(Schema.Boolean), timestampFormat: Schema.optionalKey(TimestampFormat), snapShotEnabled: Schema.optionalKey(Schema.Boolean), snapShotIncludeAccessibility: Schema.optionalKey(Schema.Boolean), diff --git a/packages/contracts/src/sourceControl.ts b/packages/contracts/src/sourceControl.ts index cc98fbc1bbcc..2a693b987c86 100644 --- a/packages/contracts/src/sourceControl.ts +++ b/packages/contracts/src/sourceControl.ts @@ -15,6 +15,7 @@ export const SourceControlProviderInfo = Schema.Struct({ kind: SourceControlProviderKind, name: TrimmedNonEmptyString, baseUrl: Schema.String, + repositoryUrl: Schema.optional(TrimmedNonEmptyString), }); export type SourceControlProviderInfo = typeof SourceControlProviderInfo.Type; @@ -37,6 +38,7 @@ export const ChangeRequest = Schema.Struct({ isCrossRepository: Schema.optional(Schema.Boolean), headRepositoryNameWithOwner: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)), headRepositoryOwnerLogin: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)), + hasFailingChecks: Schema.optional(Schema.Boolean), }); export type ChangeRequest = typeof ChangeRequest.Type; diff --git a/packages/contracts/src/t3ProjectFile.test.ts b/packages/contracts/src/t3ProjectFile.test.ts index ed19c6d69887..298e96413b7a 100644 --- a/packages/contracts/src/t3ProjectFile.test.ts +++ b/packages/contracts/src/t3ProjectFile.test.ts @@ -16,6 +16,8 @@ describe("T3ProjectFile", () => { command: "pnpm dev", icon: "play", runOnWorktreeCreate: false, + runOnWorktreeRemove: true, + runOnPrMerged: true, previewUrl: "http://localhost:3000", autoOpenPreview: true, }, diff --git a/packages/contracts/src/t3ProjectFile.ts b/packages/contracts/src/t3ProjectFile.ts index 5062a1a370b5..ef919babe299 100644 --- a/packages/contracts/src/t3ProjectFile.ts +++ b/packages/contracts/src/t3ProjectFile.ts @@ -12,6 +12,8 @@ export const T3_PROJECT_FILE_SCHEMA_URL = "https://t3.codes/schema/t3.json"; const T3_PROJECT_FILE_PATH_MAX_LENGTH = 512; const T3_PROJECT_FILE_MAX_SCRIPTS = 50; +const T3_PROJECT_FILE_MAX_DEV_STACK_CONSUMERS = 20; +const T3_PROJECT_FILE_MAX_DEV_STACK_ROLES = 10; // Annotations go on the encoded (string) side so they survive into the // published JSON Schema; decoding still trims and re-validates non-emptiness. @@ -42,6 +44,18 @@ export const T3ProjectFileScript = Schema.Struct({ "When true, the script runs automatically after a worktree is created for a new thread.", }), ), + runOnWorktreeRemove: Schema.optionalKey( + Schema.Boolean.annotate({ + description: + "When true, the script runs automatically before a worktree is removed. Removal waits for the script to exit; a non-zero exit blocks removal.", + }), + ), + runOnPrMerged: Schema.optionalKey( + Schema.Boolean.annotate({ + description: + "When true, the script runs automatically when T3 observes the branch change request transition to merged (independent of worktree removal). Runs in the status cwd (worktree or project root).", + }), + ), previewUrl: Schema.optionalKey( trimmedNonEmpty({ description: @@ -59,6 +73,47 @@ export const T3ProjectFileScript = Schema.Struct({ }); export type T3ProjectFileScript = typeof T3ProjectFileScript.Type; +/** + * Policy for long-running dev servers a repository starts outside T3's own + * process tree (test stacks, preview servers). The live instances themselves are + * registered under `$TMPDIR/dev-stacks` in the repo-agnostic `dev-stack/1` format; + * this declares how T3 should treat them. + * + * Policy lives here rather than in each registry entry on purpose: an idle window + * is a property of the repository, not of one running instance, and changing it + * should apply to instances that are already up on the next sweep instead of only + * to ones started afterwards. + */ +export const T3ProjectFileDevStacks = Schema.Struct({ + idleMinutes: Schema.optionalKey( + Schema.Number.check(Schema.isGreaterThan(0)).annotate({ + description: + "Minutes a registered dev stack may go without an observed consumer before T3 stops it. Defaults to 20.", + }), + ), + consumers: Schema.optionalKey( + Schema.Array( + trimmedNonEmpty({ description: "Substring matched against process command lines." }), + ) + .annotate({ + description: + 'Processes whose presence inside the worktree counts as the stack being in use, e.g. ["playwright", "vitest"]. Deliberately narrow: a shell sitting in the worktree is not a consumer, and treating it as one would keep every stack alive for the length of a session.', + }) + .check(Schema.isMaxLength(T3_PROJECT_FILE_MAX_DEV_STACK_CONSUMERS)), + ), + entryRoles: Schema.optionalKey( + Schema.Array(trimmedNonEmpty({ description: "A role name used in the dev-stack registry." })) + .annotate({ + description: + 'Roles a consumer connects to, most specific first, e.g. ["frontend", "api"]. T3 watches the first role present in an instance. Ordering matters: a frontend usually holds keep-alive connections to its own API, so counting the API port would read the stack as busy for as long as the frontend is up.', + }) + .check(Schema.isMaxLength(T3_PROJECT_FILE_MAX_DEV_STACK_ROLES)), + ), +}).annotate({ + description: "How T3 supervises long-running dev stacks this repository registers.", +}); +export type T3ProjectFileDevStacks = typeof T3ProjectFileDevStacks.Type; + export const T3ProjectFile = Schema.Struct({ $schema: Schema.optionalKey( Schema.String.annotate({ @@ -87,6 +142,12 @@ export const T3ProjectFile = Schema.Struct({ }) .check(Schema.isMaxLength(T3_PROJECT_FILE_MAX_SCRIPTS)), ), + devStacks: Schema.optionalKey( + T3ProjectFileDevStacks.annotate({ + description: + "Opt in to T3 supervising the dev stacks this repository registers under $TMPDIR/dev-stacks. Omit it and T3 leaves them alone.", + }), + ), }).annotate({ title: "T3 project file", description: diff --git a/packages/contracts/src/usage.ts b/packages/contracts/src/usage.ts index 29fb75bf949c..e9b48b64e9c2 100644 --- a/packages/contracts/src/usage.ts +++ b/packages/contracts/src/usage.ts @@ -3,9 +3,10 @@ * * Each environment scans the provider CLIs' own on-disk session transcripts * (`~/.claude/projects/**\/*.jsonl`, `~/.codex/sessions/**\/*.jsonl`, - * `~/.grok/sessions/**\/updates.jsonl`) rather than relying on T3 Code's own - * orchestration projections, so usage stays complete even for turns that were - * never driven through T3 Code. This mirrors the approach `ccusage` takes. + * `~/.grok/sessions/**\/updates.jsonl`, `~/.kimi/sessions/**\/wire.jsonl`) + * rather than relying on T3 Code's own orchestration projections, so usage + * stays complete even for turns that were never driven through T3 Code. This + * mirrors the approach `ccusage` takes. * * Environments return pre-aggregated `(day, hourStart?, provider, model)` * buckets. Raw transcript records never cross the wire. @@ -20,19 +21,26 @@ import { NonNegativeInt, TrimmedNonEmptyString } from "./baseSchemas.ts"; * Bumped whenever the shape of {@link UsageSummary} changes incompatibly. The * client renders partial coverage when an environment reports an older version * rather than failing the whole page. + * + * Adding a provider to {@link UsageProviderKind} is deliberately *not* such a + * change. An older environment simply reports no buckets for the new provider, + * and those payloads still decode here. Bumping would instead drop that + * environment's Claude and Codex usage too, until every environment in a fleet + * had been upgraded — a real undercount traded for a signal about providers + * that environment may not even run. */ export const USAGE_CONTRACT_VERSION = 5 as const; /** * Oldest {@link UsageSummary} version a current client will still merge. * - * v5 only adds `grok` to {@link UsageProviderKind}; v4 Claude/Codex buckets - * remain valid, so mixed-version environments keep those totals instead of - * treating every older server as stale. + * v5 adds `grok` (and this fork's `kimi`) to {@link UsageProviderKind}; v4 + * Claude/Codex buckets remain valid, so mixed-version environments keep those + * totals instead of treating every older server as stale. */ export const USAGE_MERGE_COMPATIBLE_SINCE = 4 as const; -export const UsageProviderKind = Schema.Literals(["claude", "codex", "grok"]); +export const UsageProviderKind = Schema.Literals(["claude", "codex", "grok", "kimi"]); export type UsageProviderKind = typeof UsageProviderKind.Type; /** diff --git a/packages/contracts/src/vcs.ts b/packages/contracts/src/vcs.ts index 1f38c7cb718e..65d4fbe98412 100644 --- a/packages/contracts/src/vcs.ts +++ b/packages/contracts/src/vcs.ts @@ -33,6 +33,13 @@ export const VcsRepositoryIdentity = Schema.Struct({ kind: VcsDriverKind, rootPath: TrimmedNonEmptyString, metadataPath: Schema.NullOr(TrimmedNonEmptyString), + /** + * True when the repository has no working tree of its own (Git: `core.bare`). + * Such a repository is still a complete repository — fetch, ref, and worktree + * plumbing all work against it — so detection reports it rather than treating + * it as "no repository here". `rootPath` is then the metadata directory. + */ + bare: Schema.Boolean, freshness: VcsFreshness, }); export type VcsRepositoryIdentity = typeof VcsRepositoryIdentity.Type; @@ -121,6 +128,11 @@ export class VcsProcessExitError extends Schema.TaggedError failureKind: Schema.optional(VcsProcessExitFailureKind), stderrLength: Schema.optional(NonNegativeInt), stderrTruncated: Schema.optional(Schema.Boolean), + /** + * A guest-wrapper line that is safe to show. Raw provider stderr stays off + * `message` so tokens in GraphQL/REST failures cannot leak into logs. + */ + publicDiagnostic: Schema.optional(Schema.String), }, ) { override get message(): string { @@ -131,6 +143,7 @@ export class VcsProcessExitError extends Schema.TaggedError context: VcsProcessErrorContext, error: VcsProcessExitFailure, failureKind: VcsProcessExitFailureKind, + publicDiagnostic?: string, ) { const detail = failureKind === "authentication" @@ -152,6 +165,7 @@ export class VcsProcessExitError extends Schema.TaggedError failureKind, stderrLength: error.stderr.length, stderrTruncated: error.stderrTruncated, + ...(publicDiagnostic !== undefined ? { publicDiagnostic } : {}), }); } } diff --git a/packages/effect-acp/src/agent.ts b/packages/effect-acp/src/agent.ts index 8e209fe01bd9..0d3d9bbffe02 100644 --- a/packages/effect-acp/src/agent.ts +++ b/packages/effect-acp/src/agent.ts @@ -175,6 +175,11 @@ export class AcpAgent extends Context.Service< request: AcpSchema.SetSessionModelRequest, ) => Effect.Effect, ) => Effect.Effect; + readonly handleSetSessionMode: ( + handler: ( + request: AcpSchema.SetSessionModeRequest, + ) => Effect.Effect, + ) => Effect.Effect; readonly handleSetSessionConfigOption: ( handler: ( request: AcpSchema.SetSessionConfigOptionRequest, @@ -244,6 +249,9 @@ interface AcpCoreAgentRequestHandlers { setSessionModel?: ( request: AcpSchema.SetSessionModelRequest, ) => Effect.Effect; + setSessionMode?: ( + request: AcpSchema.SetSessionModeRequest, + ) => Effect.Effect; setSessionConfigOption?: ( request: AcpSchema.SetSessionConfigOptionRequest, ) => Effect.Effect; @@ -348,6 +356,8 @@ export const make = Effect.fn("effect-acp/AcpAgent.make")(function* ( runHandler(coreHandlers.closeSession, payload, AGENT_METHODS.session_close), [AGENT_METHODS.session_set_model]: (payload) => runHandler(coreHandlers.setSessionModel, payload, AGENT_METHODS.session_set_model), + [AGENT_METHODS.session_set_mode]: (payload) => + runHandler(coreHandlers.setSessionMode, payload, AGENT_METHODS.session_set_mode), [AGENT_METHODS.session_set_config_option]: (payload) => runHandler( coreHandlers.setSessionConfigOption, @@ -485,6 +495,11 @@ export const make = Effect.fn("effect-acp/AcpAgent.make")(function* ( coreHandlers.setSessionModel = handler; return Effect.void; }), + handleSetSessionMode: (handler) => + Effect.suspend(() => { + coreHandlers.setSessionMode = handler; + return Effect.void; + }), handleSetSessionConfigOption: (handler) => Effect.suspend(() => { coreHandlers.setSessionConfigOption = handler; diff --git a/packages/effect-acp/src/client.ts b/packages/effect-acp/src/client.ts index b3bcf3cd2433..4736f0952280 100644 --- a/packages/effect-acp/src/client.ts +++ b/packages/effect-acp/src/client.ts @@ -119,6 +119,13 @@ export class AcpClient extends Context.Service< readonly setSessionModel: ( payload: AcpSchema.SetSessionModelRequest, ) => Effect.Effect; + /** + * Selects the active session mode. + * @see https://agentclientprotocol.com/protocol/schema#session/set_mode + */ + readonly setSessionMode: ( + payload: AcpSchema.SetSessionModeRequest, + ) => Effect.Effect; /** * Updates a session configuration option. * @see https://agentclientprotocol.com/protocol/schema#session/set_config_option @@ -495,6 +502,8 @@ export const make = Effect.fn("effect-acp/AcpClient.make")(function* ( callRpc(AGENT_METHODS.session_close, rpc[AGENT_METHODS.session_close](payload)), setSessionModel: (payload) => callRpc(AGENT_METHODS.session_set_model, rpc[AGENT_METHODS.session_set_model](payload)), + setSessionMode: (payload) => + callRpc(AGENT_METHODS.session_set_mode, rpc[AGENT_METHODS.session_set_mode](payload)), setSessionConfigOption: (payload) => callRpc( AGENT_METHODS.session_set_config_option, @@ -594,5 +603,16 @@ export const layerChildProcess = ( stdin: options.transformStdout?.(handle.stdout) ?? handle.stdout, }; const terminationError = makeTerminationError(handle); - return Layer.effect(AcpClient, make(stdio, options, terminationError)); + return Layer.effect( + AcpClient, + Effect.gen(function* () { + const decoder = new TextDecoder(); + yield* Stream.runForEach(handle.stderr, (chunk) => + Effect.sync(() => { + process.stderr.write(`[acp-child-stderr] ${decoder.decode(chunk, { stream: true })}`); + }), + ).pipe(Effect.ignore, Effect.forkScoped); + return yield* make(stdio, options, terminationError); + }), + ); }; diff --git a/packages/effect-acp/src/protocol.test.ts b/packages/effect-acp/src/protocol.test.ts index cef04ffcd498..b3d6977c836f 100644 --- a/packages/effect-acp/src/protocol.test.ts +++ b/packages/effect-acp/src/protocol.test.ts @@ -54,6 +54,9 @@ const encoder = new TextEncoder(); const mockPeerPath = Effect.map(Effect.service(Path.Path), (path) => path.join(import.meta.dirname, "../test/fixtures/acp-mock-peer.ts"), ); +const stdinDrainingPeerPath = Effect.map(Effect.service(Path.Path), (path) => + path.join(import.meta.dirname, "../test/fixtures/stdin-draining-peer.ts"), +); const mockPeerArgs = (path: string) => [path]; const makeHandle = (env?: Record) => @@ -68,6 +71,39 @@ const makeHandle = (env?: Record) => }); it.layer(NodeServices.layer)("effect-acp protocol", (it) => { + it.effect("closes child stdin before awaiting process shutdown", () => + Effect.gen(function* () { + const exitCode = yield* Ref.make(null); + + yield* Effect.scoped( + Effect.gen(function* () { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const handle = yield* spawner.spawn( + ChildProcess.make(process.execPath, [yield* stdinDrainingPeerPath], { + forceKillAfter: "100 millis", + }), + ); + yield* Effect.addFinalizer(() => + handle.exitCode.pipe( + Effect.flatMap((code) => Ref.set(exitCode, code)), + Effect.timeoutOrElse({ + duration: "1 second", + orElse: () => Ref.set(exitCode, -1), + }), + Effect.catch(() => Ref.set(exitCode, -2)), + ), + ); + yield* AcpProtocol.makeAcpPatchedProtocol({ + stdio: makeChildStdio(handle), + serverRequestMethods: new Set(), + }); + }), + ); + + assert.equal(yield* Ref.get(exitCode), 0); + }), + ); + it.effect( "emits exact JSON-RPC notifications and decodes inbound session/update and elicitation completion", () => @@ -135,6 +171,46 @@ it.layer(NodeServices.layer)("effect-acp protocol", (it) => { }), ); + it.effect( + "drops Effect-RPC transport control frames instead of leaking them to the ACP wire", + () => + Effect.gen(function* () { + const { stdio, output } = yield* makeInMemoryStdio(); + const transport = yield* AcpProtocol.makeAcpPatchedProtocol({ + stdio, + serverRequestMethods: new Set(), + }); + + // `Interrupt` is what Effect's RpcClient emits when an in-flight request + // fiber is cancelled (a turn Stop, a client reconnect, a superseding + // turn, ...). A spec-compliant ACP agent cannot decode it — leaking it + // wedges the session — so it must never reach stdout. + yield* transport.clientProtocol.send(0, { + _tag: "Interrupt", + requestId: "4294967299", + }); + + // A real ACP message (here an id:"" notification) must still be written. + yield* transport.clientProtocol.send(0, { + _tag: "Request", + id: "", + tag: "session/cancel", + payload: { sessionId: "session-1" }, + headers: [], + }); + + // The first — and only — frame on the wire is the real request. Had the + // Interrupt leaked, it would have been taken here first. + const outbound = yield* Queue.take(output); + assert.deepEqual(yield* decodeSessionCancelNotification(outbound), { + jsonrpc: "2.0", + method: "session/cancel", + params: { sessionId: "session-1" }, + }); + assert.strictEqual(yield* Queue.size(output), 0); + }), + ); + it.effect("keeps only recent raw notifications after their callbacks run", () => Effect.gen(function* () { const { stdio, input } = yield* makeInMemoryStdio(); diff --git a/packages/effect-acp/src/protocol.ts b/packages/effect-acp/src/protocol.ts index cd6043f2db00..8f46fdb28e1f 100644 --- a/packages/effect-acp/src/protocol.ts +++ b/packages/effect-acp/src/protocol.ts @@ -2,6 +2,7 @@ import * as Cause from "effect/Cause"; import * as Effect from "effect/Effect"; import * as Deferred from "effect/Deferred"; import * as Exit from "effect/Exit"; +import * as Fiber from "effect/Fiber"; import * as Queue from "effect/Queue"; import * as Ref from "effect/Ref"; import type * as PlatformError from "effect/PlatformError"; @@ -511,7 +512,16 @@ export const makeAcpPatchedProtocol = Effect.fn("makeAcpPatchedProtocol")(functi Effect.forkScoped, ); - yield* Stream.fromQueue(outgoing).pipe(Stream.run(options.stdio.stdout()), Effect.forkScoped); + const outgoingFiber = yield* Stream.fromQueue(outgoing).pipe( + Stream.run(options.stdio.stdout()), + Effect.forkScoped, + ); + yield* Effect.addFinalizer(() => + Fiber.interrupt(outgoingFiber).pipe( + Effect.andThen(Stream.run(Stream.empty, options.stdio.stdout())), + Effect.ignore, + ), + ); const clientProtocol = RpcClient.Protocol.of({ run: (_clientId, f) => @@ -520,17 +530,30 @@ export const makeAcpPatchedProtocol = Effect.fn("makeAcpPatchedProtocol")(functi Effect.forever, ), send: (_clientId, request) => - offerOutgoing(request).pipe( - Effect.mapError( - (error) => - new RpcClientError.RpcClientError({ - reason: new RpcClientError.RpcClientDefect({ - message: "Failed to send ACP protocol message.", - cause: error, - }), - }), - ), - ), + // Effect's RpcClient multiplexes real RPC requests with transport-level + // control frames: `Interrupt` (emitted when a request fiber is cancelled), + // `Ack` (chunk backpressure), and `Ping`/`Eof` (liveness). Those frames are + // an Effect-RPC transport concern with no meaning in ACP, whose wire is + // plain JSON-RPC. A spec-compliant agent (e.g. grok) cannot decode them and + // rejects the line with "Method not found", which wedges the session: + // interrupting an in-flight `session/prompt` (a turn Stop) would otherwise + // leak an `Interrupt` frame onto the agent's stdin and brick the thread. + // Agent-side cancellation is expressed via the `session/cancel` + // notification, so only real ACP messages (`Request`, including id:"" for + // notifications) belong on the wire; the control frames are dropped here. + request._tag === "Request" + ? offerOutgoing(request).pipe( + Effect.mapError( + (error) => + new RpcClientError.RpcClientError({ + reason: new RpcClientError.RpcClientDefect({ + message: "Failed to send ACP protocol message.", + cause: error, + }), + }), + ), + ) + : Effect.void, supportsAck: true, supportsTransferables: false, codecFor: parserFactory.codecFor, diff --git a/packages/effect-acp/src/rpc.ts b/packages/effect-acp/src/rpc.ts index 5026645374eb..abe90ad892eb 100644 --- a/packages/effect-acp/src/rpc.ts +++ b/packages/effect-acp/src/rpc.ts @@ -70,6 +70,12 @@ const SetSessionModelRpc = Rpc.make(AGENT_METHODS.session_set_model, { error: AcpSchema.Error, }); +export const SetSessionModeRpc = Rpc.make(AGENT_METHODS.session_set_mode, { + payload: AcpSchema.SetSessionModeRequest, + success: AcpSchema.SetSessionModeResponse, + error: AcpSchema.Error, +}); + const SetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, { payload: AcpSchema.SetSessionConfigOptionRequest, success: AcpSchema.SetSessionConfigOptionResponse, @@ -142,6 +148,7 @@ export const AgentRpcs = RpcGroup.make( CloseSessionRpc, PromptRpc, SetSessionModelRpc, + SetSessionModeRpc, SetSessionConfigOptionRpc, ); diff --git a/packages/effect-acp/test/fixtures/stdin-draining-peer.ts b/packages/effect-acp/test/fixtures/stdin-draining-peer.ts new file mode 100644 index 000000000000..6a7396f97723 --- /dev/null +++ b/packages/effect-acp/test/fixtures/stdin-draining-peer.ts @@ -0,0 +1,6 @@ +process.on("SIGTERM", () => { + // Model agents that drain their protocol transport before exiting. +}); + +process.stdin.resume(); +process.stdin.on("end", () => process.exit(0)); diff --git a/packages/shared/package.json b/packages/shared/package.json index b502090e2a9d..4238986928d8 100644 --- a/packages/shared/package.json +++ b/packages/shared/package.json @@ -19,6 +19,10 @@ "types": "./src/model.ts", "import": "./src/model.ts" }, + "./providerModelSelection": { + "types": "./src/providerModelSelection.ts", + "import": "./src/providerModelSelection.ts" + }, "./advertisedEndpoint": { "types": "./src/advertisedEndpoint.ts", "import": "./src/advertisedEndpoint.ts" @@ -27,6 +31,14 @@ "types": "./src/agentAwareness.ts", "import": "./src/agentAwareness.ts" }, + "./agentRulesPointer": { + "types": "./src/agentRulesPointer.ts", + "import": "./src/agentRulesPointer.ts" + }, + "./sessionWake": { + "types": "./src/sessionWake.ts", + "import": "./src/sessionWake.ts" + }, "./git": { "types": "./src/git.ts", "import": "./src/git.ts" @@ -67,6 +79,10 @@ "types": "./src/KeyedCoalescingWorker.ts", "import": "./src/KeyedCoalescingWorker.ts" }, + "./KeyedDrainableWorker": { + "types": "./src/KeyedDrainableWorker.ts", + "import": "./src/KeyedDrainableWorker.ts" + }, "./schemaJson": { "types": "./src/schemaJson.ts", "import": "./src/schemaJson.ts" @@ -95,10 +111,30 @@ "types": "./src/backgroundActivitySettings.ts", "import": "./src/backgroundActivitySettings.ts" }, + "./serverRuntime": { + "types": "./src/serverRuntime.ts", + "import": "./src/serverRuntime.ts" + }, "./String": { "types": "./src/String.ts", "import": "./src/String.ts" }, + "./identityAvatar": { + "types": "./src/identityAvatar.ts", + "import": "./src/identityAvatar.ts" + }, + "./identityMap": { + "types": "./src/identityMap.ts", + "import": "./src/identityMap.ts" + }, + "./sourceAttribution": { + "types": "./src/sourceAttribution.ts", + "import": "./src/sourceAttribution.ts" + }, + "./threadAttributeSearch": { + "types": "./src/threadAttributeSearch.ts", + "import": "./src/threadAttributeSearch.ts" + }, "./projectScripts": { "types": "./src/projectScripts.ts", "import": "./src/projectScripts.ts" @@ -191,6 +227,10 @@ "types": "./src/composerInlineTokens.ts", "import": "./src/composerInlineTokens.ts" }, + "./composerInputHistory": { + "types": "./src/composerInputHistory.ts", + "import": "./src/composerInputHistory.ts" + }, "./assistantCitations": { "types": "./src/assistantCitations.ts", "import": "./src/assistantCitations.ts" @@ -199,6 +239,10 @@ "types": "./src/terminalLabels.ts", "import": "./src/terminalLabels.ts" }, + "./threadTitle": { + "types": "./src/threadTitle.ts", + "import": "./src/threadTitle.ts" + }, "./relayClient": { "types": "./src/relayClient.ts", "import": "./src/relayClient.ts" @@ -231,6 +275,10 @@ "types": "./src/chatList.ts", "import": "./src/chatList.ts" }, + "./userInputTranscript": { + "types": "./src/userInputTranscript.ts", + "import": "./src/userInputTranscript.ts" + }, "./hostProcess": { "types": "./src/hostProcess.ts", "import": "./src/hostProcess.ts" @@ -255,6 +303,22 @@ "types": "./src/devProxy.ts", "import": "./src/devProxy.ts" }, + "./steerTimeline": { + "types": "./src/steerTimeline.ts", + "import": "./src/steerTimeline.ts" + }, + "./proposedPlan": { + "types": "./src/proposedPlan.ts", + "import": "./src/proposedPlan.ts" + }, + "./turnResponseStats": { + "types": "./src/turnResponseStats.ts", + "import": "./src/turnResponseStats.ts" + }, + "./productFamily": { + "types": "./src/productFamily.ts", + "import": "./src/productFamily.ts" + }, "./usageMerge": { "types": "./src/usageMerge.ts", "import": "./src/usageMerge.ts" diff --git a/packages/shared/src/KeyedDrainableWorker.test.ts b/packages/shared/src/KeyedDrainableWorker.test.ts new file mode 100644 index 000000000000..cd944f8d851b --- /dev/null +++ b/packages/shared/src/KeyedDrainableWorker.test.ts @@ -0,0 +1,71 @@ +import { it } from "@effect/vitest"; +import { describe, expect } from "vite-plus/test"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; + +import { makeKeyedDrainableWorker } from "./KeyedDrainableWorker.ts"; + +describe("makeKeyedDrainableWorker", () => { + it.live("keeps FIFO order per key, runs keys concurrently, and reclaims idle lanes", () => + Effect.scoped( + Effect.gen(function* () { + const blockedStarted = yield* Deferred.make(); + const releaseBlocked = yield* Deferred.make(); + const processed: string[] = []; + const worker = yield* makeKeyedDrainableWorker({ + key: (item) => item.split(":")[0] ?? item, + process: (item) => + Effect.gen(function* () { + processed.push(item); + if (item === "blocked:first") { + yield* Deferred.succeed(blockedStarted, undefined).pipe(Effect.orDie); + yield* Deferred.await(releaseBlocked); + } + }), + }); + + expect(yield* worker.activeKeyCount).toBe(0); + yield* worker.enqueue("blocked:first"); + yield* worker.enqueue("blocked:second"); + yield* Deferred.await(blockedStarted).pipe(Effect.timeout("1 second")); + yield* worker.enqueue("free:first"); + yield* worker.drainKey("free"); + + expect(processed).toEqual(["blocked:first", "free:first"]); + expect(yield* worker.activeKeyCount).toBe(1); + + yield* Deferred.succeed(releaseBlocked, undefined).pipe(Effect.orDie); + yield* worker.drain; + expect(processed).toEqual(["blocked:first", "free:first", "blocked:second"]); + expect(yield* worker.activeKeyCount).toBe(0); + }), + ), + ); + + it.live("interrupts active work and drops queued work when a key is cancelled", () => + Effect.scoped( + Effect.gen(function* () { + const started = yield* Deferred.make(); + const processed: string[] = []; + const worker = yield* makeKeyedDrainableWorker({ + key: () => "deleted-thread", + process: (item) => + Effect.gen(function* () { + processed.push(item); + yield* Deferred.succeed(started, undefined).pipe(Effect.orDie); + return yield* Effect.never; + }), + }); + + yield* worker.enqueue("active"); + yield* worker.enqueue("queued"); + yield* Deferred.await(started).pipe(Effect.timeout("1 second")); + yield* worker.cancelKey("deleted-thread"); + yield* worker.drain; + + expect(processed).toEqual(["active"]); + expect(yield* worker.activeKeyCount).toBe(0); + }), + ), + ); +}); diff --git a/packages/shared/src/KeyedDrainableWorker.ts b/packages/shared/src/KeyedDrainableWorker.ts new file mode 100644 index 000000000000..ce89a82712a7 --- /dev/null +++ b/packages/shared/src/KeyedDrainableWorker.ts @@ -0,0 +1,159 @@ +/** + * Lazy FIFO work lanes keyed by an identifier. + * + * A lane exists only while its key has active or queued work. Same-key work is + * serial, different keys run concurrently, and idle lanes are reclaimed. + */ +import * as Scope from "effect/Scope"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Semaphore from "effect/Semaphore"; +import * as TxRef from "effect/TxRef"; + +export interface KeyedDrainableWorker { + readonly enqueue: (item: A) => Effect.Effect; + readonly cancelKey: (key: K) => Effect.Effect; + readonly drain: Effect.Effect; + readonly drainKey: (key: K) => Effect.Effect; + readonly activeKeyCount: Effect.Effect; +} + +interface Lane { + readonly queue: Array; + fiber: Fiber.Fiber | undefined; +} + +interface Outstanding { + readonly total: number; + readonly byKey: Map; +} + +export const makeKeyedDrainableWorker = (options: { + readonly key: (item: A) => K; + readonly process: (item: A) => Effect.Effect; +}): Effect.Effect, never, Scope.Scope | R> => + Effect.gen(function* () { + const context = yield* Effect.context(); + const registryLock = yield* Semaphore.make(1); + const lanes = new Map>(); + const outstandingRef = yield* TxRef.make>({ + total: 0, + byKey: new Map(), + }); + + const adjustOutstanding = (key: K, delta: number) => + TxRef.update(outstandingRef, (state) => { + const byKey = new Map(state.byKey); + const next = (byKey.get(key) ?? 0) + delta; + if (next <= 0) byKey.delete(key); + else byKey.set(key, next); + return { total: state.total + delta, byKey }; + }).pipe(Effect.tx); + + const processLane = (key: K, lane: Lane): Effect.Effect => + Effect.suspend(() => + registryLock + .withPermit( + Effect.sync(() => { + const item = lane.queue.shift(); + if (item === undefined && lanes.get(key) === lane) { + lanes.delete(key); + } + return item; + }), + ) + .pipe( + Effect.flatMap((item) => + item === undefined + ? Effect.void + : options + .process(item) + .pipe( + Effect.provide(context), + Effect.ensuring(adjustOutstanding(key, -1)), + Effect.andThen(processLane(key, lane)), + ), + ), + ), + ); + + const enqueue: KeyedDrainableWorker["enqueue"] = (item) => { + const key = options.key(item); + return registryLock.withPermit( + Effect.gen(function* () { + let lane = lanes.get(key); + if (lane === undefined) { + lane = { queue: [], fiber: undefined }; + lanes.set(key, lane); + } + lane.queue.push(item); + yield* adjustOutstanding(key, 1); + if (lane.fiber === undefined) { + lane.fiber = yield* processLane(key, lane).pipe(Effect.forkDetach); + } + }), + ); + }; + + const cancelKey: KeyedDrainableWorker["cancelKey"] = (key) => + Effect.gen(function* () { + let fiber: Fiber.Fiber | undefined; + let droppedQueuedItems = 0; + yield* registryLock.withPermit( + Effect.sync(() => { + const lane = lanes.get(key); + if (lane === undefined) return; + lanes.delete(key); + droppedQueuedItems = lane.queue.length; + lane.queue.length = 0; + fiber = lane.fiber; + }), + ); + if (droppedQueuedItems > 0) { + yield* adjustOutstanding(key, -droppedQueuedItems); + } + if (fiber !== undefined) { + yield* Fiber.interrupt(fiber); + } + }); + + yield* Effect.addFinalizer(() => + registryLock + .withPermit( + Effect.sync(() => { + const fibers = Array.from(lanes.values()).flatMap((lane) => + lane.fiber === undefined ? [] : [lane.fiber], + ); + lanes.clear(); + return fibers; + }), + ) + .pipe( + Effect.flatMap((fibers) => Fiber.interruptAll(fibers)), + Effect.asVoid, + ), + ); + + const drain = TxRef.get(outstandingRef).pipe( + Effect.tap((state) => (state.total > 0 ? Effect.txRetry : Effect.void)), + Effect.asVoid, + Effect.tx, + ); + + const drainKey: KeyedDrainableWorker["drainKey"] = (key) => + TxRef.get(outstandingRef).pipe( + Effect.tap((state) => (state.byKey.has(key) ? Effect.txRetry : Effect.void)), + Effect.asVoid, + Effect.tx, + ); + + const activeKeyCount = registryLock.withPermit(Effect.sync(() => lanes.size)); + + return { + enqueue, + cancelKey, + drain, + drainKey, + activeKeyCount, + } satisfies KeyedDrainableWorker; + }); diff --git a/packages/shared/src/agentAwareness.ts b/packages/shared/src/agentAwareness.ts index 77c7c845db31..c0f5842eb7c5 100644 --- a/packages/shared/src/agentAwareness.ts +++ b/packages/shared/src/agentAwareness.ts @@ -43,7 +43,7 @@ export interface ProjectThreadAwarenessInput { >; } -function buildAgentAwarenessDeepLink(input: { +export function buildAgentAwarenessDeepLink(input: { readonly environmentId: EnvironmentId; readonly threadId: ThreadId; }): string { diff --git a/packages/shared/src/agentRulesPointer.test.ts b/packages/shared/src/agentRulesPointer.test.ts new file mode 100644 index 000000000000..2bcd4a3d4503 --- /dev/null +++ b/packages/shared/src/agentRulesPointer.test.ts @@ -0,0 +1,101 @@ +import * as NodeAssert from "node:assert/strict"; +import { describe, it } from "vite-plus/test"; + +import { + AGENT_RULES_HEADER, + dedupeAgentRulesPaths, + ensureAgentRulesPaths, + extractAgentRulesPaths, + formatAgentRulesPointer, + formatAgentRulesPointers, + stripAgentRulesBlock, +} from "./agentRulesPointer.ts"; + +describe("formatAgentRulesPointers", () => { + it("formats global + overlay under one header", () => { + NodeAssert.equal( + formatAgentRulesPointers([ + "/opt/t3/docs/t3-agent-rules.md", + "/opt/t3/discord/agent-turn-rules.md", + ]), + `## Agent rules +rules: /opt/t3/docs/t3-agent-rules.md +rules: /opt/t3/discord/agent-turn-rules.md`, + ); + }); + + it("dedupes paths", () => { + NodeAssert.equal( + formatAgentRulesPointers(["/a.md", "/a.md", "/b.md"]), + `## Agent rules +rules: /a.md +rules: /b.md`, + ); + }); + + it("returns empty for no paths", () => { + NodeAssert.equal(formatAgentRulesPointers([]), ""); + }); +}); + +describe("formatAgentRulesPointer", () => { + it("still supports a custom single-path header", () => { + NodeAssert.equal( + formatAgentRulesPointer("/tmp/rules.md", "## Discord conversation context"), + `## Discord conversation context +rules: /tmp/rules.md`, + ); + }); +}); + +describe("extract / strip / ensure", () => { + const sample = `## Agent rules +rules: /global.md +rules: /discord.md + +## Discord conversation context +req: 1@user +## User request +hello`; + + it("extracts rules paths from the agent-rules block", () => { + NodeAssert.deepEqual(extractAgentRulesPaths(sample), ["/global.md", "/discord.md"]); + }); + + it("strips the agent-rules block", () => { + const stripped = stripAgentRulesBlock(sample); + NodeAssert.equal(stripped.includes(AGENT_RULES_HEADER), false); + NodeAssert.equal(stripped.includes("## Discord conversation context"), true); + NodeAssert.equal(stripped.includes("hello"), true); + }); + + it("merges required paths first and dedupes", () => { + const merged = ensureAgentRulesPaths(sample, ["/global.md", "/extra.md"]); + NodeAssert.equal( + merged, + `## Agent rules +rules: /global.md +rules: /extra.md +rules: /discord.md + +## Discord conversation context +req: 1@user +## User request +hello`, + ); + }); + + it("adds a block when missing", () => { + NodeAssert.equal( + ensureAgentRulesPaths("just text", ["/global.md"]), + `## Agent rules +rules: /global.md + +just text`, + ); + }); + + it("dedupeAgentRulesPaths preserves order", () => { + NodeAssert.deepEqual(dedupeAgentRulesPaths(["/b", "/a", "/b", ""]), ["/b", "/a"]); + }); +}); diff --git a/packages/shared/src/agentRulesPointer.ts b/packages/shared/src/agentRulesPointer.ts new file mode 100644 index 000000000000..5ef46d79e314 --- /dev/null +++ b/packages/shared/src/agentRulesPointer.ts @@ -0,0 +1,119 @@ +/** + * Shared shape for agent policy file pointers. + * + * Product policy is layered: + * 1. Global rules file (all surfaces) — always first + * 2. Optional client overlay (Discord, …) — additional `rules:` lines + * + * Injection shape (never paste rule bodies into the prompt): + * + * ``` + * ## Agent rules + * rules: /absolute/path/to/t3-agent-rules.md + * rules: /absolute/path/to/agent-turn-rules.md + * ``` + */ + +/** Canonical header for the unified rules block (global + overlays). */ +export const AGENT_RULES_HEADER = "## Agent rules"; + +const RULES_LINE = /^rules:\s+(\S+)\s*$/u; + +function normalizePath(path: string): string { + return path.trim(); +} + +/** Stable de-dupe preserving first-seen order. */ +export function dedupeAgentRulesPaths(paths: readonly string[]): string[] { + const seen = new Set(); + const out: string[] = []; + for (const raw of paths) { + const path = normalizePath(raw); + if (path.length === 0 || seen.has(path)) continue; + seen.add(path); + out.push(path); + } + return out; +} + +/** + * Format one or more rules-file pointers under a single header. + * Empty input → empty string. + */ +export function formatAgentRulesPointers( + rulesPaths: readonly string[], + header: string = AGENT_RULES_HEADER, +): string { + const unique = dedupeAgentRulesPaths(rulesPaths); + if (unique.length === 0) return ""; + return `${header}\n${unique.map((path) => `rules: ${path}`).join("\n")}`; +} + +/** @deprecated Prefer formatAgentRulesPointers — kept for single-path call sites. */ +export function formatAgentRulesPointer(rulesPath: string, header: string): string { + return formatAgentRulesPointers([rulesPath], header); +} + +/** + * Collect `rules: ` lines from a `## Agent rules` (or custom header) block. + * Stops at the next markdown H2. + */ +export function extractAgentRulesPaths( + text: string, + header: string = AGENT_RULES_HEADER, +): string[] { + const lines = text.split("\n"); + const headerIndex = lines.findIndex((line) => line.trim() === header); + if (headerIndex < 0) return []; + + const paths: string[] = []; + for (let i = headerIndex + 1; i < lines.length; i++) { + const line = lines[i] ?? ""; + if (/^##\s+/u.test(line)) break; + const match = RULES_LINE.exec(line); + if (match?.[1]) paths.push(match[1]); + } + return dedupeAgentRulesPaths(paths); +} + +/** + * Strip an existing agent-rules block (header + following `rules:` lines / blanks + * until the next H2 or non-rules content that is not blank). + */ +export function stripAgentRulesBlock(text: string, header: string = AGENT_RULES_HEADER): string { + const lines = text.split("\n"); + const headerIndex = lines.findIndex((line) => line.trim() === header); + if (headerIndex < 0) return text; + + let end = headerIndex + 1; + while (end < lines.length) { + const line = lines[end] ?? ""; + if (/^##\s+/u.test(line)) break; + if (line.trim() === "" || RULES_LINE.test(line)) { + end += 1; + continue; + } + break; + } + + const next = [...lines.slice(0, headerIndex), ...lines.slice(end)].join("\n"); + return next.replace(/^\n+/u, "").replace(/\n{3,}/gu, "\n\n"); +} + +/** + * Ensure `requiredPaths` appear in the unified agent-rules block (global first). + * Replaces any existing block with a merged, de-duplicated list. + */ +export function ensureAgentRulesPaths( + text: string, + requiredPaths: readonly string[], + header: string = AGENT_RULES_HEADER, +): string { + const existing = extractAgentRulesPaths(text, header); + const merged = dedupeAgentRulesPaths([...requiredPaths, ...existing]); + const without = stripAgentRulesBlock(text, header).trimEnd(); + const block = formatAgentRulesPointers(merged, header); + if (block.length === 0) return without; + if (without.length === 0) return block; + return `${block}\n\n${without}`; +} diff --git a/packages/shared/src/chatList.test.ts b/packages/shared/src/chatList.test.ts index 78cf90f2aa88..3016deebabeb 100644 --- a/packages/shared/src/chatList.test.ts +++ b/packages/shared/src/chatList.test.ts @@ -1,6 +1,10 @@ import { describe, expect, it } from "vite-plus/test"; -import { CHAT_LIST_ANCHOR_OFFSET, resolveChatListAnchoredEndSpace } from "./chatList.js"; +import { + CHAT_LIST_ANCHOR_OFFSET, + resolveChatListAnchoredEndSpace, + sendEntersSteeringQueue, +} from "./chatList.js"; interface Row { readonly id: string; @@ -51,3 +55,54 @@ describe("resolveChatListAnchoredEndSpace", () => { expect(resolveChatListAnchoredEndSpace(rows, null, getAnchorId)).toBeUndefined(); }); }); + +describe("sendEntersSteeringQueue", () => { + it("queues a follow-up sent while a turn is running or starting", () => { + for (const sessionStatus of ["running", "starting"]) { + expect( + sendEntersSteeringQueue({ + hasBootstrap: false, + sessionStatus, + hasPendingTurnStart: false, + }), + ).toBe(true); + } + }); + + it("queues a follow-up sent in the dispatched-but-unreported turn-start gap", () => { + expect( + sendEntersSteeringQueue({ + hasBootstrap: false, + sessionStatus: "ready", + hasPendingTurnStart: true, + }), + ).toBe(true); + }); + + it("does not queue an idle send, so it keeps its chat-list anchoring", () => { + expect( + sendEntersSteeringQueue({ + hasBootstrap: false, + sessionStatus: "ready", + hasPendingTurnStart: false, + }), + ).toBe(false); + expect( + sendEntersSteeringQueue({ + hasBootstrap: false, + sessionStatus: null, + hasPendingTurnStart: false, + }), + ).toBe(false); + }); + + it("exempts bootstrap sends, which create their thread in the same dispatch", () => { + expect( + sendEntersSteeringQueue({ + hasBootstrap: true, + sessionStatus: "running", + hasPendingTurnStart: true, + }), + ).toBe(false); + }); +}); diff --git a/packages/shared/src/chatList.ts b/packages/shared/src/chatList.ts index adfdcad4eaf2..c81d8388d374 100644 --- a/packages/shared/src/chatList.ts +++ b/packages/shared/src/chatList.ts @@ -1,5 +1,32 @@ export const CHAT_LIST_ANCHOR_OFFSET = 16; +/** + * Mirrors the server decider's queue-by-default rule (see + * `thread.turn.start` in `apps/server/src/orchestration/decider.ts`): a + * follow-up sent while a turn is starting/running — or while a turn start has + * been dispatched but the provider has not reported its session yet — is held + * in the steering queue instead of opening a turn. Bootstrap sends create their + * thread in the same dispatch and are exempt. + * + * Such a send never reaches the chat list; it lands as a queued chip by the + * composer. Both clients use this to keep the reader's position instead of + * jumping to the live edge and anchoring a row that will never appear. + */ +export function sendEntersSteeringQueue(input: { + readonly hasBootstrap: boolean; + readonly sessionStatus: string | null | undefined; + readonly hasPendingTurnStart: boolean; +}): boolean { + if (input.hasBootstrap) { + return false; + } + return ( + input.sessionStatus === "running" || + input.sessionStatus === "starting" || + input.hasPendingTurnStart + ); +} + export interface ChatListAnchoredEndSpace { readonly anchorIndex: number; readonly anchorOffset: number; diff --git a/packages/shared/src/composerInputHistory.test.ts b/packages/shared/src/composerInputHistory.test.ts new file mode 100644 index 000000000000..50bddd1f5ee2 --- /dev/null +++ b/packages/shared/src/composerInputHistory.test.ts @@ -0,0 +1,321 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + EMPTY_COMPOSER_INPUT_HISTORY, + isComposerCursorOnFirstLine, + isComposerCursorOnLastLine, + navigateComposerInputHistory, + normalizeComposerInputHistoryEntries, + pushComposerInputHistory, + recallComposerInputHistory, + resolveComposerInputHistoryKeyAction, + seedComposerInputHistoryFromConversation, + shouldNavigateComposerInputHistory, + type ComposerInputHistoryState, +} from "./composerInputHistory.ts"; + +describe("pushComposerInputHistory", () => { + it("ignores empty and whitespace-only values but exits browsing", () => { + const browsing: ComposerInputHistoryState = { + entries: ["abc"], + browsingIndex: 0, + stashedDraft: "tmp", + }; + expect(pushComposerInputHistory(browsing, " ")).toEqual({ + entries: ["abc"], + browsingIndex: null, + stashedDraft: "", + }); + }); + + it("appends non-empty values and skips consecutive duplicates", () => { + let state = pushComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "abc"); + state = pushComposerInputHistory(state, "cba"); + state = pushComposerInputHistory(state, "cba"); + expect(state.entries).toEqual(["abc", "cba"]); + expect(state.browsingIndex).toBeNull(); + }); + + it("caps entries at maxEntries", () => { + let state = EMPTY_COMPOSER_INPUT_HISTORY; + state = pushComposerInputHistory(state, "one", { maxEntries: 2 }); + state = pushComposerInputHistory(state, "two", { maxEntries: 2 }); + state = pushComposerInputHistory(state, "three", { maxEntries: 2 }); + expect(state.entries).toEqual(["two", "three"]); + }); +}); + +describe("recallComposerInputHistory", () => { + it("edits the recalled value and restores the existing draft on ArrowDown", () => { + const recalled = recallComposerInputHistory( + { + entries: ["older"], + browsingIndex: null, + stashedDraft: "", + }, + "queued follow-up", + "unfinished draft", + ); + expect(recalled.entries).toEqual(["older", "queued follow-up"]); + expect(recalled.browsingIndex).toBe(1); + expect(navigateComposerInputHistory(recalled, "down", "edited follow-up")).toMatchObject({ + handled: true, + value: "unfinished draft", + state: { browsingIndex: null }, + }); + }); +}); + +describe("seedComposerInputHistoryFromConversation", () => { + it("seeds from conversation when session history is empty", () => { + const seeded = seedComposerInputHistoryFromConversation(EMPTY_COMPOSER_INPUT_HISTORY, [ + "first", + " ", + "second", + "second", + "third", + ]); + expect(seeded.entries).toEqual(["first", "second", "third"]); + + const step = navigateComposerInputHistory(seeded, "up", "draft"); + expect(step).toMatchObject({ handled: true, value: "third" }); + }); + + it("does not overwrite existing session history", () => { + const session = pushComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "typed-this-session"); + const seeded = seedComposerInputHistoryFromConversation(session, ["older-thread-message"]); + expect(seeded).toEqual(session); + }); + + it("leaves state empty when conversation has no user prompts", () => { + expect( + seedComposerInputHistoryFromConversation(EMPTY_COMPOSER_INPUT_HISTORY, [" ", ""]), + ).toEqual(EMPTY_COMPOSER_INPUT_HISTORY); + }); +}); + +describe("normalizeComposerInputHistoryEntries", () => { + it("caps from the newest side", () => { + expect(normalizeComposerInputHistoryEntries(["a", "b", "c"], { maxEntries: 2 })).toEqual([ + "b", + "c", + ]); + }); +}); + +describe("navigateComposerInputHistory", () => { + it("matches shell-style up/down with draft restore", () => { + let state = pushComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "abc"); + state = pushComposerInputHistory(state, "cba"); + + let step = navigateComposerInputHistory(state, "up", "ab"); + expect(step).toEqual({ + handled: true, + state: { + entries: ["abc", "cba"], + browsingIndex: 1, + stashedDraft: "ab", + }, + value: "cba", + }); + state = step.handled ? step.state : state; + + step = navigateComposerInputHistory(state, "up", "cba"); + expect(step).toMatchObject({ handled: true, value: "abc" }); + state = step.handled ? step.state : state; + + step = navigateComposerInputHistory(state, "down", "abc"); + expect(step).toMatchObject({ handled: true, value: "cba" }); + state = step.handled ? step.state : state; + + step = navigateComposerInputHistory(state, "down", "cba"); + expect(step).toEqual({ + handled: true, + state: { + entries: ["abc", "cba"], + browsingIndex: null, + stashedDraft: "", + }, + value: "ab", + }); + }); + + it("stays on oldest entry when pressing up again", () => { + let state = pushComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "only"); + const first = navigateComposerInputHistory(state, "up", "draft"); + expect(first.handled).toBe(true); + if (!first.handled) return; + state = first.state; + + const again = navigateComposerInputHistory(state, "up", "only"); + expect(again).toEqual({ handled: true, state, value: "only" }); + }); + + it("does not handle down when not browsing", () => { + const state = pushComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "abc"); + expect(navigateComposerInputHistory(state, "down", "live")).toEqual({ handled: false }); + }); + + it("does not handle navigation with empty history", () => { + expect(navigateComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "up", "x")).toEqual({ + handled: false, + }); + }); + + it("preserves draft after editing a history entry and returning", () => { + let state = pushComposerInputHistory(EMPTY_COMPOSER_INPUT_HISTORY, "abc"); + state = pushComposerInputHistory(state, "cba"); + + let step = navigateComposerInputHistory(state, "up", "temporary"); + expect(step.handled).toBe(true); + if (!step.handled) return; + state = step.state; + + // User edits the history value in the input; navigation still uses entries. + step = navigateComposerInputHistory(state, "down", "cba-edited"); + expect(step).toMatchObject({ handled: true, value: "temporary" }); + }); +}); + +describe("resolveComposerInputHistoryKeyAction", () => { + it("moves toward top/beginning before history on up", () => { + // Mid multi-line → native caret movement first. + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: false, + text: "line1\nline2", + cursor: 8, + }), + ).toEqual({ action: "none" }); + + // First line, not at start → jump to beginning. + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: false, + text: "line1\nline2", + cursor: 2, + }), + ).toEqual({ action: "move-caret", cursor: 0 }); + + // Already at document start → history. + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: false, + text: "line1\nline2", + cursor: 0, + }), + ).toEqual({ action: "history" }); + }); + + it("moves to end before history on down while browsing", () => { + expect( + resolveComposerInputHistoryKeyAction({ + direction: "down", + browsing: true, + text: "line1\nline2", + cursor: 2, + }), + ).toEqual({ action: "none" }); + + expect( + resolveComposerInputHistoryKeyAction({ + direction: "down", + browsing: true, + text: "line1\nline2", + cursor: 8, + }), + ).toEqual({ action: "move-caret", cursor: "line1\nline2".length }); + + expect( + resolveComposerInputHistoryKeyAction({ + direction: "down", + browsing: true, + text: "line1\nline2", + cursor: "line1\nline2".length, + }), + ).toEqual({ action: "history" }); + }); + + it("does not enter history on down when not browsing", () => { + expect( + resolveComposerInputHistoryKeyAction({ + direction: "down", + browsing: false, + text: "hello", + cursor: 5, + }), + ).toEqual({ action: "none" }); + }); + + it("while browsing multi-line history, requires start edge for up", () => { + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: true, + text: "line1\nline2", + cursor: 8, + }), + ).toEqual({ action: "none" }); + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: true, + text: "line1\nline2", + cursor: 2, + }), + ).toEqual({ action: "move-caret", cursor: 0 }); + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: true, + text: "line1\nline2", + cursor: 0, + }), + ).toEqual({ action: "history" }); + }); + + it("ignores non-collapsed selections", () => { + expect( + resolveComposerInputHistoryKeyAction({ + direction: "up", + browsing: false, + text: "hello", + cursor: 0, + selectionEnd: 3, + }), + ).toEqual({ action: "none" }); + }); +}); + +describe("shouldNavigateComposerInputHistory", () => { + it("is true only at the history edge", () => { + expect( + shouldNavigateComposerInputHistory({ + direction: "up", + browsing: false, + text: "hello", + cursor: 0, + }), + ).toBe(true); + expect( + shouldNavigateComposerInputHistory({ + direction: "up", + browsing: false, + text: "hello", + cursor: 2, + }), + ).toBe(false); + }); +}); + +describe("line helpers", () => { + it("detects first and last line", () => { + expect(isComposerCursorOnFirstLine("a\nb", 1)).toBe(true); + expect(isComposerCursorOnFirstLine("a\nb", 2)).toBe(false); + expect(isComposerCursorOnLastLine("a\nb", 1)).toBe(false); + expect(isComposerCursorOnLastLine("a\nb", 2)).toBe(true); + }); +}); diff --git a/packages/shared/src/composerInputHistory.ts b/packages/shared/src/composerInputHistory.ts new file mode 100644 index 000000000000..bf838121fa16 --- /dev/null +++ b/packages/shared/src/composerInputHistory.ts @@ -0,0 +1,305 @@ +/** + * Shell-style composer prompt history. + * + * - Up/Down browse previously submitted inputs (oldest → newest in `entries`). + * - Leaving the live draft stashes temporary input and restores it when returning. + * - Edits while browsing are transient; navigating away discards them unless submitted. + */ + +export type ComposerInputHistoryState = { + /** Submitted prompts, oldest first. */ + readonly entries: ReadonlyArray; + /** + * Index into `entries` while browsing history. + * `null` means the live draft (not browsing). + */ + readonly browsingIndex: number | null; + /** Draft text captured when first leaving live mode via ArrowUp. */ + readonly stashedDraft: string; +}; + +export const EMPTY_COMPOSER_INPUT_HISTORY: ComposerInputHistoryState = { + entries: [], + browsingIndex: null, + stashedDraft: "", +}; + +export const DEFAULT_COMPOSER_INPUT_HISTORY_MAX_ENTRIES = 100; + +export type ComposerInputHistoryNavigation = + | { readonly handled: false } + | { + readonly handled: true; + readonly state: ComposerInputHistoryState; + readonly value: string; + }; + +function clampCursor(text: string, cursor: number): number { + if (!Number.isFinite(cursor)) return text.length; + return Math.max(0, Math.min(text.length, Math.floor(cursor))); +} + +/** True when the caret is on the first line (or selection is collapsed there). */ +export function isComposerCursorOnFirstLine(text: string, cursor: number): boolean { + const bounded = clampCursor(text, cursor); + return !text.slice(0, bounded).includes("\n"); +} + +/** True when the caret is on the last line (or selection is collapsed there). */ +export function isComposerCursorOnLastLine(text: string, cursor: number): boolean { + const bounded = clampCursor(text, cursor); + return !text.slice(bounded).includes("\n"); +} + +/** + * What ArrowUp/ArrowDown should do in the composer. + * + * Matches common chat UIs (Copilot / Claude / Codex-style): + * 1. Move the caret inside the multi-line input first (top / bottom lines). + * 2. On the first line, move to the document start before history. + * 3. On the last line, move to the document end before history (when browsing). + * 4. Only once the caret is already at that edge does history run. + * + * Non-collapsed selections never intercept (leave native behavior). + */ +export type ComposerInputHistoryKeyAction = + | { readonly action: "none" } + | { readonly action: "move-caret"; readonly cursor: number } + | { readonly action: "history" }; + +export function resolveComposerInputHistoryKeyAction(input: { + readonly direction: "up" | "down"; + readonly browsing: boolean; + readonly text: string; + readonly cursor: number; + readonly selectionEnd?: number; +}): ComposerInputHistoryKeyAction { + const cursor = clampCursor(input.text, input.cursor); + const selectionEnd = clampCursor(input.text, input.selectionEnd ?? input.cursor); + if (cursor !== selectionEnd) { + return { action: "none" }; + } + + if (input.direction === "up") { + if (!isComposerCursorOnFirstLine(input.text, cursor)) { + // Let the editor move toward the top line first. + return { action: "none" }; + } + if (cursor > 0) { + // On the first line: go to the beginning of the composer before history. + return { action: "move-caret", cursor: 0 }; + } + return { action: "history" }; + } + + // down + if (!isComposerCursorOnLastLine(input.text, cursor)) { + return { action: "none" }; + } + if (cursor < input.text.length) { + // On the last line: go to the end before stepping history forward. + return { action: "move-caret", cursor: input.text.length }; + } + // At document end: only history while browsing (restore draft / newer entry). + // When not browsing, leave native no-op / caret behavior. + return input.browsing ? { action: "history" } : { action: "none" }; +} + +/** + * @deprecated Prefer {@link resolveComposerInputHistoryKeyAction}. + * True when ArrowUp/Down should drive history (caret already at the history edge). + */ +export function shouldNavigateComposerInputHistory(input: { + readonly direction: "up" | "down"; + readonly browsing: boolean; + readonly text: string; + readonly cursor: number; + readonly selectionEnd?: number; +}): boolean { + return resolveComposerInputHistoryKeyAction(input).action === "history"; +} + +/** + * Normalize conversation/session prompts into history entries (oldest first). + * Drops empty values and consecutive duplicates; caps length from the newest side. + */ +export function normalizeComposerInputHistoryEntries( + values: ReadonlyArray, + options?: { readonly maxEntries?: number }, +): ReadonlyArray { + const maxEntries = options?.maxEntries ?? DEFAULT_COMPOSER_INPUT_HISTORY_MAX_ENTRIES; + const normalized: string[] = []; + for (const value of values) { + if (value.trim().length === 0) continue; + if (normalized[normalized.length - 1] === value) continue; + normalized.push(value); + } + if (normalized.length <= maxEntries) { + return normalized; + } + return normalized.slice(normalized.length - maxEntries); +} + +/** + * When session history is empty, seed from conversation user prompts (oldest first). + * Matches Copilot/Claude/Codex-style recall: ArrowUp recovers the latest user message + * even before any new submits in this session. + */ +export function seedComposerInputHistoryFromConversation( + state: ComposerInputHistoryState, + conversationUserTexts: ReadonlyArray, + options?: { readonly maxEntries?: number }, +): ComposerInputHistoryState { + if (state.entries.length > 0) { + return state; + } + const entries = normalizeComposerInputHistoryEntries(conversationUserTexts, options); + if (entries.length === 0) { + return state; + } + return { + entries, + browsingIndex: state.browsingIndex, + stashedDraft: state.stashedDraft, + }; +} + +/** + * Record a submitted prompt and return to the live draft. + * Empty (trim) values are ignored. Consecutive duplicate entries are skipped. + */ +export function pushComposerInputHistory( + state: ComposerInputHistoryState, + value: string, + options?: { readonly maxEntries?: number }, +): ComposerInputHistoryState { + if (value.trim().length === 0) { + return { + entries: state.entries, + browsingIndex: null, + stashedDraft: "", + }; + } + + const maxEntries = options?.maxEntries ?? DEFAULT_COMPOSER_INPUT_HISTORY_MAX_ENTRIES; + const last = state.entries[state.entries.length - 1]; + const entries = + last === value + ? state.entries + : [...state.entries, value].slice(Math.max(0, state.entries.length + 1 - maxEntries)); + + return { + entries, + browsingIndex: null, + stashedDraft: "", + }; +} + +/** + * Place an editable value at the newest history position while preserving the + * current live draft on the forward side. ArrowDown restores that draft. + */ +export function recallComposerInputHistory( + state: ComposerInputHistoryState, + recalledValue: string, + currentDraft: string, + options?: { readonly maxEntries?: number }, +): ComposerInputHistoryState { + const maxEntries = options?.maxEntries ?? DEFAULT_COMPOSER_INPUT_HISTORY_MAX_ENTRIES; + const entries = [...state.entries, recalledValue].slice( + Math.max(0, state.entries.length + 1 - maxEntries), + ); + return { + entries, + browsingIndex: entries.length - 1, + stashedDraft: currentDraft, + }; +} + +/** + * Navigate one step through history. + * Returns `handled: false` when the key should fall through (e.g. Down at live draft). + */ +export function navigateComposerInputHistory( + state: ComposerInputHistoryState, + direction: "up" | "down", + currentValue: string, +): ComposerInputHistoryNavigation { + if (state.entries.length === 0) { + return { handled: false }; + } + + if (direction === "up") { + if (state.browsingIndex === null) { + const nextIndex = state.entries.length - 1; + const value = state.entries[nextIndex]; + if (value === undefined) { + return { handled: false }; + } + return { + handled: true, + state: { + entries: state.entries, + browsingIndex: nextIndex, + stashedDraft: currentValue, + }, + value, + }; + } + + if (state.browsingIndex <= 0) { + const value = state.entries[0]; + if (value === undefined) { + return { handled: false }; + } + return { handled: true, state, value }; + } + + const nextIndex = state.browsingIndex - 1; + const value = state.entries[nextIndex]; + if (value === undefined) { + return { handled: false }; + } + return { + handled: true, + state: { + entries: state.entries, + browsingIndex: nextIndex, + stashedDraft: state.stashedDraft, + }, + value, + }; + } + + // down + if (state.browsingIndex === null) { + return { handled: false }; + } + + if (state.browsingIndex >= state.entries.length - 1) { + return { + handled: true, + state: { + entries: state.entries, + browsingIndex: null, + stashedDraft: "", + }, + value: state.stashedDraft, + }; + } + + const nextIndex = state.browsingIndex + 1; + const value = state.entries[nextIndex]; + if (value === undefined) { + return { handled: false }; + } + return { + handled: true, + state: { + entries: state.entries, + browsingIndex: nextIndex, + stashedDraft: state.stashedDraft, + }, + value, + }; +} diff --git a/packages/shared/src/composerTrigger.test.ts b/packages/shared/src/composerTrigger.test.ts index 4b2763854457..ac198611c582 100644 --- a/packages/shared/src/composerTrigger.test.ts +++ b/packages/shared/src/composerTrigger.test.ts @@ -1,6 +1,9 @@ import { describe, expect, it } from "vite-plus/test"; -import { serializeComposerFileLink } from "./composerTrigger.ts"; +import { + parseStandaloneComposerSlashCommand, + serializeComposerFileLink, +} from "./composerTrigger.ts"; describe("serializeComposerFileLink", () => { it("uses the basename as the markdown label", () => { @@ -27,3 +30,10 @@ describe("serializeComposerFileLink", () => { ); }); }); + +describe("parseStandaloneComposerSlashCommand", () => { + it("parses /new without accepting trailing prompt text", () => { + expect(parseStandaloneComposerSlashCommand(" /NEW ")).toBe("new"); + expect(parseStandaloneComposerSlashCommand("/new explain this")).toBeNull(); + }); +}); diff --git a/packages/shared/src/composerTrigger.ts b/packages/shared/src/composerTrigger.ts index 6176d10d7908..00ea722641a1 100644 --- a/packages/shared/src/composerTrigger.ts +++ b/packages/shared/src/composerTrigger.ts @@ -1,5 +1,5 @@ export type ComposerTriggerKind = "path" | "slash-command" | "slash-model" | "skill"; -export type ComposerSlashCommand = "model" | "plan" | "default"; +export type ComposerSlashCommand = "new" | "model" | "plan" | "default"; export interface ComposerTrigger { kind: ComposerTriggerKind; @@ -115,6 +115,19 @@ export function detectComposerTrigger( }; } +export function parseStandaloneComposerSlashCommand( + text: string, +): Exclude | null { + const match = /^\/(new|plan|default)\s*$/i.exec(text.trim()); + if (!match) { + return null; + } + const command = match[1]?.toLowerCase(); + if (command === "new") return "new"; + if (command === "plan") return "plan"; + return "default"; +} + export function replaceTextRange( text: string, rangeStart: number, diff --git a/packages/shared/src/dateTime.test.ts b/packages/shared/src/dateTime.test.ts index 562507de3ac2..049ca95d9b2a 100644 --- a/packages/shared/src/dateTime.test.ts +++ b/packages/shared/src/dateTime.test.ts @@ -86,7 +86,7 @@ describe("compareDateTimeStrings", () => { ]; for (const values of permutations) { - expect(values.toSorted(compareDateTimeStrings)).toEqual(expected); + expect([...values].sort(compareDateTimeStrings)).toEqual(expected); } }); }); diff --git a/packages/shared/src/git.test.ts b/packages/shared/src/git.test.ts index 9d7ed527088d..b4796df56b53 100644 --- a/packages/shared/src/git.test.ts +++ b/packages/shared/src/git.test.ts @@ -241,4 +241,47 @@ describe("applyGitStatusStreamEvent", () => { pr: null, }); }); + + it("preserves a known remote/PR when a snapshot arrives with remote:null", () => { + const current: VcsStatusResult = { + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "feature/demo", + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + pr: { + number: 7, + title: "Demo", + state: "open", + headRef: "feature/demo", + baseRef: "main", + url: "https://github.com/acme/widgets/pull/7", + hasFailingChecks: true, + }, + }; + + const next = applyGitStatusStreamEvent(current, { + _tag: "snapshot", + local: { + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + refName: "feature/demo", + hasWorkingTreeChanges: true, + workingTree: { + files: [{ path: "src/demo.ts", insertions: 1, deletions: 0 }], + insertions: 1, + deletions: 0, + }, + }, + remote: null, + }); + + expect(next.pr).toEqual(current.pr); + expect(next.hasWorkingTreeChanges).toBe(true); + }); }); diff --git a/packages/shared/src/git.ts b/packages/shared/src/git.ts index 8e618d2d6441..5acd3e92b52c 100644 --- a/packages/shared/src/git.ts +++ b/packages/shared/src/git.ts @@ -329,6 +329,12 @@ export function applyGitStatusStreamEvent( ): VcsStatusResult { switch (event._tag) { case "snapshot": + // A stream can emit snapshot with remote:null while the remote poller is still + // cold. Never wipe a previously known remote/PR with EMPTY defaults (pr:null) — + // that is a major source of Discord title badge flip-flops (▫️⇄❌🔀). + if (event.remote === null && current !== null) { + return mergeGitStatusParts(event.local, toRemoteStatusPart(current)); + } return mergeGitStatusParts(event.local, event.remote); case "localUpdated": return mergeGitStatusParts(event.local, current ? toRemoteStatusPart(current) : null); diff --git a/packages/shared/src/identityAvatar.test.ts b/packages/shared/src/identityAvatar.test.ts new file mode 100644 index 000000000000..d7480c89a24c --- /dev/null +++ b/packages/shared/src/identityAvatar.test.ts @@ -0,0 +1,80 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + identityAvatar, + identityAvatarColors, + identityInitials, + IDENTITY_AVATAR_PALETTE, +} from "./identityAvatar.ts"; + +describe("identityInitials", () => { + it("uses two words from display name", () => { + expect(identityInitials({ username: "patroza", name: "Patrick Roza" })).toBe("PR"); + }); + + it("uses first two letters of a single name token", () => { + expect(identityInitials({ name: "Julius" })).toBe("JU"); + }); + + it("falls back to username", () => { + expect(identityInitials({ username: "patroza" })).toBe("PA"); + }); + + it("handles short username", () => { + expect(identityInitials({ username: "ab" })).toBe("AB"); + expect(identityInitials({ username: "x" })).toBe("X"); + }); + + it("returns ? when empty", () => { + expect(identityInitials({})).toBe("?"); + expect(identityInitials({ username: " ", name: "" })).toBe("?"); + }); + + it("handles CJK name without surrogate splits", () => { + expect(identityInitials({ name: "田中 太郎" })).toBe("田太"); + }); + + it("handles CJK username", () => { + expect(identityInitials({ username: "田中" })).toBe("田中"); + }); + + it("skips emoji-only name to username when possible", () => { + // emoji has no L/N letters — falls through to code points of name + const initials = identityInitials({ name: "😀😀", username: "pat" }); + expect(initials.length).toBeGreaterThan(0); + expect(initials).not.toMatch(/[\uD800-\uDFFF]/u); + }); +}); + +describe("identityAvatarColors", () => { + it("is deterministic for the same seed", () => { + expect(identityAvatarColors("patroza")).toEqual(identityAvatarColors("patroza")); + }); + + it("varies across different seeds when possible", () => { + const a = identityAvatarColors("patroza"); + const b = identityAvatarColors("julius"); + expect(IDENTITY_AVATAR_PALETTE).toContainEqual(a); + expect(IDENTITY_AVATAR_PALETTE).toContainEqual(b); + }); +}); + +describe("identityAvatar", () => { + it("combines initials, label, and colors", () => { + const avatar = identityAvatar({ + personId: "patroza", + username: "patroza", + name: "Patrick Roza", + }); + expect(avatar.initials).toBe("PR"); + expect(avatar.label).toBe("Patrick Roza"); + expect(avatar.backgroundColor).toMatch(/^#/); + expect(avatar.color).toBe("#FFFFFF"); + }); + + it("keeps color seed on personId when username changes", () => { + const a = identityAvatar({ personId: "p1", username: "old" }); + const b = identityAvatar({ personId: "p1", username: "new" }); + expect(a.backgroundColor).toBe(b.backgroundColor); + }); +}); diff --git a/packages/shared/src/identityAvatar.ts b/packages/shared/src/identityAvatar.ts new file mode 100644 index 000000000000..ab817efe3b0e --- /dev/null +++ b/packages/shared/src/identityAvatar.ts @@ -0,0 +1,122 @@ +/** + * Deterministic micro-avatars from identity usernames (initials + color). + * + * Pure presentation helpers for web/mobile — no network, no assets. + * Real photo URLs can replace these later; seed stays `personId` / `username`. + * + * See docs/architecture/source-and-identity.md + */ + +export type IdentityAvatarColors = { + readonly backgroundColor: string; + readonly color: string; +}; + +export type IdentityAvatarModel = IdentityAvatarColors & { + /** 1–2 uppercase letters for the chip. */ + readonly initials: string; + /** Accessible label, usually the username or display name. */ + readonly label: string; +}; + +/** + * Fixed palette (background + readable foreground). Indexed by a stable hash of + * the person key so the same user always gets the same chip across clients. + * Colors are slightly muted so dense lists stay calm on dark/light UIs. + */ +export const IDENTITY_AVATAR_PALETTE: ReadonlyArray = [ + { backgroundColor: "#3B5BDB", color: "#FFFFFF" }, + { backgroundColor: "#0CA678", color: "#FFFFFF" }, + { backgroundColor: "#E67700", color: "#FFFFFF" }, + { backgroundColor: "#9C36B5", color: "#FFFFFF" }, + { backgroundColor: "#0B7285", color: "#FFFFFF" }, + { backgroundColor: "#C2255C", color: "#FFFFFF" }, + { backgroundColor: "#2F9E44", color: "#FFFFFF" }, + { backgroundColor: "#364FC7", color: "#FFFFFF" }, + { backgroundColor: "#D9480F", color: "#FFFFFF" }, + { backgroundColor: "#5F3DC4", color: "#FFFFFF" }, + { backgroundColor: "#087F5B", color: "#FFFFFF" }, + { backgroundColor: "#A61E4D", color: "#FFFFFF" }, +] as const; + +/** FNV-1a 32-bit — fast, stable, no deps. Not part of the public chip API. */ +function hashIdentitySeed(seed: string): number { + let hash = 0x811c9dc5; + for (let i = 0; i < seed.length; i++) { + hash ^= seed.charCodeAt(i); + hash = Math.imul(hash, 0x01000193); + } + return hash >>> 0; +} + +export function identityAvatarColors(seed: string): IdentityAvatarColors { + const index = hashIdentitySeed(seed) % IDENTITY_AVATAR_PALETTE.length; + return IDENTITY_AVATAR_PALETTE[index]!; +} + +/** First up to `count` Unicode code points (not UTF-16 units). */ +function takeCodePoints(value: string, count: number): string { + const points: Array = []; + for (const point of value) { + if (point.trim().length === 0) continue; + points.push(point); + if (points.length >= count) break; + } + return points.join(""); +} + +/** + * Initials from display name when present, otherwise username. + * Uses code points so non-BMP / CJK handles do not split surrogates. + * - "Patrick Roza" → "PR" + * - "patroza" → "PA" + * - "田中" → "田中" + * - empty → "?" + */ +export function identityInitials(input: { + readonly username?: string | null | undefined; + readonly name?: string | null | undefined; +}): string { + const name = input.name?.trim() ?? ""; + if (name.length > 0) { + const words = name.replace(/[_-]+/gu, " ").split(/\s+/u).filter(Boolean); + if (words.length >= 2) { + const a = takeCodePoints(words[0]!, 1); + const b = takeCodePoints(words[1]!, 1); + const pair = `${a}${b}`; + if (pair.length > 0) return pair.toLocaleUpperCase(); + } + if (words.length === 1) { + const two = takeCodePoints(words[0]!, 2); + if (two.length > 0) return two.toLocaleUpperCase(); + } + } + + const username = input.username?.trim() ?? ""; + if (username.length === 0) return "?"; + // Prefer letter/number-like code points; fall back to raw username points. + const alnumLike = [...username].filter((ch) => /[\p{L}\p{N}]/u.test(ch)).join(""); + const source = alnumLike.length > 0 ? alnumLike : username; + const two = takeCodePoints(source, 2); + return two.length > 0 ? two.toLocaleUpperCase() : "?"; +} + +/** + * Build a micro-avatar model. Prefer `personId` as color seed when available so + * renames keep the same chip; fall back to username. + */ +export function identityAvatar(input: { + readonly personId?: string | null | undefined; + readonly username?: string | null | undefined; + readonly name?: string | null | undefined; +}): IdentityAvatarModel { + const username = input.username?.trim() ?? ""; + const name = input.name?.trim() ?? ""; + const seed = (input.personId?.trim() || username || name || "?").toLowerCase(); + const colors = identityAvatarColors(seed); + return { + initials: identityInitials({ username, name }), + label: name.length > 0 ? name : username.length > 0 ? username : "Unknown", + ...colors, + }; +} diff --git a/packages/shared/src/identityMap.lookup.test.ts b/packages/shared/src/identityMap.lookup.test.ts new file mode 100644 index 000000000000..475e24906278 --- /dev/null +++ b/packages/shared/src/identityMap.lookup.test.ts @@ -0,0 +1,43 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + findPersonByDiscordId, + findPersonByGithubId, + findPersonByGithubLogin, + findPersonByJiraAccountId, + findPersonByJiraEmail, + parseIdentityMapDocument, +} from "./identityMap.ts"; + +const people = parseIdentityMapDocument({ + people: { + patroza: { + username: "patroza", + name: "Patrick", + discord: { id: "95218063095377920" }, + github: { login: "patroza", id: "42661" }, + jira: { accountId: "jira-pat", email: "patrick@example.com" }, + }, + julius: { + username: "julius", + github: { login: "juliusmarminge" }, + }, + }, +}); + +describe("identity map platform lookups", () => { + it("finds by discord id", () => { + expect(findPersonByDiscordId(people, "95218063095377920")?.username).toBe("patroza"); + expect(findPersonByDiscordId(people, "0")).toBeNull(); + }); + + it("finds by github login and id", () => { + expect(findPersonByGithubLogin(people, "Patroza")?.username).toBe("patroza"); + expect(findPersonByGithubId(people, 42661)?.username).toBe("patroza"); + }); + + it("finds by jira account and email", () => { + expect(findPersonByJiraAccountId(people, "jira-pat")?.username).toBe("patroza"); + expect(findPersonByJiraEmail(people, "patrick@example.com")?.username).toBe("patroza"); + }); +}); diff --git a/packages/shared/src/identityMap.test.ts b/packages/shared/src/identityMap.test.ts new file mode 100644 index 000000000000..dda0239d8511 --- /dev/null +++ b/packages/shared/src/identityMap.test.ts @@ -0,0 +1,69 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + IdentityMapParseError, + normalizeJiraAccountId, + parseIdentityMapDocument, + resolvePersonByJiraAccountId, +} from "./identityMap.ts"; + +describe("parseIdentityMapDocument", () => { + it("parses people map with usernames", () => { + const people = parseIdentityMapDocument({ + people: { + patroza: { + username: "patroza", + name: "Patrick Roza", + discord: { id: "95218063095377920" }, + github: { login: "patroza", id: "42661" }, + }, + julius: { + username: "Julius", + name: "Julius", + }, + }, + }); + expect(people).toHaveLength(2); + expect(people[0]?.username).toBe("patroza"); + expect(people[1]?.username).toBe("julius"); + expect(people[1]?.personId).toBe("julius"); + }); + + it("rejects free-form invalid usernames", () => { + expect(() => + parseIdentityMapDocument({ + people: [{ username: "pat roza", name: "Bad" }], + }), + ).toThrow(IdentityMapParseError); + }); + + it("rejects duplicate usernames", () => { + expect(() => + parseIdentityMapDocument({ + people: [ + { username: "a", personId: "a" }, + { username: "a", personId: "b" }, + ], + }), + ).toThrow(/duplicate username/); + }); + + it("returns empty for empty document", () => { + expect(parseIdentityMapDocument({})).toEqual([]); + expect(parseIdentityMapDocument({ people: [] })).toEqual([]); + }); + + it("resolves people by Jira accountId", () => { + const people = parseIdentityMapDocument({ + people: { + patroza: { + username: "patroza", + jira: { accountId: "712020:abc" }, + }, + }, + }); + expect(normalizeJiraAccountId("accountid:712020:ABC")).toBe("712020:abc"); + expect(resolvePersonByJiraAccountId(people, "712020:abc")?.username).toBe("patroza"); + expect(resolvePersonByJiraAccountId(people, "nope")).toBeNull(); + }); +}); diff --git a/packages/shared/src/identityMap.ts b/packages/shared/src/identityMap.ts new file mode 100644 index 000000000000..678d39962409 --- /dev/null +++ b/packages/shared/src/identityMap.ts @@ -0,0 +1,343 @@ +/** + * Parse closed-set identity map documents (YAML/JSON). + * Shared by server (and later Discord bot) so ops keep one file format. + * + * See docs/architecture/source-and-identity.md + */ +import * as Schema from "effect/Schema"; + +export type IdentityMapDiscordRef = { + readonly id: string; + readonly username?: string | undefined; +}; + +export type IdentityMapGitHubRef = { + readonly login: string; + readonly id?: string | undefined; + readonly email?: string | undefined; + readonly name?: string | undefined; +}; + +export type IdentityMapJiraRef = { + readonly accountId?: string | undefined; + readonly email?: string | undefined; + readonly displayName?: string | undefined; +}; + +export type IdentityMapPerson = { + readonly personId: string; + readonly username: string; + readonly name?: string | undefined; + readonly discord?: IdentityMapDiscordRef | undefined; + readonly github?: IdentityMapGitHubRef | undefined; + readonly jira?: IdentityMapJiraRef | undefined; +}; + +export class IdentityMapParseError extends Error { + readonly _tag = "IdentityMapParseError"; + readonly pathLabel: string; + constructor(pathLabel: string, message: string) { + super(message); + this.name = "IdentityMapParseError"; + this.pathLabel = pathLabel; + } +} + +const HANDLE_PATTERN = /^[a-z0-9][a-z0-9._-]*$/; +const HANDLE_MAX = 128; + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function asNonEmptyString(value: unknown): string | undefined { + if (typeof value !== "string") return undefined; + const trimmed = value.trim(); + return trimmed.length > 0 ? trimmed : undefined; +} + +function normalizeHandle(value: string, field: string, label: string): string { + const normalized = value.trim().toLowerCase(); + if ( + normalized.length === 0 || + normalized.length > HANDLE_MAX || + !HANDLE_PATTERN.test(normalized) + ) { + throw new IdentityMapParseError( + label, + `${field} must be a non-empty handle (max ${HANDLE_MAX}, pattern ${HANDLE_PATTERN}): got ${JSON.stringify(value)}`, + ); + } + return normalized; +} + +function asDiscordSnowflake(value: unknown): string | undefined { + const raw = asNonEmptyString(value); + if (raw === undefined) return undefined; + if (!/^\d{1,32}$/u.test(raw)) return undefined; + return raw; +} + +function normalizeLogin(value: unknown): string | undefined { + const raw = asNonEmptyString(value); + if (raw === undefined) return undefined; + const login = raw.replace(/^@/u, "").trim(); + if (login.length === 0) return undefined; + if (!/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/u.test(login)) return undefined; + return login; +} + +function parsePerson(raw: unknown, indexLabel: string, keyHint?: string): IdentityMapPerson { + if (!isRecord(raw)) { + throw new IdentityMapParseError(indexLabel, "person entry must be an object"); + } + + const discordNested = isRecord(raw.discord) ? raw.discord : undefined; + const githubNested = isRecord(raw.github) ? raw.github : undefined; + const jiraNested = isRecord(raw.jira) ? raw.jira : undefined; + + const usernameRaw = + asNonEmptyString(raw.username) ?? + asNonEmptyString(raw.userName) ?? + (keyHint !== undefined && !/^\d+$/u.test(keyHint) ? keyHint : undefined); + if (usernameRaw === undefined) { + throw new IdentityMapParseError(indexLabel, 'missing required "username"'); + } + const username = normalizeHandle(usernameRaw, "username", indexLabel); + + const personIdRaw = asNonEmptyString(raw.personId) ?? asNonEmptyString(raw.id) ?? username; + const personId = normalizeHandle(personIdRaw, "personId", indexLabel); + + const name = asNonEmptyString(raw.name); + + const discordId = + asDiscordSnowflake(discordNested?.id) ?? + asDiscordSnowflake(raw.discordId) ?? + asDiscordSnowflake(raw.discord_id) ?? + (keyHint !== undefined ? asDiscordSnowflake(keyHint) : undefined); + const discordUsername = + asNonEmptyString(discordNested?.username) ?? + asNonEmptyString(raw.discordUsername) ?? + asNonEmptyString(raw.discord_username); + + const githubLogin = + normalizeLogin(githubNested?.login) ?? + normalizeLogin(raw.githubLogin) ?? + normalizeLogin(raw.github_login) ?? + normalizeLogin(raw.github); + const githubId = + asNonEmptyString(githubNested?.id)?.replace(/\D/gu, "") || + asNonEmptyString(raw.githubId)?.replace(/\D/gu, "") || + asNonEmptyString(raw.github_id)?.replace(/\D/gu, "") || + undefined; + const githubEmail = + asNonEmptyString(githubNested?.email) ?? + asNonEmptyString(raw.githubEmail) ?? + asNonEmptyString(raw.github_email); + const githubName = + asNonEmptyString(githubNested?.name) ?? + asNonEmptyString(raw.githubName) ?? + asNonEmptyString(raw.github_name); + + const jiraAccountId = + asNonEmptyString(jiraNested?.accountId) ?? + asNonEmptyString(raw.jiraAccountId) ?? + asNonEmptyString(raw.jira_account_id); + const jiraEmail = + asNonEmptyString(jiraNested?.email) ?? + asNonEmptyString(raw.jiraEmail) ?? + asNonEmptyString(raw.jira_email); + const jiraDisplayName = + asNonEmptyString(jiraNested?.displayName) ?? + asNonEmptyString(raw.jiraDisplayName) ?? + asNonEmptyString(raw.jira_display_name); + + return { + personId, + username, + ...(name !== undefined ? { name } : {}), + ...(discordId !== undefined + ? { + discord: { + id: discordId, + ...(discordUsername !== undefined ? { username: discordUsername } : {}), + }, + } + : {}), + ...(githubLogin !== undefined + ? { + github: { + login: githubLogin, + ...(githubId !== undefined && githubId.length > 0 ? { id: githubId } : {}), + ...(githubEmail !== undefined ? { email: githubEmail } : {}), + ...(githubName !== undefined ? { name: githubName } : {}), + }, + } + : {}), + ...(jiraAccountId !== undefined || jiraEmail !== undefined + ? { + jira: { + ...(jiraAccountId !== undefined ? { accountId: jiraAccountId } : {}), + ...(jiraEmail !== undefined ? { email: jiraEmail } : {}), + ...(jiraDisplayName !== undefined ? { displayName: jiraDisplayName } : {}), + }, + } + : {}), + }; +} + +/** + * Parse identity map document object (already JSON/YAML-parsed). + */ +export function parseIdentityMapDocument(document: unknown): ReadonlyArray { + if (document === null || document === undefined) return []; + if (!isRecord(document)) { + throw new IdentityMapParseError("root", "Identity map root must be an object."); + } + + const peopleNode = document.people; + let people: ReadonlyArray; + + if (Array.isArray(peopleNode)) { + people = peopleNode.map((entry, index) => parsePerson(entry, `[${index}]`)); + } else if (isRecord(peopleNode)) { + people = Object.entries(peopleNode).map(([key, value]) => + parsePerson(value, `people["${key}"]`, key), + ); + } else { + const reserved = new Set(["version", "schema", "$schema"]); + const entries = Object.entries(document).filter(([key]) => !reserved.has(key)); + if (entries.length === 0) return []; + people = entries.map(([key, value]) => parsePerson(value, `["${key}"]`, key)); + } + + const usernames = new Set(); + const personIds = new Set(); + for (const person of people) { + if (usernames.has(person.username)) { + throw new IdentityMapParseError(person.username, `duplicate username "${person.username}"`); + } + if (personIds.has(person.personId)) { + throw new IdentityMapParseError(person.personId, `duplicate personId "${person.personId}"`); + } + usernames.add(person.username); + personIds.add(person.personId); + } + + return people; +} + +export function toIdentityPersonPublic(person: IdentityMapPerson) { + return { + personId: person.personId, + username: person.username, + ...(person.name !== undefined ? { name: person.name } : {}), + links: { + ...(person.discord?.id !== undefined ? { discordId: person.discord.id } : {}), + ...(person.discord?.username !== undefined + ? { discordUsername: person.discord.username } + : {}), + ...(person.github?.login !== undefined ? { githubLogin: person.github.login } : {}), + ...(person.jira?.accountId !== undefined ? { jiraAccountId: person.jira.accountId } : {}), + }, + }; +} + +/** Closed-set platform lookups (case-insensitive where appropriate). */ +export function findPersonByDiscordId( + people: ReadonlyArray, + discordId: string, +): IdentityMapPerson | null { + const id = discordId.trim(); + if (id.length === 0) return null; + return people.find((person) => person.discord?.id === id) ?? null; +} + +/** Resolve the canonical person stamped onto interactive and integration turns. */ +export function findPersonByPersonId( + people: ReadonlyArray, + personId: string, +): IdentityMapPerson | null { + const normalized = personId.trim().toLowerCase(); + if (normalized.length === 0) return null; + return people.find((person) => person.personId.toLowerCase() === normalized) ?? null; +} + +/** Full Git trailer for a mapped person, when GitHub attribution is configured. */ +export function formatCoAuthoredByTrailer(person: IdentityMapPerson): string | null { + const github = person.github; + if (github === undefined) return null; + const explicitEmail = github.email?.trim(); + const id = github.id?.trim(); + const login = github.login.trim(); + const email = + explicitEmail && explicitEmail.length > 0 + ? explicitEmail + : id && id.length > 0 && login.length > 0 + ? `${id}+${login}@users.noreply.github.com` + : null; + if (email === null) return null; + const rawName = github.name ?? person.name ?? person.username; + const name = rawName.replace(/[\r\n]+/gu, " ").trim(); + return name.length > 0 ? `Co-authored-by: ${name} <${email}>` : null; +} + +export function findPersonByGithubLogin( + people: ReadonlyArray, + login: string, +): IdentityMapPerson | null { + const normalized = login.trim().replace(/^@/u, "").toLowerCase(); + if (normalized.length === 0) return null; + return people.find((person) => person.github?.login.toLowerCase() === normalized) ?? null; +} + +export function findPersonByGithubId( + people: ReadonlyArray, + githubId: string | number, +): IdentityMapPerson | null { + const id = String(githubId).replace(/\D/gu, ""); + if (id.length === 0) return null; + return people.find((person) => person.github?.id === id) ?? null; +} + +/** Normalize Atlassian account ids for map lookup (`accountid:` prefix, case). */ +export function normalizeJiraAccountId(accountId: string | null | undefined): string | null { + if (accountId === null || accountId === undefined) return null; + const trimmed = accountId.trim(); + if (trimmed.length === 0) return null; + const withoutPrefix = trimmed.replace(/^accountid:/iu, ""); + return withoutPrefix.length > 0 ? withoutPrefix.toLowerCase() : null; +} + +/** Resolve a closed-set person by Jira Cloud accountId (prefix/case-insensitive). */ +export function resolvePersonByJiraAccountId( + people: ReadonlyArray, + accountId: string | null | undefined, +): IdentityMapPerson | null { + const normalized = normalizeJiraAccountId(accountId); + if (normalized === null) return null; + for (const person of people) { + const mapped = normalizeJiraAccountId(person.jira?.accountId); + if (mapped !== null && mapped === normalized) return person; + } + return null; +} + +export function findPersonByJiraAccountId( + people: ReadonlyArray, + accountId: string, +): IdentityMapPerson | null { + return resolvePersonByJiraAccountId(people, accountId); +} + +export function findPersonByJiraEmail( + people: ReadonlyArray, + email: string, +): IdentityMapPerson | null { + const normalized = email.trim().toLowerCase(); + if (normalized.length === 0) return null; + return people.find((person) => person.jira?.email?.toLowerCase() === normalized) ?? null; +} + +/** Schema re-export helper for tests that want branded contracts after parse. */ +export const IdentityMapPersonCount = Schema.Number; diff --git a/packages/shared/src/keybindings.ts b/packages/shared/src/keybindings.ts index 1107873c8285..380db4ae944c 100644 --- a/packages/shared/src/keybindings.ts +++ b/packages/shared/src/keybindings.ts @@ -40,6 +40,7 @@ export const DEFAULT_KEYBINDINGS: ReadonlyArray = [ { key: "mod+shift+f", command: "projectSearch.toggle", when: "!terminalFocus" }, { key: "mod+alt+shift+t", command: "themeEditor.toggle" }, { key: "mod+s", command: "composer.stash", when: "!terminalFocus" }, + { key: "mod+t", command: "board.open" }, { key: "mod+n", command: "chat.new", when: "!terminalFocus" }, { key: "mod+shift+o", command: "chat.new", when: "!terminalFocus" }, { key: "mod+shift+n", command: "chat.newLocal", when: "!terminalFocus" }, diff --git a/packages/shared/src/orchestrationTiming.test.ts b/packages/shared/src/orchestrationTiming.test.ts index 74e90d45a5e7..4f1061592730 100644 --- a/packages/shared/src/orchestrationTiming.test.ts +++ b/packages/shared/src/orchestrationTiming.test.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from "vite-plus/test"; -import { formatDuration, deriveActiveWorkStartedAt } from "./orchestrationTiming.ts"; +import { deriveActiveWorkStartedAt, formatDuration, formatElapsed } from "./orchestrationTiming.ts"; describe("formatDuration", () => { it.each([ @@ -30,6 +30,12 @@ describe("formatDuration", () => { }); }); +describe("formatElapsed", () => { + it("formats a long run across midnight", () => { + expect(formatElapsed("2026-09-03T22:00:00Z", "2026-09-04T04:59:50Z")).toBe("6h 59m 50s"); + }); +}); + describe("deriveActiveWorkStartedAt", () => { it.each([null, "2026-09-06T23:34:00.000Z"])( "does not time a superseded turn when the active turn differs", diff --git a/packages/shared/src/orchestrationTiming.ts b/packages/shared/src/orchestrationTiming.ts index b87fa9547473..8368e0d7981e 100644 --- a/packages/shared/src/orchestrationTiming.ts +++ b/packages/shared/src/orchestrationTiming.ts @@ -30,6 +30,16 @@ export function formatDuration(durationMs: number): string { return parts.join(" "); } +export function formatElapsed(startIso: string, endIso: string | undefined): string | null { + if (!endIso) return null; + const startedAt = Date.parse(startIso); + const endedAt = Date.parse(endIso); + if (Number.isNaN(startedAt) || Number.isNaN(endedAt) || endedAt < startedAt) { + return null; + } + return formatDuration(endedAt - startedAt); +} + function isLatestTurnSettled( latestTurn: LatestTurnTiming | null, session: SessionActivityState | null, diff --git a/packages/shared/src/productFamily.test.ts b/packages/shared/src/productFamily.test.ts new file mode 100644 index 000000000000..b65b8ec39b96 --- /dev/null +++ b/packages/shared/src/productFamily.test.ts @@ -0,0 +1,52 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + appendOmegentT3ProductHandshake, + isValidOmegentT3ProductHandshake, + OMEGENT_T3_PRODUCT_FAMILY, + OMEGENT_T3_PRODUCT_TOKEN, + parseProductHandshakeFromSearchParams, + parseProductHandshakeFromUrl, + PRODUCT_FAMILY_QUERY_PARAM, + PRODUCT_TOKEN_QUERY_PARAM, +} from "./productFamily.ts"; + +describe("productFamily", () => { + it("appends product handshake query params to absolute urls", () => { + const url = appendOmegentT3ProductHandshake("wss://example.test/ws?wsTicket=abc"); + const parsed = new URL(url); + expect(parsed.searchParams.get("wsTicket")).toBe("abc"); + expect(parsed.searchParams.get(PRODUCT_FAMILY_QUERY_PARAM)).toBe(OMEGENT_T3_PRODUCT_FAMILY); + expect(parsed.searchParams.get(PRODUCT_TOKEN_QUERY_PARAM)).toBe(OMEGENT_T3_PRODUCT_TOKEN); + }); + + it("appends product handshake query params to relative urls", () => { + const url = appendOmegentT3ProductHandshake("/ws"); + expect(url).toContain(`${PRODUCT_FAMILY_QUERY_PARAM}=${OMEGENT_T3_PRODUCT_FAMILY}`); + expect(url).toContain(`${PRODUCT_TOKEN_QUERY_PARAM}=${OMEGENT_T3_PRODUCT_TOKEN}`); + expect(url.startsWith("/ws?")).toBe(true); + }); + + it("parses and validates the omegent-t3 handshake", () => { + const url = appendOmegentT3ProductHandshake("ws://127.0.0.1:3777/ws"); + const handshake = parseProductHandshakeFromUrl(url); + expect(handshake).toEqual({ + productFamily: OMEGENT_T3_PRODUCT_FAMILY, + productToken: OMEGENT_T3_PRODUCT_TOKEN, + }); + expect(isValidOmegentT3ProductHandshake(handshake)).toBe(true); + }); + + it("rejects missing or wrong handshakes", () => { + expect(isValidOmegentT3ProductHandshake(null)).toBe(false); + expect( + isValidOmegentT3ProductHandshake({ + productFamily: OMEGENT_T3_PRODUCT_FAMILY, + productToken: "wrong", + }), + ).toBe(false); + expect( + parseProductHandshakeFromSearchParams(new URLSearchParams("productFamily=omegent-t3")), + ).toBeNull(); + }); +}); diff --git a/packages/shared/src/productFamily.ts b/packages/shared/src/productFamily.ts new file mode 100644 index 000000000000..09df12a1f30e --- /dev/null +++ b/packages/shared/src/productFamily.ts @@ -0,0 +1,70 @@ +/** + * Omegent T3 product handshake. + * + * Our fork servers require connecting clients to present this product family + + * token on the WebSocket upgrade URL. Official / upstream T3 clients do not + * send it, so the first RPC fails with a readable authorization error. + * + * This is intentionally a shared static token baked into fork builds — enough + * to block accidental upstream clients, not a DRM scheme. + */ + +export const OMEGENT_T3_PRODUCT_FAMILY = "omegent-t3" as const; + +/** Static product proof shared by omegent-t3 server + clients. */ +export const OMEGENT_T3_PRODUCT_TOKEN = "omegent-t3-product-v1-9c4e2f71a8b6" as const; + +export const PRODUCT_FAMILY_QUERY_PARAM = "productFamily" as const; +export const PRODUCT_TOKEN_QUERY_PARAM = "productToken" as const; + +export const OMEGENT_T3_CLIENT_REQUIRED_MESSAGE = + "This environment only accepts omegent-t3 clients (web, desktop, mobile, vscode, discord-bot). Official / upstream T3 clients are not supported."; + +export interface ProductHandshake { + readonly productFamily: string; + readonly productToken: string; +} + +export function isValidOmegentT3ProductHandshake( + handshake: ProductHandshake | null | undefined, +): boolean { + if (handshake == null) { + return false; + } + return ( + handshake.productFamily === OMEGENT_T3_PRODUCT_FAMILY && + handshake.productToken === OMEGENT_T3_PRODUCT_TOKEN + ); +} + +export function parseProductHandshakeFromSearchParams( + searchParams: URLSearchParams, +): ProductHandshake | null { + const productFamily = searchParams.get(PRODUCT_FAMILY_QUERY_PARAM)?.trim() ?? ""; + const productToken = searchParams.get(PRODUCT_TOKEN_QUERY_PARAM)?.trim() ?? ""; + if (productFamily.length === 0 || productToken.length === 0) { + return null; + } + return { productFamily, productToken }; +} + +export function parseProductHandshakeFromUrl(url: string | URL): ProductHandshake | null { + try { + const parsed = typeof url === "string" ? new URL(url, "http://localhost") : url; + return parseProductHandshakeFromSearchParams(parsed.searchParams); + } catch { + return null; + } +} + +/** Appends omegent-t3 product handshake query params to a WebSocket/HTTP URL. */ +export function appendOmegentT3ProductHandshake(url: string): string { + const isAbsoluteUrl = /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(url); + const parsed = new URL(url, "http://localhost"); + parsed.searchParams.set(PRODUCT_FAMILY_QUERY_PARAM, OMEGENT_T3_PRODUCT_FAMILY); + parsed.searchParams.set(PRODUCT_TOKEN_QUERY_PARAM, OMEGENT_T3_PRODUCT_TOKEN); + if (isAbsoluteUrl) { + return parsed.toString(); + } + return `${parsed.pathname}${parsed.search}${parsed.hash}`; +} diff --git a/packages/shared/src/projectScripts.ts b/packages/shared/src/projectScripts.ts index 4d98e36b4d70..c75dce5f415b 100644 --- a/packages/shared/src/projectScripts.ts +++ b/packages/shared/src/projectScripts.ts @@ -55,3 +55,91 @@ export function projectScriptRuntimeEnv( export function setupProjectScript(scripts: readonly ProjectScript[]): ProjectScript | null { return scripts.find((script) => script.runOnWorktreeCreate) ?? null; } + +export function worktreeRemoveProjectScript( + scripts: readonly ProjectScript[], +): ProjectScript | null { + return scripts.find((script) => script.runOnWorktreeRemove === true) ?? null; +} + +export function prMergedProjectScript(scripts: readonly ProjectScript[]): ProjectScript | null { + return scripts.find((script) => script.runOnPrMerged === true) ?? null; +} + +export type ProjectLifecycleKind = "worktree-remove" | "pr-merged"; + +/** Change request (PR/MR) associated with a lifecycle run, when known. */ +export interface ProjectLifecyclePrAssociation { + readonly number: number; + readonly url: string; + readonly title?: string | null; + readonly baseRef?: string | null; + readonly headRef?: string | null; + readonly state?: string | null; +} + +/** + * Env for the linked PR/MR. `T3CODE_PR` is the primary handle (URL preferred). + */ +export function projectLifecyclePrEnv( + pr: ProjectLifecyclePrAssociation | null | undefined, +): Record { + if (!pr) { + return {}; + } + const url = pr.url.trim(); + const env: Record = { + T3CODE_PR: url.length > 0 ? url : String(pr.number), + T3CODE_PR_NUMBER: String(pr.number), + }; + if (url.length > 0) { + env.T3CODE_PR_URL = url; + } + const title = pr.title?.trim(); + if (title) { + env.T3CODE_PR_TITLE = title; + } + const baseRef = pr.baseRef?.trim(); + if (baseRef) { + env.T3CODE_PR_BASE_REF = baseRef; + } + const headRef = pr.headRef?.trim(); + if (headRef) { + env.T3CODE_PR_HEAD_REF = headRef; + } + const state = pr.state?.trim(); + if (state) { + env.T3CODE_PR_STATE = state; + } + return env; +} + +export function projectLifecycleRuntimeEnv(input: { + project: { cwd: string }; + worktreePath: string; + lifecycle: ProjectLifecycleKind; + pr?: ProjectLifecyclePrAssociation | null; + /** @deprecated Prefer `pr`. */ + prNumber?: number | null; + /** @deprecated Prefer `pr`. */ + prUrl?: string | null; + extraEnv?: Record; +}): Record { + const pr = + input.pr ?? + (input.prNumber !== undefined && input.prNumber !== null + ? { + number: input.prNumber, + url: input.prUrl?.trim() ?? "", + } + : null); + return projectScriptRuntimeEnv({ + project: input.project, + worktreePath: input.worktreePath, + extraEnv: { + T3CODE_LIFECYCLE: input.lifecycle, + ...projectLifecyclePrEnv(pr), + ...input.extraEnv, + }, + }); +} diff --git a/packages/shared/src/proposedPlan.test.ts b/packages/shared/src/proposedPlan.test.ts new file mode 100644 index 000000000000..d5d106e3dab6 --- /dev/null +++ b/packages/shared/src/proposedPlan.test.ts @@ -0,0 +1,67 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + buildPlanImplementationPrompt, + findLatestProposedPlan, + hasActionableProposedPlan, + proposedPlanTitle, + resolvePlanFollowUpSubmission, + shouldShowPlanFollowUpComposer, + stripDisplayedPlanMarkdown, +} from "./proposedPlan.ts"; + +describe("proposedPlan shared helpers", () => { + it("extracts titles and strips display chrome", () => { + expect(proposedPlanTitle("# Ship it\n\nBody")).toBe("Ship it"); + expect(stripDisplayedPlanMarkdown("# Ship it\n\n## Summary\n\nDo the thing")).toBe( + "Do the thing", + ); + }); + + it("maps plan follow-up submissions", () => { + expect( + resolvePlanFollowUpSubmission({ draftText: "", planMarkdown: "# Plan\n\n- step" }), + ).toEqual({ + text: buildPlanImplementationPrompt("# Plan\n\n- step"), + interactionMode: "default", + }); + expect( + resolvePlanFollowUpSubmission({ + draftText: "prefer REST", + planMarkdown: "# Plan", + }), + ).toEqual({ text: "prefer REST", interactionMode: "plan" }); + }); + + it("finds the latest plan and actionability", () => { + const plans = [ + { + id: "p1", + createdAt: "2026-01-01T00:00:00.000Z", + updatedAt: "2026-01-01T00:00:00.000Z", + turnId: "t1", + planMarkdown: "# Old", + implementedAt: null, + implementationThreadId: null, + }, + { + id: "p2", + createdAt: "2026-01-01T00:00:01.000Z", + updatedAt: "2026-01-01T00:00:02.000Z", + turnId: "t2", + planMarkdown: "# New", + implementedAt: null, + implementationThreadId: null, + }, + ]; + expect(findLatestProposedPlan(plans, "t2")?.id).toBe("p2"); + expect(hasActionableProposedPlan(plans[1]!)).toBe(true); + expect( + shouldShowPlanFollowUpComposer({ + interactionMode: "plan", + hasPendingUserInput: false, + proposedPlan: plans[1]!, + }), + ).toBe(true); + }); +}); diff --git a/packages/shared/src/proposedPlan.ts b/packages/shared/src/proposedPlan.ts new file mode 100644 index 000000000000..fa1bc21b7746 --- /dev/null +++ b/packages/shared/src/proposedPlan.ts @@ -0,0 +1,168 @@ +/** + * Pure proposed-plan helpers shared by web and VS Code. + * Keep free of DOM / React so both clients can reuse the same semantics. + */ + +export interface ProposedPlanFields { + readonly id: string; + readonly createdAt: string; + readonly updatedAt: string; + readonly turnId: string | null; + readonly planMarkdown: string; + readonly implementedAt: string | null; + readonly implementationThreadId: string | null; +} + +export function proposedPlanTitle(planMarkdown: string): string | null { + const heading = planMarkdown.match(/^\s{0,3}#{1,6}\s+(.+)$/m)?.[1]?.trim(); + return heading && heading.length > 0 ? heading : null; +} + +export function stripDisplayedPlanMarkdown(planMarkdown: string): string { + const lines = planMarkdown.trimEnd().split(/\r?\n/); + const sourceLines = lines[0] && /^\s{0,3}#{1,6}\s+/.test(lines[0]) ? lines.slice(1) : [...lines]; + while (sourceLines[0]?.trim().length === 0) { + sourceLines.shift(); + } + const firstHeadingMatch = sourceLines[0]?.match(/^\s{0,3}#{1,6}\s+(.+)$/); + if (firstHeadingMatch?.[1]?.trim().toLowerCase() === "summary") { + sourceLines.shift(); + while (sourceLines[0]?.trim().length === 0) { + sourceLines.shift(); + } + } + return sourceLines.join("\n"); +} + +export function buildCollapsedProposedPlanPreviewMarkdown( + planMarkdown: string, + options?: { + maxLines?: number; + }, +): string { + const maxLines = options?.maxLines ?? 8; + const lines = stripDisplayedPlanMarkdown(planMarkdown) + .trimEnd() + .split(/\r?\n/) + .map((line) => line.trimEnd()); + const previewLines: string[] = []; + let visibleLineCount = 0; + let hasMoreContent = false; + + for (const line of lines) { + const isVisibleLine = line.trim().length > 0; + if (isVisibleLine && visibleLineCount >= maxLines) { + hasMoreContent = true; + break; + } + previewLines.push(line); + if (isVisibleLine) { + visibleLineCount += 1; + } + } + + while (previewLines.length > 0 && previewLines.at(-1)?.trim().length === 0) { + previewLines.pop(); + } + + if (previewLines.length === 0) { + return proposedPlanTitle(planMarkdown) ?? "Plan preview unavailable."; + } + + if (hasMoreContent) { + previewLines.push("", "..."); + } + + return previewLines.join("\n"); +} + +export function buildPlanImplementationPrompt(planMarkdown: string): string { + return `PLEASE IMPLEMENT THIS PLAN:\n${planMarkdown.trim()}`; +} + +export function resolvePlanFollowUpSubmission(input: { draftText: string; planMarkdown: string }): { + text: string; + interactionMode: "default" | "plan"; +} { + const trimmedDraftText = input.draftText.trim(); + if (trimmedDraftText.length > 0) { + return { + text: trimmedDraftText, + interactionMode: "plan", + }; + } + + return { + text: buildPlanImplementationPrompt(input.planMarkdown), + interactionMode: "default", + }; +} + +export function buildPlanImplementationThreadTitle(planMarkdown: string): string { + const title = proposedPlanTitle(planMarkdown); + if (!title) { + return "Implement plan"; + } + return `Implement ${title}`; +} + +export function findLatestProposedPlan( + proposedPlans: ReadonlyArray, + latestTurnId: string | null | undefined, +): T | null { + if (latestTurnId) { + const matchingTurnPlan = [...proposedPlans] + .filter((proposedPlan) => proposedPlan.turnId === latestTurnId) + .sort( + (left, right) => + left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id), + ) + .at(-1); + if (matchingTurnPlan) { + return matchingTurnPlan; + } + } + + const latestPlan = [...proposedPlans] + .sort( + (left, right) => + left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id), + ) + .at(-1); + return latestPlan ?? null; +} + +export function hasActionableProposedPlan( + proposedPlan: Pick | null, +): boolean { + return proposedPlan !== null && proposedPlan.implementedAt === null; +} + +/** + * Plan Ready / implement composer should appear as soon as an unimplemented plan + * exists in plan mode — not only after the agent turn settles. + */ +export function shouldShowPlanFollowUpComposer(input: { + readonly interactionMode: string | undefined | null; + readonly hasPendingUserInput: boolean; + readonly proposedPlan: Pick | null; +}): boolean { + return ( + !input.hasPendingUserInput && + input.interactionMode === "plan" && + hasActionableProposedPlan(input.proposedPlan) + ); +} + +/** Status pill: plan ready outranks Working when a plan is actionable. */ +export function shouldShowPlanReadyStatus(input: { + readonly interactionMode: string | undefined | null; + readonly hasPendingUserInput: boolean; + readonly hasActionableProposedPlan: boolean; +}): boolean { + return ( + !input.hasPendingUserInput && + input.interactionMode === "plan" && + input.hasActionableProposedPlan + ); +} diff --git a/packages/shared/src/providerModelSelection.test.ts b/packages/shared/src/providerModelSelection.test.ts new file mode 100644 index 000000000000..54393d0cbebd --- /dev/null +++ b/packages/shared/src/providerModelSelection.test.ts @@ -0,0 +1,171 @@ +import { ProviderDriverKind, ProviderInstanceId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { + parseProviderModelFlags, + resolveProviderModelSelection, +} from "./providerModelSelection.ts"; + +const providers = [ + { + instanceId: ProviderInstanceId.make("codex"), + driver: ProviderDriverKind.make("codex"), + enabled: true, + installed: true, + models: [ + { + slug: "gpt-5.4", + name: "GPT-5.4", + shortName: "5.4", + isCustom: false, + capabilities: null, + }, + { + slug: "gpt-5.6", + name: "GPT-5.6", + shortName: "5.6", + isCustom: false, + capabilities: null, + }, + ], + }, + { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + models: [ + { + slug: "claude-opus-4-6", + name: "Claude Opus 4.6", + isCustom: false, + capabilities: null, + }, + ], + }, + { + instanceId: ProviderInstanceId.make("grok"), + driver: ProviderDriverKind.make("grok"), + enabled: true, + installed: true, + models: [ + { + slug: "grok-build", + name: "Grok Build", + isCustom: false, + capabilities: null, + }, + ], + }, + { + instanceId: ProviderInstanceId.make("cursor"), + driver: ProviderDriverKind.make("cursor"), + enabled: true, + installed: true, + models: [ + { + slug: "claude-opus-4-6", + name: "Opus 4.6", + isCustom: false, + capabilities: null, + }, + { + slug: "composer-2", + name: "Composer 2", + isCustom: false, + capabilities: null, + }, + ], + }, +]; + +const fallbackSelection = { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", +}; + +describe("provider/model message settings", () => { + it("strips provider and model flags from the agent prompt", () => { + expect( + parseProviderModelFlags( + "--discord --provider claudeAgent investigate --model claude-opus-4-6 now", + ), + ).toEqual({ + provider: "claudeAgent", + model: "claude-opus-4-6", + discord: true, + prompt: "investigate now", + }); + }); + + it("resolves a provider-only override to an available model", () => { + expect( + resolveProviderModelSelection({ + providers, + preferredSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5.4", + }, + fallbackSelection, + overrideInstanceId: "claudeAgent", + }), + ).toEqual({ + instanceId: "claudeAgent", + model: "claude-opus-4-6", + }); + }); + + it("matches a model-only override to its native provider instead of the sticky default", () => { + expect( + resolveProviderModelSelection({ + providers, + preferredSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + fallbackSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + overrideModel: "gpt-5.6", + }), + ).toEqual({ + instanceId: "codex", + model: "gpt-5.6", + }); + }); + + it("prefers the native Claude provider over Cursor for a Claude model-only override", () => { + expect( + resolveProviderModelSelection({ + providers, + preferredSelection: { + instanceId: ProviderInstanceId.make("grok"), + model: "grok-build", + }, + fallbackSelection, + overrideModel: "claude-opus-4-6", + }), + ).toEqual({ + instanceId: "claudeAgent", + model: "claude-opus-4-6", + }); + }); + + it("keeps the sticky provider when the model-only override is available there", () => { + expect( + resolveProviderModelSelection({ + providers, + preferredSelection: { + instanceId: ProviderInstanceId.make("cursor"), + model: "composer-2", + }, + fallbackSelection, + overrideModel: "claude-opus-4-6", + }), + ).toEqual({ + instanceId: "cursor", + model: "claude-opus-4-6", + }); + }); +}); diff --git a/packages/shared/src/providerModelSelection.ts b/packages/shared/src/providerModelSelection.ts new file mode 100644 index 000000000000..971573dbd97e --- /dev/null +++ b/packages/shared/src/providerModelSelection.ts @@ -0,0 +1,246 @@ +import { type ModelSelection, type ProviderInstanceId } from "@t3tools/contracts"; + +export interface ParsedProviderModelFlags { + readonly provider?: string; + readonly model?: string; + readonly discord: boolean; + readonly prompt: string; +} + +export const DISCORD_LINK_REQUEST_MARKER = "T3 Discord link requested from GitHub: yes"; + +export function parseProviderModelFlags(raw: string): ParsedProviderModelFlags { + const tokens = raw + .trim() + .split(/\s+/u) + .filter((token) => token.length > 0); + let provider: string | undefined; + let model: string | undefined; + let discord = false; + const promptParts: string[] = []; + + for (let index = 0; index < tokens.length; index += 1) { + const token = tokens[index]!; + if (token === "--discord") { + discord = true; + continue; + } + if (token === "--provider" || token === "--model") { + const value = tokens[index + 1]; + if (value !== undefined && !value.startsWith("--")) { + if (token === "--provider") provider = value; + else model = value; + index += 1; + continue; + } + } + promptParts.push(token); + } + + return { + ...(provider === undefined ? {} : { provider }), + ...(model === undefined ? {} : { model }), + discord, + prompt: promptParts.join(" ").trim(), + }; +} + +export interface ProviderModelCatalogEntry { + readonly instanceId: ProviderInstanceId; + readonly driver: string; + readonly enabled: boolean; + readonly installed: boolean; + readonly models: ReadonlyArray<{ + readonly slug: string; + readonly name: string; + readonly shortName?: string | undefined; + }>; +} + +function modelHaystack(model: ProviderModelCatalogEntry["models"][number]): string { + return `${model.slug} ${model.name} ${model.shortName ?? ""}`.toLowerCase(); +} + +/** + * Guess the native driver for a model query so multi-provider catalogs + * (e.g. Cursor + Claude both listing Opus) pick the first-party provider. + */ +function nativeDriverHint(desired: string): string | undefined { + const needle = desired.toLowerCase(); + if (needle.includes("grok")) return "grok"; + if (needle.includes("kimi")) return "kimi"; + if (needle.includes("composer") || needle === "auto") return "cursor"; + if ( + needle.includes("claude") || + needle.includes("opus") || + needle.includes("sonnet") || + needle.includes("haiku") + ) { + return "claudeAgent"; + } + if (needle.includes("gpt") || needle.includes("codex") || /^5\.\d/.test(needle)) { + return "codex"; + } + return undefined; +} + +type CatalogModelMatch = { + readonly provider: ProviderModelCatalogEntry; + readonly slug: string; + readonly exactSlug: boolean; + readonly catalogIndex: number; +}; + +/** Match a model on one provider without falling back to that provider's default. */ +function matchModelOnProvider( + provider: ProviderModelCatalogEntry, + desired: string, + catalogIndex: number, +): CatalogModelMatch | undefined { + if (provider.models.length === 0) return undefined; + const needle = desired.toLowerCase().trim(); + if (needle === "") return undefined; + + const exactSlug = provider.models.find((model) => model.slug.toLowerCase() === needle); + if (exactSlug !== undefined) { + return { provider, slug: exactSlug.slug, exactSlug: true, catalogIndex }; + } + + const fuzzy = provider.models.find((model) => modelHaystack(model).includes(needle)); + if (fuzzy !== undefined) { + return { provider, slug: fuzzy.slug, exactSlug: false, catalogIndex }; + } + + return undefined; +} + +/** + * When only a model is requested, pick the best provider that catalogs it. + * Prefers sticky/preferred provider (same-provider switches), then exact slug, + * then native driver for the model name, then default instance id. + */ +function resolveModelOnlySelection(input: { + readonly available: ReadonlyArray; + readonly desiredModel: string; + readonly preferredInstanceId: string; +}): ModelSelection | undefined { + const matches: CatalogModelMatch[] = []; + for (let index = 0; index < input.available.length; index += 1) { + const provider = input.available[index]!; + const match = matchModelOnProvider(provider, input.desiredModel, index); + if (match !== undefined) matches.push(match); + } + if (matches.length === 0) return undefined; + + const preferredInstanceId = input.preferredInstanceId; + const preferredDriver = + input.available.find((provider) => provider.instanceId === preferredInstanceId)?.driver ?? + input.available.find((provider) => provider.driver === preferredInstanceId)?.driver; + const nativeDriver = nativeDriverHint(input.desiredModel); + + const rank = (match: CatalogModelMatch): number => { + const isPreferredInstance = + match.provider.instanceId === preferredInstanceId || + match.provider.driver === preferredInstanceId; + const isPreferredDriver = + preferredDriver !== undefined && match.provider.driver === preferredDriver; + const isNativeDriver = nativeDriver !== undefined && match.provider.driver === nativeDriver; + const isDefaultInstance = match.provider.instanceId === match.provider.driver; + + // Lower is better. Preferred instance wins so sticky same-provider model + // switches stay put even when another provider also lists the model. + let score = 0; + if (!isPreferredInstance) score += 1_000; + if (!match.exactSlug) score += 100; + if (!isNativeDriver) score += 40; + if (!isPreferredDriver) score += 20; + if (!isDefaultInstance) score += 10; + score += match.catalogIndex; + return score; + }; + + matches.sort((left, right) => rank(left) - rank(right)); + const best = matches[0]!; + return { instanceId: best.provider.instanceId, model: best.slug }; +} + +function resolveModelSlug( + provider: ProviderModelCatalogEntry, + desired: string | undefined, +): string | undefined { + if (provider.models.length === 0) return undefined; + if (desired !== undefined && desired.trim() !== "") { + const match = matchModelOnProvider(provider, desired, 0); + if (match !== undefined) return match.slug; + } + return ( + provider.models.find((model) => !model.slug.includes("custom"))?.slug ?? + provider.models[0]?.slug + ); +} + +export function resolveProviderModelSelection(input: { + readonly providers: ReadonlyArray; + readonly projectDefault?: ModelSelection | null; + readonly preferredSelection?: ModelSelection | null; + readonly fallbackSelection: ModelSelection; + readonly overrideInstanceId?: string; + readonly overrideModel?: string; +}): ModelSelection { + if (input.overrideInstanceId !== undefined && input.overrideModel !== undefined) { + return { + instanceId: input.overrideInstanceId as ProviderInstanceId, + model: input.overrideModel, + }; + } + + const available = input.providers.filter( + (provider) => provider.enabled && provider.installed && provider.models.length > 0, + ); + const desiredInstance = + input.overrideInstanceId ?? + input.preferredSelection?.instanceId ?? + input.fallbackSelection.instanceId; + const desiredModel = + input.overrideModel ?? input.preferredSelection?.model ?? input.fallbackSelection.model; + + // Model-only override: match the model to a cataloged provider instead of + // forcing the sticky/default provider (e.g. gpt-5.6 must not run on Grok). + if (input.overrideModel !== undefined && input.overrideInstanceId === undefined) { + const modelOnly = resolveModelOnlySelection({ + available, + desiredModel: input.overrideModel, + preferredInstanceId: desiredInstance, + }); + if (modelOnly !== undefined) return modelOnly; + } + + const preferredProvider = + available.find((provider) => provider.instanceId === desiredInstance) ?? + available.find((provider) => provider.driver === desiredInstance); + if (preferredProvider !== undefined) { + const model = resolveModelSlug(preferredProvider, desiredModel); + if (model !== undefined) return { instanceId: preferredProvider.instanceId, model }; + } + + if (input.projectDefault !== null && input.projectDefault !== undefined) { + const projectProvider = available.find( + (provider) => provider.instanceId === input.projectDefault!.instanceId, + ); + if (projectProvider !== undefined) { + return { + instanceId: projectProvider.instanceId, + model: + resolveModelSlug(projectProvider, input.projectDefault.model) ?? + input.projectDefault.model, + }; + } + } + + const fallbackProvider = available[0]; + if (fallbackProvider === undefined) return input.fallbackSelection; + return { + instanceId: fallbackProvider.instanceId, + model: resolveModelSlug(fallbackProvider, desiredModel) ?? fallbackProvider.models[0]!.slug, + }; +} diff --git a/packages/shared/src/schemaJson.test.ts b/packages/shared/src/schemaJson.test.ts index 4a4d16da0b30..c808a9b7c515 100644 --- a/packages/shared/src/schemaJson.test.ts +++ b/packages/shared/src/schemaJson.test.ts @@ -57,15 +57,6 @@ Done.`), expect(() => decodeLenientJson('{ "enabled": true,, }')).toThrow(); }); - it("preserves commas before brackets inside string values", () => { - // A comma inside a string value that happens to precede `}`/`]` must not - // be stripped as if it were a trailing comma. - expect(decodeLenientJson('{"note":"a,]"}')).toEqual({ note: "a,]" }); - expect(decodeLenientJson('{"list":["x,}"]}')).toEqual({ list: ["x,}"] }); - // Genuine trailing commas are still removed. - expect(decodeLenientJson('{"values":[1, 2,],}')).toEqual({ values: [1, 2] }); - }); - it("formats schema failures with paths without exposing invalid values", () => { const decodeCredential = decodeJsonResult(Schema.Struct({ token: Schema.Number })); const decoded = decodeCredential('{"token":"credential=secret-value"}'); diff --git a/packages/shared/src/schemaJson.ts b/packages/shared/src/schemaJson.ts index 076ff67b62df..5725c9f3255a 100644 --- a/packages/shared/src/schemaJson.ts +++ b/packages/shared/src/schemaJson.ts @@ -177,14 +177,8 @@ const parseLenientJsonGetter = SchemaGetter.onSome((input: string) => { (match, stringLiteral: string | undefined) => (stringLiteral ? match : ""), ); - // Strip trailing commas before `}` or `]`. The alternation preserves quoted - // strings so a comma inside a string value (e.g. `{"note":"a,]"}`) is not - // mistaken for a trailing comma and removed. - stripped = stripped.replace( - /("(?:[^"\\]|\\.)*")|,(\s*[}\]])/g, - (match, stringLiteral: string | undefined, bracket: string | undefined) => - stringLiteral ? match : (bracket ?? ""), - ); + // Strip trailing commas before `}` or `]`. + stripped = stripped.replace(/,(\s*[}\]])/g, "$1"); return decodeJsonString(stripped).pipe( Effect.map(Option.some), diff --git a/packages/shared/src/semver.test.ts b/packages/shared/src/semver.test.ts index ed3e1896aaf6..8cbbc150fc96 100644 --- a/packages/shared/src/semver.test.ts +++ b/packages/shared/src/semver.test.ts @@ -1,11 +1,6 @@ import { describe, expect, it } from "vite-plus/test"; -import { - compareSemverVersions, - normalizeSemverVersion, - parseSemver, - satisfiesSemverRange, -} from "./semver.ts"; +import { compareSemverVersions, normalizeSemverVersion, satisfiesSemverRange } from "./semver.ts"; describe("semver helpers", () => { it("matches supported range groups", () => { @@ -23,25 +18,6 @@ describe("semver helpers", () => { expect(normalizeSemverVersion("2.1")).toBe("2.1.0"); }); - it("normalizes and parses shorthand major-only versions", () => { - expect(normalizeSemverVersion("20")).toBe("20.0.0"); - expect(normalizeSemverVersion("v18")).toBe("v18.0.0"); - expect(normalizeSemverVersion("20-rc.1")).toBe("20.0.0-rc.1"); - expect(parseSemver("20")).toEqual({ major: 20, minor: 0, patch: 0, prerelease: [] }); - }); - - it("compares shorthand versions numerically instead of lexically", () => { - // Regression: "20" vs "9" previously fell back to string comparison, which - // ordered "20" before "9" ("2" < "9"). - expect(compareSemverVersions("20", "9")).toBeGreaterThan(0); - expect(compareSemverVersions("18", "18.0.0")).toBe(0); - }); - - it("still rejects non-numeric shorthand and keeps empty input empty", () => { - expect(parseSemver("abc")).toBeNull(); - expect(normalizeSemverVersion("")).toBe(""); - }); - it("compares prerelease versions before stable versions", () => { expect(compareSemverVersions("2.1.111-beta.1", "2.1.111")).toBeLessThan(0); }); diff --git a/packages/shared/src/semver.ts b/packages/shared/src/semver.ts index a765b065fc6d..1a73e33042f1 100644 --- a/packages/shared/src/semver.ts +++ b/packages/shared/src/semver.ts @@ -17,12 +17,7 @@ export function normalizeSemverVersion(version: string): string { } } - // Pad shorthand versions ("20" or "20.1") up to three segments so major-only - // and minor-only inputs parse and compare numerically. This matches - // satisfiesSemverRange, which already treats a missing minor/patch as 0. The - // length > 0 guard keeps empty/garbage input empty (parseSemver still - // rejects it), and inputs with more than three segments are left untouched. - while (segments.length > 0 && segments.length < 3) { + if (segments.length === 2) { segments.push("0"); } diff --git a/packages/shared/src/serverRuntime.ts b/packages/shared/src/serverRuntime.ts new file mode 100644 index 000000000000..a7e3cf164c62 --- /dev/null +++ b/packages/shared/src/serverRuntime.ts @@ -0,0 +1,15 @@ +import * as Schema from "effect/Schema"; + +// Deliberately distinct from ServerConfig.serverRuntimeStatePath +// (`server-runtime.json`), which is the replaceable health heartbeat. +export const SERVER_RUNTIME_DESCRIPTOR_FILE = "server-owner.json"; +export const LOCAL_BOOTSTRAP_CREDENTIAL_FILE = "local-bootstrap-credential"; + +export const ServerRuntimeDescriptor = Schema.Struct({ + version: Schema.Literal(1), + pid: Schema.Int, + stateDir: Schema.String, + httpBaseUrl: Schema.String, + startedAt: Schema.String, +}); +export type ServerRuntimeDescriptor = typeof ServerRuntimeDescriptor.Type; diff --git a/packages/shared/src/sessionWake.test.ts b/packages/shared/src/sessionWake.test.ts new file mode 100644 index 000000000000..2b0994668546 --- /dev/null +++ b/packages/shared/src/sessionWake.test.ts @@ -0,0 +1,99 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + resolveOrphanSettleSessionStatus, + sessionHadInProgressWork, + sessionNeedsWakeUp, +} from "./sessionWake.ts"; + +describe("sessionHadInProgressWork", () => { + it("is true when an active turn id is set", () => { + expect(sessionHadInProgressWork({ activeTurnId: "turn-1" })).toBe(true); + }); + + it("is true when the latest turn is still running", () => { + expect(sessionHadInProgressWork({ latestTurnState: "running" })).toBe(true); + }); + + it("is true for pending approval / user input", () => { + expect(sessionHadInProgressWork({ hasPendingApprovals: true })).toBe(true); + expect(sessionHadInProgressWork({ hasPendingUserInput: true })).toBe(true); + }); + + it("is false for a zombie running session with a completed turn and no active id", () => { + expect( + sessionHadInProgressWork({ + activeTurnId: null, + latestTurnState: "completed", + }), + ).toBe(false); + }); +}); + +describe("resolveOrphanSettleSessionStatus", () => { + it("interrupts only when work was in progress", () => { + expect(resolveOrphanSettleSessionStatus({ hadInProgressWork: true })).toBe("interrupted"); + expect(resolveOrphanSettleSessionStatus({ hadInProgressWork: false })).toBe("ready"); + }); + + it("allows stopped as the in-progress preferred status", () => { + expect( + resolveOrphanSettleSessionStatus({ + hadInProgressWork: true, + preferredWhenInProgress: "stopped", + }), + ).toBe("stopped"); + }); +}); + +describe("sessionNeedsWakeUp", () => { + it("requires interrupted session status", () => { + expect( + sessionNeedsWakeUp({ + sessionStatus: "ready", + latestTurnState: "running", + }), + ).toBe(false); + }); + + it("wakes when interrupted mid-turn (stale running latest turn)", () => { + expect( + sessionNeedsWakeUp({ + sessionStatus: "interrupted", + activeTurnId: null, + latestTurnState: "running", + }), + ).toBe(true); + }); + + it("does not wake zombie interrupted sessions with a completed turn", () => { + expect( + sessionNeedsWakeUp({ + sessionStatus: "interrupted", + activeTurnId: null, + latestTurnState: "completed", + latestTurnCompletedAt: "2026-07-01T00:00:00.000Z", + }), + ).toBe(false); + }); + + it("does not wake interrupted sessions with no turn at all", () => { + expect( + sessionNeedsWakeUp({ + sessionStatus: "interrupted", + activeTurnId: null, + latestTurnState: null, + }), + ).toBe(false); + }); + + it("wakes interrupted turns that never completed", () => { + expect( + sessionNeedsWakeUp({ + sessionStatus: "interrupted", + latestTurnState: "interrupted", + latestTurnCompletedAt: null, + }), + ).toBe(true); + }); +}); diff --git a/packages/shared/src/sessionWake.ts b/packages/shared/src/sessionWake.ts new file mode 100644 index 000000000000..b2408bd295cb --- /dev/null +++ b/packages/shared/src/sessionWake.ts @@ -0,0 +1,77 @@ +/** + * Shared wake-up / orphan-settle helpers. + * + * Problem: server restarts used to mark every session that *claimed* to be + * `running`/`starting` as `interrupted` ("Wake Required"), including idle + * zombies with no active turn. That resurrects old threads across all clients. + * + * Rules: + * - Only settle as `interrupted` when real work was in flight. + * - Only show Wake Required when the session is interrupted *and* the latest + * turn still looks unfinished (guards legacy false positives already stored). + */ + +export type OrphanSettleSessionStatus = "interrupted" | "ready" | "stopped"; + +/** + * True when a thread had real agent work in flight. + * Used **before** orphan settle to choose `interrupted` vs `ready`. + */ +export function sessionHadInProgressWork(input: { + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly hasPendingApprovals?: boolean; + readonly hasPendingUserInput?: boolean; +}): boolean { + if (input.activeTurnId != null && String(input.activeTurnId).trim() !== "") { + return true; + } + if (input.latestTurnState === "running") return true; + if (input.hasPendingApprovals === true) return true; + if (input.hasPendingUserInput === true) return true; + return false; +} + +/** + * Status to write when settling an orphan/zombie session after restart or reaper. + * Zombie `running` with no in-progress work becomes `ready` (no Wake Required). + */ +export function resolveOrphanSettleSessionStatus(input: { + readonly hadInProgressWork: boolean; + readonly preferredWhenInProgress?: Extract; +}): OrphanSettleSessionStatus { + if (input.hadInProgressWork) { + return input.preferredWhenInProgress ?? "interrupted"; + } + return "ready"; +} + +/** + * True when clients should show Wake Required / Discord Continue notice. + * + * After a correct settle, `status === "interrupted"` alone is enough — but we + * still require incomplete-turn evidence so legacy false positives (interrupted + * with a completed/absent turn) stay quiet. + */ +export function sessionNeedsWakeUp(input: { + readonly sessionStatus?: string | null | undefined; + readonly activeTurnId?: string | null | undefined; + readonly latestTurnState?: string | null | undefined; + readonly latestTurnCompletedAt?: string | null | undefined; +}): boolean { + if (input.sessionStatus !== "interrupted") return false; + + if (input.activeTurnId != null && String(input.activeTurnId).trim() !== "") { + return true; + } + // Mid-turn crash: turn row often still says running after session settle. + if (input.latestTurnState === "running") return true; + // Explicit interrupted turn without a completion timestamp. + if ( + input.latestTurnState === "interrupted" && + (input.latestTurnCompletedAt == null || input.latestTurnCompletedAt === "") + ) { + return true; + } + return false; +} diff --git a/packages/shared/src/sourceAttribution.test.ts b/packages/shared/src/sourceAttribution.test.ts new file mode 100644 index 000000000000..ce8f831673ef --- /dev/null +++ b/packages/shared/src/sourceAttribution.test.ts @@ -0,0 +1,120 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + buildSourceRefFromClaim, + mergeParticipantSummaries, + nextOriginSource, + resolveSourceChannel, + sourceChannelFromDeviceType, +} from "./sourceAttribution.ts"; + +describe("sourceChannelFromDeviceType", () => { + it("maps known device types", () => { + expect(sourceChannelFromDeviceType("desktop")).toBe("desktop"); + expect(sourceChannelFromDeviceType("mobile")).toBe("mobile"); + expect(sourceChannelFromDeviceType("tablet")).toBe("mobile"); + expect(sourceChannelFromDeviceType("bot")).toBe("bot"); + expect(sourceChannelFromDeviceType("unknown")).toBe("unknown"); + expect(sourceChannelFromDeviceType(undefined)).toBe("unknown"); + }); +}); + +describe("resolveSourceChannel", () => { + it("accepts the VS Code integration channel hint", () => { + expect(resolveSourceChannel({ deviceType: "desktop", channelHint: "vscode" })).toBe("vscode"); + }); + + it("prefers explicit channel hints", () => { + expect(resolveSourceChannel({ deviceType: "desktop", channelHint: "discord" })).toBe("discord"); + }); + + it("falls back to device type", () => { + expect(resolveSourceChannel({ deviceType: "mobile" })).toBe("mobile"); + }); +}); + +describe("buildSourceRefFromClaim", () => { + it("stamps person fields from claim", () => { + expect( + buildSourceRefFromClaim({ + personId: "patroza", + username: "patroza", + channel: "desktop", + }), + ).toEqual({ + channel: "desktop", + personId: "patroza", + username: "patroza", + }); + }); +}); + +describe("nextOriginSource", () => { + it("sets origin from first user source only", () => { + const first = buildSourceRefFromClaim({ + personId: "patroza", + username: "patroza", + channel: "web", + }); + const second = buildSourceRefFromClaim({ + personId: "julius", + username: "julius", + channel: "desktop", + }); + expect(nextOriginSource({ current: null, messageSource: first, role: "user" })).toEqual(first); + expect(nextOriginSource({ current: first, messageSource: second, role: "user" })).toEqual( + first, + ); + expect(nextOriginSource({ current: null, messageSource: first, role: "assistant" })).toBeNull(); + }); +}); + +describe("mergeParticipantSummaries", () => { + it("appends distinct people and keeps origin first", () => { + const origin = { + personId: "patroza", + username: "patroza", + firstChannel: "discord" as const, + firstParticipatedAt: "2026-01-01T00:00:00.000Z", + }; + const merged = mergeParticipantSummaries({ + existing: [origin], + source: { personId: "julius", username: "julius", channel: "desktop" }, + participatedAt: "2026-01-01T00:01:00.000Z", + originPersonId: "patroza", + }); + expect(merged.map((entry) => entry.personId)).toEqual(["patroza", "julius"]); + }); + + it("ignores unmapped sources and folds a person's channels into one summary", () => { + const existing = [ + { + personId: "patroza", + username: "patroza", + firstChannel: "discord" as const, + firstParticipatedAt: "2026-01-01T00:00:00.000Z", + }, + ]; + expect( + mergeParticipantSummaries({ + existing, + source: { channel: "discord" }, + participatedAt: "2026-01-01T00:01:00.000Z", + }), + ).toEqual(existing); + const folded = mergeParticipantSummaries({ + existing, + source: { personId: "patroza", username: "patroza", channel: "desktop" }, + participatedAt: "2026-01-01T00:02:00.000Z", + }); + expect(folded).toHaveLength(1); + expect(folded[0]?.channels).toEqual(["discord", "desktop"]); + expect( + mergeParticipantSummaries({ + existing: folded, + source: { personId: "patroza", username: "patroza", channel: "desktop" }, + participatedAt: "2026-01-01T00:03:00.000Z", + }), + ).toBe(folded); + }); +}); diff --git a/packages/shared/src/sourceAttribution.ts b/packages/shared/src/sourceAttribution.ts new file mode 100644 index 000000000000..ec9cbd8284e5 --- /dev/null +++ b/packages/shared/src/sourceAttribution.ts @@ -0,0 +1,176 @@ +/** + * Server-side SourceRef helpers and thread participant denormalization. + * + * Clients never invent personId/username — those come from session claim or + * platform map resolution. Channel is derived from auth client device type + * (or an explicit SourceChannel for integrations). + * + * See docs/architecture/source-and-identity.md + */ +import type { AuthClientMetadataDeviceType, SourceChannel } from "@t3tools/contracts"; + +export type SourceRefLike = { + readonly channel: SourceChannel; + readonly personId?: string | undefined; + readonly username?: string | undefined; + readonly location?: { + readonly guildId?: string | undefined; + readonly channelId?: string | undefined; + readonly threadId?: string | undefined; + readonly owner?: string | undefined; + readonly repo?: string | undefined; + readonly number?: number | undefined; + readonly kind?: "pr" | "issue" | undefined; + readonly projectKey?: string | undefined; + readonly issueKey?: string | undefined; + }; + readonly actor?: { + readonly platformId?: string | undefined; + readonly displayName?: string | undefined; + }; +}; + +/** Map auth client deviceType → SourceChannel. */ +export function sourceChannelFromDeviceType( + deviceType: AuthClientMetadataDeviceType | undefined | null, +): SourceChannel { + switch (deviceType) { + case "desktop": + return "desktop"; + case "mobile": + case "tablet": + return "mobile"; + case "bot": + return "bot"; + case "unknown": + case undefined: + case null: + return "unknown"; + default: { + const _exhaustive: never = deviceType; + void _exhaustive; + return "unknown"; + } + } +} + +/** + * Prefer an explicit channel (ClientSourceHint / integration) when present; + * otherwise derive from session deviceType. Web is not a deviceType today — + * browser clients often report desktop; accept explicit "web" when hinted. + */ +export function resolveSourceChannel(input: { + readonly deviceType?: AuthClientMetadataDeviceType | null | undefined; + readonly channelHint?: SourceChannel | null | undefined; +}): SourceChannel { + if (input.channelHint !== undefined && input.channelHint !== null) { + return input.channelHint; + } + return sourceChannelFromDeviceType(input.deviceType); +} + +export function buildSourceRefFromClaim(input: { + readonly personId: string; + readonly username: string; + readonly channel: SourceChannel; + readonly location?: SourceRefLike["location"]; + readonly actor?: SourceRefLike["actor"]; +}): SourceRefLike { + return { + channel: input.channel, + personId: input.personId, + username: input.username, + ...(input.location !== undefined ? { location: input.location } : {}), + ...(input.actor !== undefined ? { actor: input.actor } : {}), + }; +} + +export type ParticipantSummaryLike = { + readonly personId: string; + readonly username: string; + readonly name?: string | undefined; + readonly firstChannel?: SourceChannel | undefined; + readonly channels?: ReadonlyArray | undefined; + readonly firstParticipatedAt: string; +}; + +/** + * Merge a user message SourceRef into ordered participant summaries. + * Origin person stays first when already present; new people append by + * first-participation time (caller passes chronological events). + */ +export function mergeParticipantSummaries(input: { + readonly existing: ReadonlyArray; + readonly source: { + readonly personId?: string | undefined; + readonly username?: string | undefined; + readonly channel: SourceChannel; + readonly name?: string | undefined; + }; + readonly participatedAt: string; + readonly originPersonId?: string | null | undefined; +}): ReadonlyArray { + const personId = input.source.personId; + if (personId === undefined || personId === null || personId.length === 0) { + return input.existing; + } + const username = input.source.username; + if (username === undefined || username === null || username.length === 0) { + return input.existing; + } + + const existingIndex = input.existing.findIndex((entry) => entry.personId === personId); + if (existingIndex !== -1) { + const existingEntry = input.existing[existingIndex]!; + const channels = + existingEntry.channels ?? + (existingEntry.firstChannel === undefined ? [] : [existingEntry.firstChannel]); + if (channels.includes(input.source.channel)) { + return input.existing; + } + return input.existing.map((entry, index) => + index === existingIndex + ? { + ...entry, + channels: [...channels, input.source.channel], + } + : entry, + ); + } + + const nextEntry: ParticipantSummaryLike = { + personId, + username, + ...(input.source.name !== undefined ? { name: input.source.name } : {}), + firstChannel: input.source.channel, + channels: [input.source.channel], + firstParticipatedAt: input.participatedAt, + }; + + const originId = input.originPersonId ?? null; + if (originId !== null && personId === originId) { + return [nextEntry, ...input.existing]; + } + + // Keep origin lead if present, then append by first-seen order. + if (originId !== null) { + const origin = input.existing.find((entry) => entry.personId === originId); + const rest = input.existing.filter((entry) => entry.personId !== originId); + if (origin !== undefined) { + return [origin, ...rest, nextEntry]; + } + } + + return [...input.existing, nextEntry]; +} + +/** First user-message SourceRef becomes origin when none set yet. */ +export function nextOriginSource(input: { + readonly current: SourceRefLike | null | undefined; + readonly messageSource: SourceRefLike | undefined; + readonly role: string; +}): SourceRefLike | null | undefined { + if (input.role !== "user") return input.current; + if (input.current !== undefined && input.current !== null) return input.current; + return input.messageSource ?? input.current ?? null; +} diff --git a/packages/shared/src/sourceControl.test.ts b/packages/shared/src/sourceControl.test.ts index 6a60d6f9b38d..4d2c1e8b0d19 100644 --- a/packages/shared/src/sourceControl.test.ts +++ b/packages/shared/src/sourceControl.test.ts @@ -1,3 +1,4 @@ +import type { VcsStatusChangeRequest, VcsStatusResult } from "@t3tools/contracts"; import { describe, expect, it } from "vite-plus/test"; import { @@ -5,9 +6,84 @@ import { detectSourceControlProviderFromRemoteUrl, getChangeRequestTerminologyForKind, isSshRemoteUrl, + resolveChangeRequestIndicator, resolveChangeRequestPresentation, + resolveThreadChangeRequest, } from "./sourceControl.ts"; +const openPr: VcsStatusChangeRequest = { + number: 42, + title: "Add feature", + url: "https://github.com/org/repo/pull/42", + baseRef: "main", + headRef: "feature/demo", + state: "open", +}; + +function gitStatus( + overrides: Partial & Pick, +): VcsStatusResult { + return { + isRepo: true, + hasPrimaryRemote: true, + isDefaultRef: false, + hasWorkingTreeChanges: false, + workingTree: { files: [], insertions: 0, deletions: 0 }, + hasUpstream: true, + aheadCount: 0, + behindCount: 0, + aheadOfDefaultCount: 0, + pr: null, + ...overrides, + }; +} + +describe("resolveThreadChangeRequest", () => { + it("matches on the live ref or on the change request's head ref", () => { + expect( + resolveThreadChangeRequest("feature/demo", gitStatus({ refName: "main", pr: openPr })), + ).toEqual(openPr); + expect( + resolveThreadChangeRequest( + "feature/demo", + gitStatus({ refName: "feature/demo", pr: openPr }), + ), + ).toEqual(openPr); + }); + + it("returns null when the branch, the status, or the change request is absent", () => { + expect( + resolveThreadChangeRequest("feature/other", gitStatus({ refName: "main", pr: openPr })), + ).toBeNull(); + expect(resolveThreadChangeRequest(null, gitStatus({ refName: "main", pr: openPr }))).toBeNull(); + expect(resolveThreadChangeRequest("feature/demo", null)).toBeNull(); + expect(resolveThreadChangeRequest("feature/demo", gitStatus({ refName: "main" }))).toBeNull(); + }); +}); + +describe("resolveChangeRequestIndicator", () => { + it("labels each state with the provider's own terminology", () => { + expect(resolveChangeRequestIndicator(openPr, undefined)).toEqual({ + state: "open", + number: 42, + label: "PR open", + tooltip: "#42 PR open: Add feature", + url: "https://github.com/org/repo/pull/42", + }); + expect( + resolveChangeRequestIndicator( + { ...openPr, state: "merged" }, + { kind: "gitlab", name: "GitLab", baseUrl: "https://gitlab.com" }, + ), + ).toMatchObject({ state: "merged", label: "MR merged", tooltip: "#42 MR merged: Add feature" }); + }); + + it("returns null without a change request", () => { + expect(resolveChangeRequestIndicator(null, undefined)).toBeNull(); + expect(resolveChangeRequestIndicator(undefined, undefined)).toBeNull(); + }); +}); + describe("source control presentation", () => { it("uses merge request terminology for GitLab", () => { expect(getChangeRequestTerminologyForKind("gitlab")).toEqual({ diff --git a/packages/shared/src/sourceControl.ts b/packages/shared/src/sourceControl.ts index 9f1dc384e749..1a854e0788cb 100644 --- a/packages/shared/src/sourceControl.ts +++ b/packages/shared/src/sourceControl.ts @@ -2,6 +2,8 @@ import type { RepositoryIdentity, SourceControlProviderInfo, SourceControlProviderKind, + VcsStatusChangeRequest, + VcsStatusResult, } from "@t3tools/contracts"; export interface ChangeRequestPresentation { @@ -102,6 +104,66 @@ function resolveChangeRequestPresentationForKind( return resolveChangeRequestPresentation({ kind, name: "", baseUrl: "" }); } +export interface ChangeRequestIndicator { + readonly state: VcsStatusChangeRequest["state"]; + readonly number: number; + readonly label: string; + readonly tooltip: string; + readonly url: string; +} + +/** + * Picks the change request that belongs to `threadBranch` out of a checkout's + * status. The checkout may have moved on to another ref while a thread still + * boxes the branch its change request was opened from, so a head-ref match + * counts even when the live ref differs. + */ +export function resolveThreadChangeRequest( + threadBranch: string | null, + status: VcsStatusResult | null, +): VcsStatusChangeRequest | null { + if (threadBranch === null || status === null) { + return null; + } + const pr = status.pr ?? null; + if (!pr) { + return null; + } + return status.refName === threadBranch || pr.headRef === threadBranch ? pr : null; +} + +/** + * Derives the provider-agnostic wording for a change request badge. Callers map + * {@link ChangeRequestIndicator.state} onto their own palette. + */ +export function resolveChangeRequestIndicator( + pr: VcsStatusChangeRequest | null | undefined, + provider: SourceControlProviderInfo | null | undefined, +): ChangeRequestIndicator | null { + if (!pr) { + return null; + } + const { shortName } = resolveChangeRequestPresentation(provider); + return { + state: pr.state, + number: pr.number, + label: `${shortName} ${pr.state}`, + tooltip: `#${pr.number} ${shortName} ${pr.state}: ${pr.title}`, + url: pr.url, + }; +} + +export function formatChangeRequestAction( + verb: "View" | "Create", + presentation: ChangeRequestPresentation, +): string { + return `${verb} ${presentation.shortName}`; +} + +export function formatCreateChangeRequestPhrase(presentation: ChangeRequestPresentation): string { + return `create ${presentation.shortName}`; +} + export function getChangeRequestTerminology( provider: SourceControlProviderInfo | null | undefined, ): ChangeRequestTerminology { diff --git a/packages/shared/src/steerTimeline.test.ts b/packages/shared/src/steerTimeline.test.ts new file mode 100644 index 000000000000..e0ada5265cfd --- /dev/null +++ b/packages/shared/src/steerTimeline.test.ts @@ -0,0 +1,183 @@ +import { describe, expect, it } from "vite-plus/test"; +import { + clearSteerTimelineBoundaryStore, + compareSteerTimelineSortable, + findMidTurnSteerUserIds, + observeSteerTextBoundary, + splitAssistantTextAtSteers, + steerTimelineBoundaryKey, +} from "./steerTimeline.ts"; + +describe("observeSteerTextBoundary", () => { + it("freezes the first observed length and ignores later growth", () => { + const store = new Map(); + expect(observeSteerTextBoundary("a1", "s1", 10, store)).toBe(10); + expect(observeSteerTextBoundary("a1", "s1", 40, store)).toBe(10); + expect(store.get(steerTimelineBoundaryKey("a1", "s1"))).toBe(10); + }); + + it("clamps when text shrinks below the observed boundary", () => { + const store = new Map(); + observeSteerTextBoundary("a1", "s1", 10, store); + expect(observeSteerTextBoundary("a1", "s1", 4, store)).toBe(4); + }); +}); + +describe("splitAssistantTextAtSteers", () => { + it("returns the original message when no steers follow its start", () => { + const store = new Map(); + const segments = splitAssistantTextAtSteers({ + assistantMessageId: "a1", + assistantCreatedAt: "2026-01-01T00:01:05Z", + text: "hello", + streaming: true, + steers: [{ id: "s0", createdAt: "2026-01-01T00:01:00Z" }], + boundaryStore: store, + }); + expect(segments).toEqual([ + { + segmentId: "a1", + text: "hello", + sortAt: "2026-01-01T00:01:05Z", + sortRank: 0, + streaming: true, + }, + ]); + }); + + it("splits pre/post at the first observed boundary and keeps later tokens post-steer", () => { + const store = new Map(); + const first = splitAssistantTextAtSteers({ + assistantMessageId: "a1", + assistantCreatedAt: "2026-01-01T00:01:05Z", + text: "pre text", + streaming: true, + steers: [{ id: "s1", createdAt: "2026-01-01T00:08:30Z" }], + boundaryStore: store, + }); + expect(first).toEqual([ + { + segmentId: "a1::pre", + text: "pre text", + sortAt: "2026-01-01T00:01:05Z", + sortRank: 0, + streaming: false, + }, + { + segmentId: "a1::after::s1", + text: "", + sortAt: "2026-01-01T00:08:30Z", + sortRank: 2, + streaming: true, + }, + ]); + + const second = splitAssistantTextAtSteers({ + assistantMessageId: "a1", + assistantCreatedAt: "2026-01-01T00:01:05Z", + text: "pre text and more after steer", + streaming: true, + steers: [{ id: "s1", createdAt: "2026-01-01T00:08:30Z" }], + boundaryStore: store, + }); + expect(second).toEqual([ + { + segmentId: "a1::pre", + text: "pre text", + sortAt: "2026-01-01T00:01:05Z", + sortRank: 0, + streaming: false, + }, + { + segmentId: "a1::after::s1", + text: " and more after steer", + sortAt: "2026-01-01T00:08:30Z", + sortRank: 2, + streaming: true, + }, + ]); + }); + + it("keeps an empty streaming post segment so the cursor can sit after the steer", () => { + const store = new Map(); + observeSteerTextBoundary("a1", "s1", 5, store); + const segments = splitAssistantTextAtSteers({ + assistantMessageId: "a1", + assistantCreatedAt: "2026-01-01T00:01:05Z", + text: "hello", + streaming: true, + steers: [{ id: "s1", createdAt: "2026-01-01T00:08:30Z" }], + boundaryStore: store, + }); + expect(segments).toEqual([ + { + segmentId: "a1::pre", + text: "hello", + sortAt: "2026-01-01T00:01:05Z", + sortRank: 0, + streaming: false, + }, + { + segmentId: "a1::after::s1", + text: "", + sortAt: "2026-01-01T00:08:30Z", + sortRank: 2, + streaming: true, + }, + ]); + }); +}); + +describe("findMidTurnSteerUserIds", () => { + it("returns user messages after the turn-start boundary", () => { + const steers = findMidTurnSteerUserIds({ + items: [ + { + id: "u0", + createdAt: "2026-01-01T00:00:00Z", + isUser: true, + belongsToActiveTurn: false, + }, + { + id: "u1", + createdAt: "2026-01-01T00:01:00Z", + isUser: true, + belongsToActiveTurn: false, + }, + { + id: "a1", + createdAt: "2026-01-01T00:01:05Z", + isUser: false, + belongsToActiveTurn: true, + }, + { + id: "s1", + createdAt: "2026-01-01T00:08:30Z", + isUser: true, + belongsToActiveTurn: false, + }, + ], + }); + expect(steers).toEqual([{ id: "s1", createdAt: "2026-01-01T00:08:30Z" }]); + }); +}); + +describe("compareSteerTimelineSortable", () => { + it("orders post-steer assistant after the steer at the same timestamp", () => { + const ordered = [ + { id: "post", sortAt: "2026-01-01T00:08:30Z", sortRank: 2 }, + { id: "steer", sortAt: "2026-01-01T00:08:30Z", sortRank: 1 }, + { id: "pre", sortAt: "2026-01-01T00:01:05Z", sortRank: 0 }, + ].sort(compareSteerTimelineSortable); + expect(ordered.map((item) => item.id)).toEqual(["pre", "steer", "post"]); + }); +}); + +describe("clearSteerTimelineBoundaryStore", () => { + it("empties the default store", () => { + observeSteerTextBoundary("a1", "s1", 3); + clearSteerTimelineBoundaryStore(); + expect(observeSteerTextBoundary("a1", "s1", 9)).toBe(9); + clearSteerTimelineBoundaryStore(); + }); +}); diff --git a/packages/shared/src/steerTimeline.ts b/packages/shared/src/steerTimeline.ts new file mode 100644 index 000000000000..14282b9082bb --- /dev/null +++ b/packages/shared/src/steerTimeline.ts @@ -0,0 +1,204 @@ +/** + * Mid-turn steer timeline interleave helpers. + * + * Providers often reuse one assistant message row for an entire turn while + * steer user messages arrive with a later `createdAt`. Pure chronological + * sort then parks the whole assistant bubble above the steer; coarse reorders + * park every steer above all turn work. These helpers split assistant text at + * client-observed boundaries so steers can sit between pre- and post-steer + * content without Orchestration V2. + */ + +export type SteerTimelineBoundaryStore = Map; + +const defaultBoundaryStore: SteerTimelineBoundaryStore = new Map(); + +export function steerTimelineBoundaryKey( + assistantMessageId: string, + steerMessageId: string, +): string { + return `${assistantMessageId}::${steerMessageId}`; +} + +/** Test helper — clears the process-wide default boundary store. */ +export function clearSteerTimelineBoundaryStore( + store: SteerTimelineBoundaryStore = defaultBoundaryStore, +): void { + store.clear(); +} + +/** + * Remember how much assistant text existed when a steer first became visible. + * Later tokens only grow the post-steer segment; the boundary never advances. + */ +export function observeSteerTextBoundary( + assistantMessageId: string, + steerMessageId: string, + currentTextLength: number, + store: SteerTimelineBoundaryStore = defaultBoundaryStore, +): number { + const key = steerTimelineBoundaryKey(assistantMessageId, steerMessageId); + const existing = store.get(key); + if (existing !== undefined) { + return Math.min(existing, Math.max(0, currentTextLength)); + } + const observed = Math.max(0, currentTextLength); + store.set(key, observed); + return observed; +} + +export interface SteerAssistantSegment { + readonly segmentId: string; + readonly text: string; + /** Sort timestamp for this segment. */ + readonly sortAt: string; + /** + * Tie-break after `sortAt`: lower ranks first. + * 0 = pre-steer / normal work, 1 = steer user message, 2 = post-steer assistant. + */ + readonly sortRank: number; + readonly streaming: boolean; +} + +/** + * Split one assistant message across mid-turn steer timestamps. + * Returns a single segment (the original message) when no steers apply. + */ +export function splitAssistantTextAtSteers(input: { + readonly assistantMessageId: string; + readonly assistantCreatedAt: string; + readonly text: string; + readonly streaming: boolean; + readonly steers: ReadonlyArray<{ readonly id: string; readonly createdAt: string }>; + readonly boundaryStore?: SteerTimelineBoundaryStore; +}): ReadonlyArray { + const store = input.boundaryStore ?? defaultBoundaryStore; + const steersAfterStart = input.steers + .filter((steer) => steer.createdAt > input.assistantCreatedAt) + .sort((left, right) => left.createdAt.localeCompare(right.createdAt)); + + if (steersAfterStart.length === 0) { + return [ + { + segmentId: input.assistantMessageId, + text: input.text, + sortAt: input.assistantCreatedAt, + sortRank: 0, + streaming: input.streaming, + }, + ]; + } + + const boundaries = steersAfterStart.map((steer) => + observeSteerTextBoundary(input.assistantMessageId, steer.id, input.text.length, store), + ); + + const cutPoints = [0, ...boundaries, input.text.length]; + const segments: SteerAssistantSegment[] = []; + + for (let index = 0; index < cutPoints.length - 1; index += 1) { + const start = cutPoints[index]!; + const end = cutPoints[index + 1]!; + const text = input.text.slice(start, end); + const isLast = index === cutPoints.length - 2; + const isFirst = index === 0; + const streaming = input.streaming && isLast; + + if (text.length === 0 && !streaming) { + continue; + } + + if (isFirst) { + segments.push({ + segmentId: `${input.assistantMessageId}::pre`, + text, + sortAt: input.assistantCreatedAt, + sortRank: 0, + streaming: false, + }); + continue; + } + + const precedingSteer = steersAfterStart[index - 1]!; + segments.push({ + segmentId: `${input.assistantMessageId}::after::${precedingSteer.id}`, + text, + sortAt: precedingSteer.createdAt, + sortRank: 2, + streaming, + }); + } + + if (segments.length === 0) { + return [ + { + segmentId: input.assistantMessageId, + text: input.text, + sortAt: input.assistantCreatedAt, + sortRank: 0, + streaming: input.streaming, + }, + ]; + } + + return segments; +} + +export interface SteerTimelineSortable { + readonly sortAt: string; + readonly sortRank: number; + readonly id: string; +} + +export function compareSteerTimelineSortable( + left: SteerTimelineSortable, + right: SteerTimelineSortable, +): number { + const byTime = left.sortAt.localeCompare(right.sortAt); + if (byTime !== 0) { + return byTime; + } + if (left.sortRank !== right.sortRank) { + return left.sortRank - right.sortRank; + } + return left.id.localeCompare(right.id); +} + +/** + * Identify mid-turn user messages that should interleave with turn work. + * `belongsToTurn` should be true for assistant/work/plan rows of the active turn + * (not for user rows). + */ +export function findMidTurnSteerUserIds(input: { + readonly items: ReadonlyArray<{ + readonly id: string; + readonly createdAt: string; + readonly isUser: boolean; + readonly belongsToActiveTurn: boolean; + }>; +}): ReadonlyArray<{ readonly id: string; readonly createdAt: string }> { + const sorted = [...input.items].sort((left, right) => + left.createdAt.localeCompare(right.createdAt), + ); + + let turnStartUserBoundary: string | null = null; + for (const item of sorted) { + if (item.belongsToActiveTurn) { + break; + } + if (item.isUser) { + turnStartUserBoundary = item.createdAt; + } + } + + if (turnStartUserBoundary === null) { + return []; + } + + return sorted.flatMap((item) => { + if (!item.isUser || item.createdAt <= turnStartUserBoundary!) { + return []; + } + return [{ id: item.id, createdAt: item.createdAt }]; + }); +} diff --git a/packages/shared/src/t3ProjectFile.test.ts b/packages/shared/src/t3ProjectFile.test.ts index a1986ff35f9b..5f591d4e4a49 100644 --- a/packages/shared/src/t3ProjectFile.test.ts +++ b/packages/shared/src/t3ProjectFile.test.ts @@ -26,6 +26,7 @@ describe("buildT3ProjectFileJsonSchema", () => { { description?: string; items?: { properties: Record; required: ReadonlyArray }; + properties?: Record; } >; required?: ReadonlyArray; @@ -34,11 +35,18 @@ describe("buildT3ProjectFileJsonSchema", () => { expect(Object.keys(schema.properties).sort()).toEqual([ "$schema", "defaultThreadEnvMode", + "devStacks", "iconPath", "scripts", ]); expect(schema.required).toBeUndefined(); expect(schema.properties.iconPath?.description).toContain("Workspace-relative path"); + expect(schema.properties.devStacks?.description).toContain("supervising the dev stacks"); + expect(Object.keys(schema.properties.devStacks?.properties ?? {}).sort()).toEqual([ + "consumers", + "entryRoles", + "idleMinutes", + ]); expect(schema.properties.defaultThreadEnvMode?.description).toContain("new threads start"); const script = schema.properties.scripts?.items; @@ -49,7 +57,9 @@ describe("buildT3ProjectFileJsonSchema", () => { "icon", "name", "previewUrl", + "runOnPrMerged", "runOnWorktreeCreate", + "runOnWorktreeRemove", ]); }); diff --git a/packages/shared/src/threadAttributeSearch.test.ts b/packages/shared/src/threadAttributeSearch.test.ts new file mode 100644 index 000000000000..9ba392600e31 --- /dev/null +++ b/packages/shared/src/threadAttributeSearch.test.ts @@ -0,0 +1,104 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + buildThreadAttributeSearchTerms, + threadAttributeSearchMatches, + threadMatchesAttributeQuery, +} from "./threadAttributeSearch.ts"; + +const sample = { + title: "Fix gate SA-123 for multi-user claims", + branch: "pr/4521-identity-search", + originSource: { + channel: "discord" as const, + personId: "patroza", + username: "patroza", + location: { + issueKey: "SA-123", + number: 4521, + kind: "pr" as const, + }, + }, + participantSummaries: [ + { + personId: "patroza", + username: "patroza", + name: "Patrick Roza", + firstChannel: "discord" as const, + }, + { + personId: "julius", + username: "julius", + firstChannel: "desktop" as const, + }, + ], + extraTerms: ["t3-code"], +}; + +describe("buildThreadAttributeSearchTerms", () => { + it("includes identity handles and channels", () => { + const terms = buildThreadAttributeSearchTerms(sample); + expect(terms).toEqual( + expect.arrayContaining([ + "patroza", + "@patroza", + "patroza@discord", + "@discord", + "discord", + "julius", + "@julius", + "julius@desktop", + "@desktop", + "desktop", + "patrick roza", + ]), + ); + }); + + it("includes PR and Jira tokens", () => { + const terms = buildThreadAttributeSearchTerms(sample); + expect(terms).toEqual( + expect.arrayContaining(["#4521", "4521", "pr/4521", "pr-4521", "sa-123"]), + ); + }); + + it("includes title and branch", () => { + const terms = buildThreadAttributeSearchTerms(sample); + expect(terms).toEqual( + expect.arrayContaining(["fix gate sa-123 for multi-user claims", "pr/4521-identity-search"]), + ); + }); +}); + +describe("threadMatchesAttributeQuery", () => { + it.each([ + ["@patroza"], + ["patroza@discord"], + ["@desktop"], + ["#4521"], + ["4521"], + ["SA-123"], + ["sa-123"], + ["julius"], + ["multi-user"], + ])("matches %s", (query) => { + expect(threadMatchesAttributeQuery(sample, query)).toBe(true); + }); + + it("rejects unrelated queries", () => { + expect(threadMatchesAttributeQuery(sample, "@theo")).toBe(false); + expect(threadMatchesAttributeQuery(sample, "#9999")).toBe(false); + expect(threadMatchesAttributeQuery(sample, "ZZ-1")).toBe(false); + }); + + it("empty query matches all", () => { + expect(threadMatchesAttributeQuery(sample, " ")).toBe(true); + }); +}); + +describe("threadAttributeSearchMatches", () => { + it("matches partial username prefixes", () => { + const terms = buildThreadAttributeSearchTerms(sample); + expect(threadAttributeSearchMatches(terms, "@patr")).toBe(true); + }); +}); diff --git a/packages/shared/src/threadAttributeSearch.ts b/packages/shared/src/threadAttributeSearch.ts new file mode 100644 index 000000000000..481bb74db827 --- /dev/null +++ b/packages/shared/src/threadAttributeSearch.ts @@ -0,0 +1,208 @@ +/** + * Search terms and match helpers for thread attributes beyond title/branch: + * identity handles (`@user`, `user@channel`, `@channel`), PR numbers (`#123`), + * and Jira keys (`SA-123`). + * + * Pure string helpers for web/mobile command palette and list filters. + * See docs/architecture/source-and-identity.md + */ + +export type ThreadAttributeSourceLike = { + readonly channel?: string | null | undefined; + readonly personId?: string | null | undefined; + readonly username?: string | null | undefined; + readonly location?: + | { + readonly number?: number | null | undefined; + readonly issueKey?: string | null | undefined; + readonly kind?: string | null | undefined; + } + | null + | undefined; +}; + +export type ThreadAttributeParticipantLike = { + readonly personId?: string | null | undefined; + readonly username?: string | null | undefined; + readonly name?: string | null | undefined; + readonly firstChannel?: string | null | undefined; +}; + +export type ThreadAttributeSearchInput = { + readonly title?: string | null | undefined; + readonly branch?: string | null | undefined; + readonly originSource?: ThreadAttributeSourceLike | null | undefined; + readonly participantSummaries?: ReadonlyArray | null | undefined; + /** Additional free-form terms (project title, etc.). */ + readonly extraTerms?: ReadonlyArray | null | undefined; +}; + +/** Jira-style issue keys: PROJ-123, SA-49, … */ +const JIRA_KEY_PATTERN = /\b([A-Za-z][A-Za-z0-9]+-\d+)\b/g; +/** Explicit PR markers in free text / branch names. */ +const PR_HASH_PATTERN = /#(\d+)\b/g; +const PR_SLUG_PATTERN = /\b(?:pr|pull)[-_/]?(\d+)\b/gi; + +function addTerm(into: Set, raw: string | null | undefined): void { + if (raw === null || raw === undefined) return; + const trimmed = raw.trim().toLowerCase(); + if (trimmed.length === 0) return; + into.add(trimmed); +} + +function addPersonTerms( + into: Set, + person: { + readonly username?: string | null | undefined; + readonly personId?: string | null | undefined; + readonly name?: string | null | undefined; + readonly channel?: string | null | undefined; + }, +): void { + const username = person.username?.trim().toLowerCase() ?? ""; + const personId = person.personId?.trim().toLowerCase() ?? ""; + const channel = person.channel?.trim().toLowerCase() ?? ""; + const name = person.name?.trim().toLowerCase() ?? ""; + + if (username.length > 0) { + addTerm(into, username); + addTerm(into, `@${username}`); + if (channel.length > 0) { + addTerm(into, `${username}@${channel}`); + } + } + if (personId.length > 0 && personId !== username) { + addTerm(into, personId); + addTerm(into, `@${personId}`); + if (channel.length > 0) { + addTerm(into, `${personId}@${channel}`); + } + } + if (name.length > 0) { + addTerm(into, name); + } +} + +function addChannelTerms(into: Set, channel: string | null | undefined): void { + const normalized = channel?.trim().toLowerCase() ?? ""; + if (normalized.length === 0) return; + addTerm(into, normalized); + addTerm(into, `@${normalized}`); +} + +function addPrNumber(into: Set, value: number | string): void { + const digits = String(value).replace(/\D/g, ""); + if (digits.length === 0) return; + addTerm(into, digits); + addTerm(into, `#${digits}`); + addTerm(into, `pr-${digits}`); + addTerm(into, `pr/${digits}`); +} + +function extractFromText(into: Set, text: string | null | undefined): void { + if (text === null || text === undefined || text.trim().length === 0) return; + const source = text; + + for (const match of source.matchAll(JIRA_KEY_PATTERN)) { + const key = match[1]; + if (key !== undefined) addTerm(into, key); + } + for (const match of source.matchAll(PR_HASH_PATTERN)) { + const n = match[1]; + if (n !== undefined) addPrNumber(into, n); + } + for (const match of source.matchAll(PR_SLUG_PATTERN)) { + const n = match[1]; + if (n !== undefined) addPrNumber(into, n); + } +} + +/** + * Build a deduped, lowercased bag of search terms for a thread. + * Suitable for command-palette `searchTerms` and list filters. + */ +export function buildThreadAttributeSearchTerms( + input: ThreadAttributeSearchInput, +): ReadonlyArray { + const terms = new Set(); + + addTerm(terms, input.title); + addTerm(terms, input.branch); + if (input.branch !== null && input.branch !== undefined && input.branch.trim().length > 0) { + addTerm(terms, `#${input.branch.trim()}`); + } + + extractFromText(terms, input.title); + extractFromText(terms, input.branch); + + const origin = input.originSource ?? null; + if (origin !== null) { + addChannelTerms(terms, origin.channel); + addPersonTerms(terms, { + username: origin.username, + personId: origin.personId, + channel: origin.channel, + }); + if (origin.location?.number !== undefined && origin.location.number !== null) { + addPrNumber(terms, origin.location.number); + } + if (origin.location?.issueKey) { + addTerm(terms, origin.location.issueKey); + } + } + + for (const participant of input.participantSummaries ?? []) { + addPersonTerms(terms, { + username: participant.username, + personId: participant.personId, + name: participant.name, + channel: participant.firstChannel, + }); + addChannelTerms(terms, participant.firstChannel); + } + + for (const extra of input.extraTerms ?? []) { + addTerm(terms, extra); + extractFromText(terms, extra); + } + + return [...terms]; +} + +/** + * Whether any search term matches the query (substring, case-insensitive). + * Query is normalized the same way as terms (trim + lower). + */ +export function threadAttributeSearchMatches(terms: ReadonlyArray, query: string): boolean { + const normalizedQuery = query.trim().toLowerCase().replace(/\s+/g, " "); + if (normalizedQuery.length === 0) return true; + if (terms.length === 0) return false; + + // Direct term substring (covers @user, user@channel, #123, sa-123, title words). + for (const term of terms) { + if (term.includes(normalizedQuery) || normalizedQuery.includes(term)) { + // Prefer: query is a prefix/substring of a term (user typed partial handle). + if (term.includes(normalizedQuery)) return true; + } + } + + // Joined haystack for multi-word title queries. + const haystack = terms.join(" "); + if (haystack.includes(normalizedQuery)) return true; + + // `#42` vs bare `42` already both in terms when PR-linked. + // `@desktop` is stored as both `desktop` and `@desktop`. + return false; +} + +/** + * Convenience: build terms and match in one call. + */ +export function threadMatchesAttributeQuery( + input: ThreadAttributeSearchInput, + query: string, +): boolean { + const normalizedQuery = query.trim(); + if (normalizedQuery.length === 0) return true; + return threadAttributeSearchMatches(buildThreadAttributeSearchTerms(input), normalizedQuery); +} diff --git a/packages/shared/src/threadPullRequests.ts b/packages/shared/src/threadPullRequests.ts index 5d91d98d52c9..4eb0a42da2fa 100644 --- a/packages/shared/src/threadPullRequests.ts +++ b/packages/shared/src/threadPullRequests.ts @@ -107,7 +107,7 @@ export function resolveThreadCurrentPullRequest( const chains = resolveThreadPullRequestChains(visible); if (open.length > 1) { const openChains = chains - .map((chain) => chain.layers.toReversed().filter(isOpen)) + .map((chain) => [...chain.layers].reverse().filter(isOpen)) .filter((layers) => layers.length > 0) .sort( (left, right) => diff --git a/packages/shared/src/threadTitle.test.ts b/packages/shared/src/threadTitle.test.ts new file mode 100644 index 000000000000..a211c9796a90 --- /dev/null +++ b/packages/shared/src/threadTitle.test.ts @@ -0,0 +1,64 @@ +import { describe, it, expect } from "vite-plus/test"; +import { isDefaultThreadTitle, sanitizeTitle, DEFAULT_THREAD_TITLE } from "./threadTitle.ts"; + +describe("isDefaultThreadTitle", () => { + it("returns true for the default title", () => { + expect(isDefaultThreadTitle("New thread")).toBe(true); + }); + + it("returns true for the default title with whitespace", () => { + expect(isDefaultThreadTitle(" New thread ")).toBe(true); + }); + + it("returns false for a custom title", () => { + expect(isDefaultThreadTitle("My custom title")).toBe(false); + }); + + it("returns false for empty string", () => { + expect(isDefaultThreadTitle("")).toBe(false); + }); + + it("returns false for null", () => { + expect(isDefaultThreadTitle(null)).toBe(false); + }); + + it("returns false for undefined", () => { + expect(isDefaultThreadTitle(undefined)).toBe(false); + }); +}); + +describe("sanitizeTitle", () => { + it("preserves a normal title", () => { + expect(sanitizeTitle("Hello World")).toBe("Hello World"); + }); + + it("trims whitespace", () => { + expect(sanitizeTitle(" hello ")).toBe("hello"); + }); + + it("strips control characters", () => { + expect(sanitizeTitle("hello\x00world")).toBe("helloworld"); + expect(sanitizeTitle("hello\x1Fworld")).toBe("helloworld"); + }); + + it("returns empty string for whitespace-only input", () => { + expect(sanitizeTitle(" ")).toBe(""); + expect(sanitizeTitle(" \t ")).toBe(""); + }); + + it("returns empty string for control-char-only input", () => { + expect(sanitizeTitle("\x00")).toBe(""); + expect(sanitizeTitle("\x00\x00")).toBe(""); + }); + + it("truncates to MAX_TITLE_LENGTH", () => { + const long = "a".repeat(1000); + expect(sanitizeTitle(long).length).toBe(500); + }); +}); + +describe("DEFAULT_THREAD_TITLE", () => { + it("equals New thread", () => { + expect(DEFAULT_THREAD_TITLE).toBe("New thread"); + }); +}); diff --git a/packages/shared/src/threadTitle.ts b/packages/shared/src/threadTitle.ts new file mode 100644 index 000000000000..ee35dde673fd --- /dev/null +++ b/packages/shared/src/threadTitle.ts @@ -0,0 +1,17 @@ +const MAX_TITLE_LENGTH = 500; + +export const DEFAULT_THREAD_TITLE = "New thread"; + +export function isDefaultThreadTitle(title: string | null | undefined): boolean { + return (title ?? "").trim() === DEFAULT_THREAD_TITLE; +} + +export function sanitizeTitle(title: string): string { + return title + .replace(/./g, (c) => { + const code = c.charCodeAt(0); + return code > 0x1f || code === 0x09 || code === 0x0a || code === 0x0d ? c : ""; + }) + .slice(0, MAX_TITLE_LENGTH) + .trim(); +} diff --git a/packages/shared/src/turnResponseStats.test.ts b/packages/shared/src/turnResponseStats.test.ts new file mode 100644 index 000000000000..9c3844147dea --- /dev/null +++ b/packages/shared/src/turnResponseStats.test.ts @@ -0,0 +1,157 @@ +import { describe, expect, it } from "vite-plus/test"; +import type { ModelSelection } from "@t3tools/contracts"; +import { ProviderInstanceId } from "@t3tools/contracts"; + +import { + appendStatsToMessageChunks, + appendTurnResponseStatsFooter, + deriveTurnResponseStats, + formatCompactTokenCount, + formatTurnResponseStatsLine, +} from "./turnResponseStats.ts"; + +const modelSelection = ( + model: string, + options: ReadonlyArray<{ id: string; value: string | boolean }> = [], +): ModelSelection => + ({ + instanceId: ProviderInstanceId.make("codex"), + model, + options: [...options], + }) as ModelSelection; + +describe("formatCompactTokenCount", () => { + it("formats small and large counts", () => { + expect(formatCompactTokenCount(42)).toBe("42"); + expect(formatCompactTokenCount(1_500)).toBe("1.5k"); + expect(formatCompactTokenCount(12_400)).toBe("12k"); + expect(formatCompactTokenCount(1_200_000)).toBe("1.2m"); + expect(formatCompactTokenCount(null)).toBe(null); + }); +}); + +describe("formatTurnResponseStatsLine", () => { + it("returns null when nothing is known", () => { + expect(formatTurnResponseStatsLine({})).toBe(null); + }); + + it("formats model, effort, fast mode, duration, and tokens", () => { + const line = formatTurnResponseStatsLine({ + modelSelection: modelSelection("gpt-5.4", [ + { id: "reasoningEffort", value: "high" }, + { id: "fastMode", value: true }, + ]), + activities: [ + { + kind: "context-window.updated", + turnId: "turn-1", + payload: { + usedTokens: 20_000, + lastInputTokens: 12_400, + lastOutputTokens: 2_100, + lastReasoningOutputTokens: 1_000, + durationMs: 84_000, + }, + }, + ], + turnId: "turn-1", + }); + + expect(line).toBe("_`gpt-5.4` · effort high · fast · 1m 24s · ↑12k ↓3.1k_"); + }); + + it("uses Claude effort option and latestTurn wall-clock when durationMs missing", () => { + const line = formatTurnResponseStatsLine({ + modelSelection: modelSelection("claude-opus-4-6", [{ id: "effort", value: "max" }]), + turnId: "turn-2", + latestTurn: { + turnId: "turn-2", + requestedAt: "2026-07-22T00:00:00.000Z", + startedAt: "2026-07-22T00:00:10.000Z", + completedAt: "2026-07-22T00:01:10.000Z", + }, + }); + + expect(line).toBe("_`claude-opus-4-6` · effort max · 1m_"); + }); + + it("prefers matching turn usage over older activities", () => { + const stats = deriveTurnResponseStats({ + turnId: "turn-2", + activities: [ + { + kind: "context-window.updated", + turnId: "turn-1", + payload: { + usedTokens: 1, + lastInputTokens: 100, + lastOutputTokens: 50, + }, + }, + { + kind: "context-window.updated", + turnId: "turn-2", + payload: { + usedTokens: 2, + lastInputTokens: 9_000, + lastOutputTokens: 400, + }, + }, + ], + }); + + expect(stats.inputTokens).toBe(9_000); + expect(stats.outputTokens).toBe(400); + }); + + it("falls back to usedTokens when in/out are missing", () => { + const line = formatTurnResponseStatsLine({ + modelSelection: modelSelection("grok-4.6"), + activities: [ + { + kind: "context-window.updated", + turnId: "turn-3", + payload: { usedTokens: 139_982 }, + }, + ], + turnId: "turn-3", + latestTurn: { + turnId: "turn-3", + requestedAt: "2026-08-15T07:00:00.000Z", + startedAt: "2026-08-15T07:00:00.000Z", + completedAt: "2026-08-15T07:31:31.000Z", + }, + }); + + expect(line).toBe("_`grok-4.6` · 31m 31s · 140k_"); + }); +}); + +describe("appendTurnResponseStatsFooter", () => { + it("appends once with blank line separation", () => { + const withStats = appendTurnResponseStatsFooter("Hello", "_`m` · 1s_"); + expect(withStats).toBe("Hello\n\n_`m` · 1s_"); + expect(appendTurnResponseStatsFooter(withStats, "_`m` · 1s_")).toBe(withStats); + }); +}); + +describe("appendStatsToMessageChunks", () => { + it("appends to the last chunk when it fits", () => { + expect(appendStatsToMessageChunks(["part a", "part b"], "_stats_", 2000)).toEqual([ + "part a", + "part b\n\n_stats_", + ]); + }); + + it("adds a new chunk when the last would overflow", () => { + const almostFull = "x".repeat(1990); + expect(appendStatsToMessageChunks([almostFull], "_stats line_", 2000)).toEqual([ + almostFull, + "_stats line_", + ]); + }); + + it("replaces an empty last chunk with the stats line", () => { + expect(appendStatsToMessageChunks([""], "_stats_", 2000)).toEqual(["_stats_"]); + }); +}); diff --git a/packages/shared/src/turnResponseStats.ts b/packages/shared/src/turnResponseStats.ts new file mode 100644 index 000000000000..9bcd5a8dfadf --- /dev/null +++ b/packages/shared/src/turnResponseStats.ts @@ -0,0 +1,286 @@ +import type { ModelSelection } from "@t3tools/contracts"; + +import { + getModelSelectionBooleanOptionValue, + getModelSelectionStringOptionValue, +} from "./model.ts"; +import { formatDuration, formatElapsed } from "./orchestrationTiming.ts"; + +/** Minimal activity shape — plain turnId so callers need not brand strings. */ +export type TurnStatsActivity = { + readonly kind: string; + readonly turnId?: string | null; + readonly payload: unknown; +}; + +export type TurnTokenUsageFields = { + readonly inputTokens: number | null; + readonly outputTokens: number | null; + readonly reasoningOutputTokens: number | null; + readonly usedTokens: number | null; + readonly durationMs: number | null; +}; + +export type TurnResponseStats = { + readonly model: string | null; + readonly effort: string | null; + readonly fastMode: boolean; + readonly durationLabel: string | null; + readonly inputTokens: number | null; + readonly outputTokens: number | null; + readonly usedTokens: number | null; +}; + +function asRecord(value: unknown): Record | null { + return value !== null && typeof value === "object" && !Array.isArray(value) + ? (value as Record) + : null; +} + +function asFiniteNumber(value: unknown): number | null { + return typeof value === "number" && Number.isFinite(value) ? value : null; +} + +function nonNegativeInt(value: unknown): number | null { + const n = asFiniteNumber(value); + if (n === null || n < 0) return null; + return Math.round(n); +} + +/** + * Compact token counts for footers (matches web context-window style). + */ +export function formatCompactTokenCount(value: number | null | undefined): string | null { + if (value === null || value === undefined || !Number.isFinite(value) || value < 0) { + return null; + } + if (value < 1_000) return `${Math.round(value)}`; + if (value < 10_000) return `${(value / 1_000).toFixed(1).replace(/\.0$/u, "")}k`; + if (value < 1_000_000) return `${Math.round(value / 1_000)}k`; + return `${(value / 1_000_000).toFixed(1).replace(/\.0$/u, "")}m`; +} + +function modelSlug(modelSelection: ModelSelection | null | undefined): string | null { + if (modelSelection === null || modelSelection === undefined) return null; + const model = typeof modelSelection.model === "string" ? modelSelection.model.trim() : ""; + return model.length > 0 ? model : null; +} + +function effortLabel(modelSelection: ModelSelection | null | undefined): string | null { + const reasoning = getModelSelectionStringOptionValue(modelSelection, "reasoningEffort"); + if (reasoning !== undefined && reasoning.trim() !== "") return reasoning.trim(); + const effort = getModelSelectionStringOptionValue(modelSelection, "effort"); + if (effort !== undefined && effort.trim() !== "") return effort.trim(); + return null; +} + +function isFastMode(modelSelection: ModelSelection | null | undefined): boolean { + return getModelSelectionBooleanOptionValue(modelSelection, "fastMode") === true; +} + +/** + * Prefer turn-scoped last* token fields; fall back to cumulative input/output on the snapshot. + * Output includes reasoning tokens when reported separately. + */ +export function deriveTurnTokenUsageFromActivities( + activities: ReadonlyArray, + turnId: string | null | undefined = null, +): TurnTokenUsageFields | null { + let fallback: TurnTokenUsageFields | null = null; + + for (let index = activities.length - 1; index >= 0; index -= 1) { + const activity = activities[index]; + if (!activity || activity.kind !== "context-window.updated") continue; + + const payload = asRecord(activity.payload); + if (payload === null) continue; + + const inputTokens = + nonNegativeInt(payload.lastInputTokens) ?? nonNegativeInt(payload.inputTokens); + const baseOutput = + nonNegativeInt(payload.lastOutputTokens) ?? nonNegativeInt(payload.outputTokens); + const reasoning = + nonNegativeInt(payload.lastReasoningOutputTokens) ?? + nonNegativeInt(payload.reasoningOutputTokens); + const outputTokens = + baseOutput === null && reasoning === null ? null : (baseOutput ?? 0) + (reasoning ?? 0); + const durationMs = nonNegativeInt(payload.durationMs); + const usedTokens = nonNegativeInt(payload.usedTokens) ?? nonNegativeInt(payload.lastUsedTokens); + + if ( + inputTokens === null && + outputTokens === null && + durationMs === null && + usedTokens === null + ) { + continue; + } + + const snapshot: TurnTokenUsageFields = { + inputTokens, + outputTokens, + reasoningOutputTokens: reasoning, + usedTokens, + durationMs, + }; + + if (turnId !== null && turnId !== undefined && activity.turnId === turnId) { + return snapshot; + } + if (fallback === null) { + fallback = snapshot; + } + } + + return fallback; +} + +function durationFromLatestTurn( + latestTurn: + | { + readonly turnId: string; + readonly startedAt: string | null; + readonly completedAt: string | null; + readonly requestedAt?: string | null; + } + | null + | undefined, + turnId: string | null | undefined, +): string | null { + if (latestTurn === null || latestTurn === undefined) return null; + if (turnId !== null && turnId !== undefined && latestTurn.turnId !== turnId) return null; + const end = latestTurn.completedAt; + if (end === null) return null; + const start = latestTurn.startedAt ?? latestTurn.requestedAt ?? null; + if (start === null) return null; + return formatElapsed(start, end); +} + +export function deriveTurnResponseStats(input: { + readonly modelSelection?: ModelSelection | null; + readonly activities?: ReadonlyArray; + readonly turnId?: string | null; + readonly latestTurn?: { + readonly turnId: string; + readonly startedAt: string | null; + readonly completedAt: string | null; + readonly requestedAt?: string | null; + } | null; +}): TurnResponseStats { + const usage = deriveTurnTokenUsageFromActivities(input.activities ?? [], input.turnId ?? null); + const durationLabel = + usage?.durationMs !== null && usage?.durationMs !== undefined + ? formatDuration(usage.durationMs) + : durationFromLatestTurn(input.latestTurn, input.turnId ?? null); + + return { + model: modelSlug(input.modelSelection), + effort: effortLabel(input.modelSelection), + fastMode: isFastMode(input.modelSelection), + durationLabel, + inputTokens: usage?.inputTokens ?? null, + outputTokens: usage?.outputTokens ?? null, + usedTokens: usage?.usedTokens ?? null, + }; +} + +/** + * Small italic footer for Discord / GitHub markdown, e.g. + * `_`grok-4.5` · effort high · fast · 1m 24s · ↑12.4k ↓3.1k_` + * + * Returns null when nothing useful is known. + */ +export function formatTurnResponseStatsLine(input: { + readonly modelSelection?: ModelSelection | null; + readonly activities?: ReadonlyArray; + readonly turnId?: string | null; + readonly latestTurn?: { + readonly turnId: string; + readonly startedAt: string | null; + readonly completedAt: string | null; + readonly requestedAt?: string | null; + } | null; +}): string | null { + const stats = deriveTurnResponseStats(input); + const parts: string[] = []; + + if (stats.model !== null) { + parts.push(`\`${stats.model}\``); + } + if (stats.effort !== null) { + parts.push(`effort ${stats.effort}`); + } + if (stats.fastMode) { + parts.push("fast"); + } + if (stats.durationLabel !== null) { + parts.push(stats.durationLabel); + } + + const inLabel = formatCompactTokenCount(stats.inputTokens); + const outLabel = formatCompactTokenCount(stats.outputTokens); + if (inLabel !== null || outLabel !== null) { + const tokenParts: string[] = []; + if (inLabel !== null) tokenParts.push(`↑${inLabel}`); + if (outLabel !== null) tokenParts.push(`↓${outLabel}`); + parts.push(tokenParts.join(" ")); + } else { + const usedLabel = formatCompactTokenCount(stats.usedTokens); + if (usedLabel !== null) { + parts.push(usedLabel); + } + } + + if (parts.length === 0) return null; + // Single italic span so Discord/GitHub render a subtle stats line. + return `_${parts.join(" · ")}_`; +} + +/** Append a stats footer once (no-op when line is empty or already present). */ +export function appendTurnResponseStatsFooter( + body: string, + statsLine: string | null | undefined, +): string { + const base = body.trimEnd(); + const line = statsLine?.trim() ?? ""; + if (line === "") return base; + if (base === "") return line; + if (base.endsWith(line)) return base; + return `${base}\n\n${line}`; +} + +/** + * Attach stats to the last Discord content chunk, or as its own chunk if it would overflow. + */ +export function appendStatsToMessageChunks( + chunks: ReadonlyArray, + statsLine: string | null | undefined, + limit: number, +): string[] { + const line = statsLine?.trim() ?? ""; + if (line === "" || chunks.length === 0) return [...chunks]; + + const out = [...chunks]; + const lastIndex = out.length - 1; + const last = out[lastIndex] ?? ""; + + // Empty placeholder chunk → replace with stats alone. + if (last.trim() === "") { + if (line.length <= limit) { + out[lastIndex] = line; + return out; + } + return out; + } + + const combined = `${last}\n\n${line}`; + if (combined.length <= limit) { + out[lastIndex] = combined; + return out; + } + + if (line.length <= limit) { + out.push(line); + } + return out; +} diff --git a/packages/shared/src/usageLimits.test.ts b/packages/shared/src/usageLimits.test.ts index b814e66da459..9028591e6603 100644 --- a/packages/shared/src/usageLimits.test.ts +++ b/packages/shared/src/usageLimits.test.ts @@ -828,7 +828,7 @@ describe("pooled account columns", () => { ]); expect(pool!.windows[1]!.resets.map((reset) => reset.member.account.key)).toEqual(["a", "b"]); expect(pool!.windows[1]!.remainingPercent).toBe(50); - expect(keys(collectLimitPools(accounts.toReversed(), now)[0]!)).toEqual(keys(pool!)); + expect(keys(collectLimitPools([...accounts].reverse(), now)[0]!)).toEqual(keys(pool!)); }); it("preserves gaps without counting missing windows toward pooled quota", () => { @@ -871,7 +871,9 @@ describe("pooled account columns", () => { account("y", [{ ...window, resetsAt: "invalid" }]), ]; expect(keys(collectLimitPools(accounts, now)[0]!)).toEqual([["a", "b", "y", "z"]]); - expect(keys(collectLimitPools(accounts.toReversed(), now)[0]!)).toEqual([["a", "b", "y", "z"]]); + expect(keys(collectLimitPools([...accounts].reverse(), now)[0]!)).toEqual([ + ["a", "b", "y", "z"], + ]); }); }); diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts index 5c32cc0343b7..710bcc30cfe6 100644 --- a/packages/shared/src/usageLimits.ts +++ b/packages/shared/src/usageLimits.ts @@ -470,6 +470,7 @@ function poolWindows(accounts: readonly LimitAccount[], now: number): readonly L }, ]; }) + .slice() .sort((left, right) => left.at - right.at); return { id: first.id, @@ -485,7 +486,17 @@ function poolWindows(accounts: readonly LimitAccount[], now: number): readonly L resets, }; }); - return pools.sort((left, right) => WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind]); + return [...pools].sort( + (left, right) => WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind], + ); +} + +/** The instance's configured name, else the driver's, else its raw kind. */ +export function providerLimitsLabel( + provider: Pick, + driverLabel: (driver: ServerProvider["driver"]) => string | undefined, +): string { + return provider.displayName?.trim() || driverLabel(provider.driver) || String(provider.driver); } /** The one-line status under a provider heading when there are no bars to draw. */ diff --git a/packages/shared/src/userInputTranscript.test.ts b/packages/shared/src/userInputTranscript.test.ts new file mode 100644 index 000000000000..b70f2c2df2b3 --- /dev/null +++ b/packages/shared/src/userInputTranscript.test.ts @@ -0,0 +1,56 @@ +import { describe, expect, it } from "vite-plus/test"; +import type { OrchestrationThreadActivity } from "@t3tools/contracts"; +import { deriveResolvedUserInputTranscripts } from "./userInputTranscript.ts"; + +function activity(kind: string, payload: unknown, sequence: number): OrchestrationThreadActivity { + return { + id: `event-${sequence}`, + kind, + payload, + sequence, + summary: kind, + tone: "info", + turnId: null, + createdAt: `2026-07-11T00:00:0${sequence}.000Z`, + } as OrchestrationThreadActivity; +} + +describe("deriveResolvedUserInputTranscripts", () => { + it("pairs questions with free-form, selectable, multi-select, and Other answers", () => { + const result = deriveResolvedUserInputTranscripts([ + activity( + "user-input.requested", + { + requestId: "request-1", + questions: [ + { id: "goal", header: "Goal", question: "What is the goal?", options: [] }, + { id: "mode", header: "Mode", question: "Which mode?", options: [] }, + { id: "targets", header: "Targets", question: "Which targets?", options: [] }, + { id: "other", header: "Other", question: "Anything else?", options: [] }, + ], + }, + 1, + ), + activity( + "user-input.resolved", + { + requestId: "request-1", + answers: { + goal: "Make it genuinely sleep", + mode: "Keep it", + targets: ["Web", "Mobile"], + other: "Use the existing dGPU only on demand", + }, + }, + 2, + ), + ]); + + expect(result).toHaveLength(1); + expect(result[0]?.preview).toBe( + "Make it genuinely sleep · Keep it · Web, Mobile · Use the existing dGPU only on demand", + ); + expect(result[0]?.detail).toContain("What is the goal?\nMake it genuinely sleep"); + expect(result[0]?.detail).toContain("Which targets?\nWeb, Mobile"); + }); +}); diff --git a/packages/shared/src/userInputTranscript.ts b/packages/shared/src/userInputTranscript.ts new file mode 100644 index 000000000000..2a8f1ee513a2 --- /dev/null +++ b/packages/shared/src/userInputTranscript.ts @@ -0,0 +1,115 @@ +import type { OrchestrationThreadActivity, UserInputQuestion } from "@t3tools/contracts"; + +export interface ResolvedUserInputAnswer { + readonly questionId: string; + readonly header: string; + readonly question: string; + readonly answer: string; +} + +export interface ResolvedUserInputTranscript { + readonly activityId: string; + readonly requestId: string; + readonly createdAt: string; + readonly turnId: OrchestrationThreadActivity["turnId"]; + readonly answers: ReadonlyArray; + readonly preview: string; + readonly detail: string; +} + +function record(value: unknown): Record | null { + return typeof value === "object" && value !== null && !Array.isArray(value) + ? (value as Record) + : null; +} + +function parseQuestions(value: unknown): ReadonlyArray | null { + if (!Array.isArray(value)) return null; + const parsed = value.filter((entry): entry is UserInputQuestion => { + const question = record(entry); + return ( + typeof question?.id === "string" && + typeof question.header === "string" && + typeof question.question === "string" && + Array.isArray(question.options) + ); + }); + return parsed.length === value.length && parsed.length > 0 ? parsed : null; +} + +function formatAnswer(value: unknown): string | null { + if (typeof value === "string") { + const trimmed = value.trim(); + return trimmed.length > 0 ? trimmed : null; + } + if (Array.isArray(value)) { + const values = value + .filter((entry): entry is string => typeof entry === "string") + .map((entry) => entry.trim()) + .filter((entry) => entry.length > 0); + return values.length > 0 ? values.join(", ") : null; + } + if (value === null || value === undefined) return null; + return String(value); +} + +function compareActivities( + left: OrchestrationThreadActivity, + right: OrchestrationThreadActivity, +): number { + if (left.sequence !== undefined && right.sequence !== undefined) { + return left.sequence - right.sequence; + } + return left.createdAt.localeCompare(right.createdAt); +} + +export function deriveResolvedUserInputTranscripts( + activities: ReadonlyArray, +): ReadonlyArray { + const questionsByRequestId = new Map>(); + const transcripts: ResolvedUserInputTranscript[] = []; + + for (const activity of [...activities].sort(compareActivities)) { + const payload = record(activity.payload); + const requestId = typeof payload?.requestId === "string" ? payload.requestId : null; + if (!requestId) continue; + + if (activity.kind === "user-input.requested") { + const questions = parseQuestions(payload?.questions); + if (questions) questionsByRequestId.set(requestId, questions); + continue; + } + if (activity.kind !== "user-input.resolved") continue; + + const questions = questionsByRequestId.get(requestId); + const rawAnswers = record(payload?.answers); + if (!questions || !rawAnswers) continue; + + const answers = questions.flatMap((question) => { + const answer = formatAnswer(rawAnswers[question.id]); + return answer + ? [ + { + questionId: question.id, + header: question.header, + question: question.question, + answer, + }, + ] + : []; + }); + if (answers.length === 0) continue; + + transcripts.push({ + activityId: activity.id, + requestId, + createdAt: activity.createdAt, + turnId: activity.turnId, + answers, + preview: answers.map((entry) => entry.answer).join(" · "), + detail: answers.map((entry) => `${entry.question}\n${entry.answer}`).join("\n\n"), + }); + } + + return transcripts; +} diff --git a/packages/ssh/src/runnerProcess.test.ts b/packages/ssh/src/runnerProcess.test.ts index 82061c0d8c84..028ebc496221 100644 --- a/packages/ssh/src/runnerProcess.test.ts +++ b/packages/ssh/src/runnerProcess.test.ts @@ -82,6 +82,7 @@ if (args.includes("--package")) { cwd: fixture, env: { PATH: bin, + HOME: fixture, T3_TEST_CLI: cliPath, T3_TEST_CALLS: callsPath, T3_TEST_PORT: String(port), @@ -357,6 +358,7 @@ if (mode === "etarget" || mode === "failed-with-path") { extendEnv: false, env: { PATH: bin, + HOME: fixture, T3_TEST_MODE: mode, T3_TEST_CLI: cliPath, T3_TEST_CALLS: callsPath, diff --git a/packages/ssh/src/tunnel.test.ts b/packages/ssh/src/tunnel.test.ts index e2536ba92017..c4aa28400a9a 100644 --- a/packages/ssh/src/tunnel.test.ts +++ b/packages/ssh/src/tunnel.test.ts @@ -130,6 +130,15 @@ describe("ssh tunnel scripts", () => { assert.notInclude(script, "ensure $NVM_DIR/nvm.sh is available"); }); + it("prepends user-local bins before accepting an existing node", () => { + const script = buildRemoteT3RunnerScript({ nodeEngineRange: TEST_NODE_ENGINE_RANGE }); + + assert.isBelow( + script.indexOf('prepend_path_if_dir "$HOME/.local/bin"'), + script.indexOf("if command -v node >/dev/null 2>&1"), + ); + }); + it("does not hard-code a remote node engine range", () => { const script = buildRemoteT3RunnerScript(); diff --git a/packages/ssh/src/tunnel.ts b/packages/ssh/src/tunnel.ts index 9cb6b25e4121..9c43c5732dcb 100644 --- a/packages/ssh/src/tunnel.ts +++ b/packages/ssh/src/tunnel.ts @@ -329,17 +329,22 @@ NODE } ensure_remote_node_path() { + prepend_path_if_dir "$HOME/.local/bin" + prepend_path_if_dir "$HOME/bin" + if command -v node >/dev/null 2>&1 && remote_node_satisfies_engine >/dev/null 2>&1; then return 0 fi - prepend_path_if_dir "$HOME/.local/bin" - prepend_path_if_dir "$HOME/bin" prepend_path_if_dir "/opt/homebrew/bin" prepend_path_if_dir "/usr/local/bin" prepend_path_if_dir "/usr/bin" prepend_path_if_dir "/bin" + if command -v node >/dev/null 2>&1 && remote_node_satisfies_engine >/dev/null 2>&1; then + return 0 + fi + if [ -z "\${VOLTA_HOME:-}" ]; then VOLTA_HOME="$HOME/.volta" fi diff --git a/packages/tailscale/src/tailscale.test.ts b/packages/tailscale/src/tailscale.test.ts index 102153f6e204..4532bcf7d59e 100644 --- a/packages/tailscale/src/tailscale.test.ts +++ b/packages/tailscale/src/tailscale.test.ts @@ -14,14 +14,18 @@ import { buildTailscaleHttpsBaseUrl, disableTailscaleServe, ensureTailscaleServe, + findRootServeMappingForLocalPort, isTailscaleIpv4Address, parseTailscaleMagicDnsName, + parseTailscaleServeMappings, parseTailscaleStatus, + readTailscaleServeMappings, readTailscaleStatus, TAILSCALE_STATUS_TIMEOUT, TailscaleCommandExitError, TailscaleCommandSpawnError, TailscaleCommandTimeoutError, + TailscaleServeStatusParseError, TailscaleStatusParseError, } from "./tailscale.ts"; @@ -66,6 +70,16 @@ function assertCarriesNoSecret(error: object, secret: string): void { } const tailscaleStatusJson = `{"Self":{"DNSName":"desktop.tail.ts.net.","TailscaleIPs":["100.100.100.100","fd7a:115c:a1e0::1","192.168.1.20"]}}`; const tailscaleStatusWithSingleIpJson = `{"Self":{"DNSName":"desktop.tail.ts.net.","TailscaleIPs":["100.90.1.2"]}}`; +// Shaped after real `tailscale serve status --json`: TCP lists the listening +// ports, Web carries the routes. The serve port deliberately differs from the +// local port it proxies, which is the case the resolver used to get wrong. +const tailscaleServeStatusJson = `{ + "TCP": { "45733": { "HTTPS": true }, "8443": { "HTTPS": true } }, + "Web": { + "desktop.tail.ts.net:45733": { "Handlers": { "/": { "Proxy": "http://127.0.0.1:5733" } } }, + "desktop.tail.ts.net:8443": { "Handlers": { "/docs": { "Proxy": "http://127.0.0.1:6001" } } } + } +}`; function mockHandle(result: { stdout?: string; stderr?: string; code?: number }) { return ChildProcessSpawner.makeHandle({ @@ -164,6 +178,78 @@ describe("tailscale", () => { }), ); + it.effect("flattens serve mappings, keeping the serve port distinct from the local port", () => + Effect.gen(function* () { + const mappings = yield* parseTailscaleServeMappings(tailscaleServeStatusJson); + + assert.deepEqual(mappings, [ + { + magicDnsName: "desktop.tail.ts.net", + servePort: 45733, + path: "/", + localHost: "127.0.0.1", + localPort: 5733, + url: "https://desktop.tail.ts.net:45733/", + }, + { + magicDnsName: "desktop.tail.ts.net", + servePort: 8443, + path: "/docs", + localHost: "127.0.0.1", + localPort: 6001, + url: "https://desktop.tail.ts.net:8443/docs", + }, + ]); + }), + ); + + it.effect("treats a tailnet with no serve mappings as empty rather than failing", () => + Effect.gen(function* () { + assert.deepEqual(yield* parseTailscaleServeMappings("{}"), []); + // TCP forwards and text handlers carry no local HTTP port to route to. + assert.deepEqual( + yield* parseTailscaleServeMappings( + `{"TCP":{"445":{"TCPForward":"127.0.0.1:445"}},"Web":{"desktop.tail.ts.net:443":{"Handlers":{"/":{"Text":"hello"}}}}}`, + ), + [], + ); + }), + ); + + it.effect("preserves serve status decoding failures", () => + Effect.gen(function* () { + const error = yield* parseTailscaleServeMappings("{not-json").pipe(Effect.flip); + + assert.instanceOf(error, TailscaleServeStatusParseError); + assert.equal(error.message, "Failed to decode tailscale serve status JSON."); + }), + ); + + it.effect("matches only root mappings when resolving a local port", () => + Effect.gen(function* () { + const mappings = yield* parseTailscaleServeMappings(tailscaleServeStatusJson); + + assert.equal(findRootServeMappingForLocalPort(mappings, 5733)?.servePort, 45733); + // Served under /docs, so it cannot carry a dev server's absolute asset + // paths — treated as no mapping at all. + assert.isUndefined(findRootServeMappingForLocalPort(mappings, 6001)); + assert.isUndefined(findRootServeMappingForLocalPort(mappings, 9999)); + }), + ); + + it.effect("reads serve mappings through the process spawner service", () => { + const layer = mockSpawnerLayer((command, args) => { + assert.equal(command, "tailscale"); + assert.deepEqual(args, ["serve", "status", "--json"]); + return { stdout: tailscaleServeStatusJson }; + }); + + return Effect.gen(function* () { + const mappings = yield* readTailscaleServeMappings; + assert.equal(mappings.length, 2); + }).pipe(Effect.provide(layer)); + }); + it.effect("builds clean HTTPS base URLs", () => Effect.sync(() => { assert.equal( diff --git a/packages/tailscale/src/tailscale.ts b/packages/tailscale/src/tailscale.ts index 3594742f274e..85213fb072a5 100644 --- a/packages/tailscale/src/tailscale.ts +++ b/packages/tailscale/src/tailscale.ts @@ -128,6 +128,15 @@ export class TailscaleStatusParseError extends Schema.TaggedError()( + "TailscaleServeStatusParseError", + { cause: Schema.Defect() }, +) { + override get message(): string { + return "Failed to decode tailscale serve status JSON."; + } +} + const TailscaleStatusSelf = Schema.Struct({ DNSName: Schema.optional(Schema.Unknown), TailscaleIPs: Schema.optional(Schema.Unknown), @@ -216,63 +225,181 @@ export const parseTailscaleStatus = ( }), ); -export const readTailscaleStatus = Effect.gen(function* () { - const args = ["status", "--json"]; - const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; - const hostPlatform = yield* HostProcessPlatform; - const executable = tailscaleCommandForPlatform(hostPlatform); - const commandContext = { - executable, - subcommand: "status" as const, - argumentCount: args.length, - }; - return yield* Effect.gen(function* () { - const child = yield* spawner.spawn(ChildProcess.make(executable, args)).pipe( - Effect.mapError((cause) => new TailscaleCommandSpawnError({ ...commandContext, cause })), - // Spawning can also fail as a defect rather than a typed error - a - // non-directory entry on PATH makes node throw ENOTDIR synchronously. - // `mapError` never sees that, so it would escape as an uncaught error. - Effect.catchDefect((cause) => - Effect.fail(new TailscaleCommandSpawnError({ ...commandContext, cause })), - ), - ); - const [stdout, stderr, exitCode] = yield* Effect.all( - [ - collectStdout(child.stdout), - collectStderr(child.stderr), - child.exitCode.pipe(Effect.map(Number)), - ], - { concurrency: "unbounded" }, - ).pipe( - Effect.mapError((cause) => new TailscaleCommandOutputError({ ...commandContext, cause })), - ); - if (exitCode !== 0) { - return yield* new TailscaleCommandExitError({ - ...commandContext, - exitCode, - stdoutLength: stdout.length, - stderrLength: stderr.length, - ...(stderrDiagnosticOf(stderr) !== undefined - ? { stderrDiagnostic: stderrDiagnosticOf(stderr) } - : {}), - }); - } - return yield* parseTailscaleStatus(stdout); - }).pipe( - Effect.scoped, - Effect.timeout(TAILSCALE_STATUS_TIMEOUT), - Effect.catchTags({ - TimeoutError: (cause) => - Effect.fail( - new TailscaleCommandTimeoutError({ - ...commandContext, - timeoutMs: Duration.toMillis(TAILSCALE_STATUS_TIMEOUT), - cause, - }), +/** + * Runs a tailscale subcommand that answers on stdout, applying the same + * spawn/exit/timeout error mapping as the rest of this module. `serve status` + * and `status` differ only in arguments and how the payload is decoded. + */ +const readTailscaleCommandStdout = (input: { + readonly args: readonly string[]; + readonly subcommand: "status" | "serve"; + readonly timeout: Duration.Duration; +}) => + Effect.gen(function* () { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const hostPlatform = yield* HostProcessPlatform; + const executable = tailscaleCommandForPlatform(hostPlatform); + const commandContext = { + executable, + subcommand: input.subcommand, + argumentCount: input.args.length, + }; + return yield* Effect.gen(function* () { + const child = yield* spawner.spawn(ChildProcess.make(executable, input.args)).pipe( + Effect.mapError((cause) => new TailscaleCommandSpawnError({ ...commandContext, cause })), + // Spawning can also fail as a defect rather than a typed error - a + // non-directory entry on PATH makes node throw ENOTDIR synchronously. + // `mapError` never sees that, so it would escape as an uncaught error. + Effect.catchDefect((cause) => + Effect.fail(new TailscaleCommandSpawnError({ ...commandContext, cause })), ), + ); + const [stdout, stderr, exitCode] = yield* Effect.all( + [ + collectStdout(child.stdout), + collectStderr(child.stderr), + child.exitCode.pipe(Effect.map(Number)), + ], + { concurrency: "unbounded" }, + ).pipe( + Effect.mapError((cause) => new TailscaleCommandOutputError({ ...commandContext, cause })), + ); + if (exitCode !== 0) { + return yield* new TailscaleCommandExitError({ + ...commandContext, + exitCode, + stdoutLength: stdout.length, + stderrLength: stderr.length, + ...(stderrDiagnosticOf(stderr) !== undefined + ? { stderrDiagnostic: stderrDiagnosticOf(stderr) } + : {}), + }); + } + return stdout; + }).pipe( + Effect.scoped, + Effect.timeout(input.timeout), + Effect.catchTags({ + TimeoutError: (cause) => + Effect.fail( + new TailscaleCommandTimeoutError({ + ...commandContext, + timeoutMs: Duration.toMillis(input.timeout), + cause, + }), + ), + }), + ); + }); + +export const readTailscaleStatus = readTailscaleCommandStdout({ + args: ["status", "--json"], + subcommand: "status", + timeout: TAILSCALE_STATUS_TIMEOUT, +}).pipe(Effect.flatMap(parseTailscaleStatus)); + +/** + * One `tailscale serve` HTTPS mapping, flattened from the `Web` section of + * `tailscale serve status --json`. + * + * `servePort` is the port the tailnet dials and `localPort` the loopback port + * behind it. They are frequently different — nothing forces serve mappings to + * preserve the port number — which is why callers must read this instead of + * assuming the local port is also reachable on the tailnet. + */ +export interface TailscaleServeMapping { + readonly magicDnsName: string; + readonly servePort: number; + readonly path: string; + readonly localHost: string; + readonly localPort: number; + /** Always https: `tailscale serve` terminates TLS for every Web handler. */ + readonly url: string; +} + +const TailscaleServeHandler = Schema.Struct({ + Proxy: Schema.optional(Schema.Unknown), +}); + +const TailscaleServeWebEntry = Schema.Struct({ + Handlers: Schema.optional(Schema.Record(Schema.String, TailscaleServeHandler)), +}); + +const TailscaleServeStatusJson = Schema.Struct({ + Web: Schema.optional(Schema.Record(Schema.String, TailscaleServeWebEntry)), +}); + +const decodeTailscaleServeStatusJson = Schema.decodeEffect( + Schema.fromJsonString(TailscaleServeStatusJson), +); + +/** Splits a `host:port` serve key, tolerating bracketed IPv6 literals. */ +const parseServeHostKey = (key: string): { host: string; port: number } | null => { + const separator = key.lastIndexOf(":"); + if (separator <= 0) return null; + const host = key.slice(0, separator).replace(/^\[|\]$/gu, ""); + const port = Number.parseInt(key.slice(separator + 1), 10); + return host.length > 0 && Number.isInteger(port) && port > 0 && port < 65536 + ? { host, port } + : null; +}; + +export const parseTailscaleServeMappings = ( + rawServeStatusJson: string, +): Effect.Effect => + decodeTailscaleServeStatusJson(rawServeStatusJson).pipe( + Effect.mapError((cause) => new TailscaleServeStatusParseError({ cause })), + Effect.map((parsed) => { + const mappings: Array = []; + for (const [hostKey, entry] of Object.entries(parsed.Web ?? {})) { + const target = parseServeHostKey(hostKey); + if (!target) continue; + for (const [path, handler] of Object.entries(entry.Handlers ?? {})) { + if (typeof handler.Proxy !== "string") continue; + // A non-proxy handler (static text, a file share) has no local port + // to match against, so it is not a route to a dev server. + let proxy: URL; + try { + proxy = new URL(handler.Proxy); + } catch { + continue; + } + const localPort = Number.parseInt(proxy.port, 10); + if (!Number.isInteger(localPort) || localPort <= 0) continue; + const url = new URL(`https://${hostKey}`); + url.pathname = path; + mappings.push({ + magicDnsName: target.host, + servePort: target.port, + path, + localHost: proxy.hostname.replace(/^\[|\]$/gu, ""), + localPort, + url: url.toString(), + }); + } + } + return mappings; }), ); -}); + +export const readTailscaleServeMappings = readTailscaleCommandStdout({ + args: ["serve", "status", "--json"], + subcommand: "serve", + timeout: TAILSCALE_STATUS_TIMEOUT, +}).pipe(Effect.flatMap(parseTailscaleServeMappings)); + +/** + * The mapping that serves `localPort` at the site root, if one exists. + * + * Root-only: a mapping under a sub-path rewrites neither the dev server's + * absolute asset URLs (`/@vite/client`) nor its HMR websocket, so handing one + * out would load a blank page instead of failing honestly. + */ +export const findRootServeMappingForLocalPort = ( + mappings: readonly TailscaleServeMapping[], + localPort: number, +): TailscaleServeMapping | undefined => + mappings.find((mapping) => mapping.localPort === localPort && mapping.path === "/"); export function buildTailscaleHttpsBaseUrl(input: { readonly magicDnsName: string; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index eb2ff380f6ce..797c335be793 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -24,6 +24,9 @@ catalogs: '@pierre/diffs': specifier: 1.3.0-beta.10 version: 1.3.0-beta.10 + dfx: + specifier: 1.0.15 + version: 1.0.15 jose: specifier: 6.2.2 version: 6.2.2 @@ -120,12 +123,15 @@ importers: knip: specifier: 6.34.0 version: 6.34.0 + lint-staged: + specifier: ^16.4.0 + version: 16.4.0 typescript: specifier: 'catalog:' version: 7.0.2 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) apps/desktop: dependencies: @@ -204,7 +210,50 @@ importers: version: 4.3.3 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + + apps/discord-bot: + dependencies: + '@effect/platform-node': + specifier: 4.0.0-rc.112 + version: 4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6) + '@microsoft/teams.apps': + specifier: 2.0.14 + version: 2.0.14 + '@t3tools/client-runtime': + specifier: workspace:* + version: link:../../packages/client-runtime + '@t3tools/contracts': + specifier: workspace:* + version: link:../../packages/contracts + '@t3tools/shared': + specifier: workspace:* + version: link:../../packages/shared + dfx: + specifier: 'catalog:' + version: 1.0.15(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) + effect: + specifier: 4.0.0-rc.112 + version: 4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2) + playwright-core: + specifier: 1.60.0 + version: 1.60.0 + yaml: + specifier: ^2.9.0 + version: 2.9.0 + devDependencies: + '@effect/vitest': + specifier: 4.0.0-rc.112 + version: 4.0.0-rc.112(patch_hash=a16b1e870d8c29e4a98b17cc4c638a4ff471753d8ca3487f78a22b759caf951b)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) + '@types/node': + specifier: 24.12.4 + version: 24.12.4 + tsx: + specifier: ^4.20.5 + version: 4.23.12 + vite-plus: + specifier: 'catalog:' + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) apps/marketing: dependencies: @@ -213,7 +262,7 @@ importers: version: link:../../packages/shared astro: specifier: ^7.0.3 - version: 7.0.3(@astrojs/markdown-remark@7.2.0)(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1)(@types/node@24.12.4)(aws4fetch@1.0.20)(idb-keyval@6.2.1)(ioredis@5.11.0)(jiti@2.7.0)(rollup@4.61.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0) + version: 7.0.3(@astrojs/markdown-remark@7.2.0)(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1)(@types/node@24.12.4)(aws4fetch@1.0.20)(idb-keyval@6.2.1)(ioredis@5.11.0)(jiti@2.7.0)(rollup@4.61.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0) sharp: specifier: 0.34.5 version: 0.34.5 @@ -508,8 +557,8 @@ importers: specifier: 0.9.4 version: 0.9.4(patch_hash=ab9ff544009e1891cfe3930105862d3699007f38922a79f3c98d90018deca368) '@opencode-ai/sdk': - specifier: ^1.3.15 - version: 1.15.13 + specifier: ^1.17.13 + version: 1.18.25 effect: specifier: 4.0.0-rc.112 version: 4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2) @@ -567,7 +616,38 @@ importers: version: link:../../packages/effect-codex-app-server vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + + apps/vscode: + dependencies: + '@t3tools/client-runtime': + specifier: workspace:* + version: link:../../packages/client-runtime + '@t3tools/contracts': + specifier: workspace:* + version: link:../../packages/contracts + '@t3tools/shared': + specifier: workspace:* + version: link:../../packages/shared + dompurify: + specifier: ^3.2.6 + version: 3.4.14 + effect: + specifier: 4.0.0-rc.112 + version: 4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2) + marked: + specifier: ^15.0.12 + version: 15.0.12 + devDependencies: + '@types/vscode': + specifier: 1.95.0 + version: 1.95.0 + esbuild: + specifier: ^0.28.0 + version: 0.28.1 + vite-plus: + specifier: 'catalog:' + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) apps/web: dependencies: @@ -697,13 +777,13 @@ importers: version: 4.0.0-rc.112(patch_hash=a16b1e870d8c29e4a98b17cc4c638a4ff471753d8ca3487f78a22b759caf951b)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) '@rolldown/plugin-babel': specifier: ^0.2.0 - version: 0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5) + version: 0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5) '@tailwindcss/vite': specifier: 4.3.3 - version: 4.3.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)) + version: 4.3.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)) '@tanstack/router-plugin': specifier: ^1.161.0 - version: 1.168.13(@tanstack/react-router@1.170.10(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)) + version: 1.168.13(@tanstack/react-router@1.170.10(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)) '@types/babel__core': specifier: ^7.20.5 version: 7.20.5 @@ -730,7 +810,7 @@ importers: version: 0.3.0 '@vitejs/plugin-react': specifier: ^6.0.0 - version: 6.0.2(@rolldown/plugin-babel@0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(babel-plugin-react-compiler@1.0.0) + version: 6.0.2(@rolldown/plugin-babel@0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(babel-plugin-react-compiler@1.0.0) babel-plugin-react-compiler: specifier: 1.0.0 version: 1.0.0 @@ -748,10 +828,10 @@ importers: version: 11.0.5 vite: specifier: npm:@voidzero-dev/vite-plus-core@0.3.0 - version: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + version: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) infra/relay: dependencies: @@ -778,7 +858,7 @@ importers: version: link:../../packages/shared alchemy: specifier: 2.0.0-beta.76 - version: 2.0.0-beta.76(b3825b36417e56a486ccb5f22a7f3d7e) + version: 2.0.0-beta.76(2a29e483e9ca6fbc5e022c796b06f03f) drizzle-orm: specifier: 1.0.0-rc.5-ab785fc version: 1.0.0-rc.5-ab785fc(8ab70e2706da13c78d64d8a92fef1884) @@ -803,10 +883,10 @@ importers: version: 1.0.0-rc.5-ab785fc vite: specifier: npm:@voidzero-dev/vite-plus-core@0.3.0 - version: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + version: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) oxlint-plugin-t3code: dependencies: @@ -825,7 +905,7 @@ importers: version: 4.0.0-rc.112(patch_hash=a16b1e870d8c29e4a98b17cc4c638a4ff471753d8ca3487f78a22b759caf951b)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/client-runtime: dependencies: @@ -857,12 +937,18 @@ importers: '@effect/vitest': specifier: 4.0.0-rc.112 version: 4.0.0-rc.112(patch_hash=a16b1e870d8c29e4a98b17cc4c638a4ff471753d8ca3487f78a22b759caf951b)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) + '@types/react': + specifier: ~19.2.14 + version: 19.2.16 micromark-util-types: specifier: ^2.0.2 version: 2.0.2 + react: + specifier: 19.2.6 + version: 19.2.6 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/contracts: dependencies: @@ -875,7 +961,7 @@ importers: version: 4.0.0-rc.112(patch_hash=a16b1e870d8c29e4a98b17cc4c638a4ff471753d8ca3487f78a22b759caf951b)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/effect-acp: dependencies: @@ -885,7 +971,7 @@ importers: devDependencies: '@effect/openapi-generator': specifier: 'catalog:' - version: 4.0.0-rc.112(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(encoding@0.1.13) + version: 4.0.0-rc.112(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) '@effect/platform-node': specifier: 4.0.0-rc.112 version: 4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6) @@ -897,7 +983,7 @@ importers: version: 24.12.4 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/effect-codex-app-server: dependencies: @@ -907,7 +993,7 @@ importers: devDependencies: '@effect/openapi-generator': specifier: 'catalog:' - version: 4.0.0-rc.112(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(encoding@0.1.13) + version: 4.0.0-rc.112(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) '@effect/platform-node': specifier: 4.0.0-rc.112 version: 4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6) @@ -919,7 +1005,7 @@ importers: version: 24.12.4 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/shared: dependencies: @@ -953,7 +1039,7 @@ importers: version: 24.12.4 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/ssh: dependencies: @@ -978,7 +1064,7 @@ importers: version: 24.12.4 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages/tailscale: dependencies: @@ -997,7 +1083,7 @@ importers: version: 24.12.4 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) scripts: dependencies: @@ -1040,7 +1126,7 @@ importers: version: typescript@6.0.3 vite-plus: specifier: 'catalog:' - version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + version: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) packages: @@ -1300,6 +1386,14 @@ packages: resolution: {integrity: sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ==} engines: {node: '>=18.0.0'} + '@azure/msal-common@16.13.0': + resolution: {integrity: sha512-rOAy0KUcyBbdwVJ+f3uPpthXatFLLZN+/KWAsTLzk1aB23Xl9DRmmXYwSvBFOZyXj4jUQQ5FKxxRkhAFW1fOow==} + engines: {node: '>=0.8.0'} + + '@azure/msal-node@5.6.0': + resolution: {integrity: sha512-uFY9NxrWHw8PwZx7gAX6PDn+9vdfS05+levc/kwkx77IkjfaldnQbbcQzzDIZ5Hq5Zdr6/z92oAIoRWKp6MnOA==} + engines: {node: '>=20'} + '@babel/code-frame@7.29.7': resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==} engines: {node: '>=6.9.0'} @@ -2274,9 +2368,6 @@ packages: '@emnapi/runtime@1.11.2': resolution: {integrity: sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==} - '@emnapi/runtime@1.11.3': - resolution: {integrity: sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==} - '@emnapi/wasi-threads@1.2.1': resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==} @@ -2902,8 +2993,8 @@ packages: cpu: [arm64] os: [darwin] - '@img/sharp-darwin-arm64@0.35.4': - resolution: {integrity: sha512-Uhfl4V4lhP2nbUVF9+hyH1+luj86f1gUFeo8ALYxFoULoU+G87D43BfeMP8XHsk9boxAnCY/bf2EHwhA7MuGsA==} + '@img/sharp-darwin-arm64@0.35.3': + resolution: {integrity: sha512-RMnFX7YQsMoh7lWfcM4NEHHymBX/rLuKNPVM84XE9ONPcaSCDgE7CHIHpSgPcO2xcRthgBy1HfNO319mwhIAkg==} engines: {node: '>=20.9.0'} cpu: [arm64] os: [darwin] @@ -2914,14 +3005,14 @@ packages: cpu: [x64] os: [darwin] - '@img/sharp-darwin-x64@0.35.4': - resolution: {integrity: sha512-hWniXY3bG5qKpkKrAwPe4y+VTPmf086YQAnkxWh7uA1YrlRouWGa0M0Mxj3ZjnXFkv7/TD1bTy9lGUK26vRvWw==} + '@img/sharp-darwin-x64@0.35.3': + resolution: {integrity: sha512-Xo+5uFBtLN0BKqieTxiFzFPQAUlBbbH5iBKyRX/z1JrbnYsHTfKJnUfL8+p2TPXr1pXqao4eeL4Rl144uDpK9w==} engines: {node: '>=20.9.0'} cpu: [x64] os: [darwin] - '@img/sharp-freebsd-wasm32@0.35.4': - resolution: {integrity: sha512-lIsKw/BU+kjB4eZjxrYrZmwOJYi3Ajrv66iAlBmUPyKc3HpnloevB1g3wxGD9P/5BbQ1brBGl65VRRrCvQDEqA==} + '@img/sharp-freebsd-wasm32@0.35.3': + resolution: {integrity: sha512-lUxcqWIj2wMQ9BrwNjngcr1gWUr5xgaGThBRqPPalIC2n67Cqj1uPh8NnA/ZhAg8hUbKl+kVHKwgUIwe6ZYPrg==} engines: {node: '>=20.9.0'} os: [freebsd] @@ -2930,8 +3021,8 @@ packages: cpu: [arm64] os: [darwin] - '@img/sharp-libvips-darwin-arm64@1.3.3': - resolution: {integrity: sha512-suTBPTDGrI9WodccaDdwZItTSaBYASlBk1NSfElSHrUfzu3szG6lvIF58+WiFvnfzuK8ZBFS5zE00PxqxnRiPg==} + '@img/sharp-libvips-darwin-arm64@1.3.2': + resolution: {integrity: sha512-9J6ypZFpQBj4YnePGoq/S38w6nz+vqg5WZLrLGY4YuSemdMq47GMLBPO42MzwdGwpg/agZ7xzZcFHa48xlywfg==} cpu: [arm64] os: [darwin] @@ -2940,8 +3031,8 @@ packages: cpu: [x64] os: [darwin] - '@img/sharp-libvips-darwin-x64@1.3.3': - resolution: {integrity: sha512-FVJZ5mITMobmXIz/hPDTw0EintTW5H3WfrxwLqEqjiIihlu+hVRyGrFQ60xl0Lxn7Bt3zdpevPaQi0HEzqz9fw==} + '@img/sharp-libvips-darwin-x64@1.3.2': + resolution: {integrity: sha512-m2pW1n6cns9VaubNwsZ+c3CRYjxNQWgJ5gPlnL1nbBcpkBvFm6SCFN5o0psFHI8w9n11NKhFkeEDns98tiqbEw==} cpu: [x64] os: [darwin] @@ -2951,8 +3042,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-libvips-linux-arm64@1.3.3': - resolution: {integrity: sha512-0DaL0A6Xu6sQSQFwe4iVCrKWU2cCTItnRsYsCdxAMm9NF6twAA9BKnoqy4hqz4+azQ0JHuA26qiUKsf1XJ/v5A==} + '@img/sharp-libvips-linux-arm64@1.3.2': + resolution: {integrity: sha512-dqVSFynCox4C/J8kT16V7SIFAns0IjgLwkvYT7p8LQVmJ5OS5b6tI9IGflxTeuBS//zXeFIUbwt5dwxyZ17cnA==} cpu: [arm64] os: [linux] libc: [glibc] @@ -2963,8 +3054,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-libvips-linux-arm@1.3.3': - resolution: {integrity: sha512-3rbU4vqXXc3hY/OiXdl52xZvT0F1yEngWfvqudtPJg/KkyiaQw2DRsFrNzpmLvfavbwOq3qXn36GP8obHRULQA==} + '@img/sharp-libvips-linux-arm@1.3.2': + resolution: {integrity: sha512-1eMLzy92I4J6rmi4mAT8yC3HxOtniyGELlzGbNMLLeqe052ahFQ0h6LFq+lh5DsDIdYViIDst08abvSbcEdLXQ==} cpu: [arm] os: [linux] libc: [glibc] @@ -2975,8 +3066,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-libvips-linux-ppc64@1.3.3': - resolution: {integrity: sha512-cdn1OvUBwsXhbC0zSzJnNzf5MZ/mTrobawDvNXBTxe8VtqKAm0sRuEY2Evzovb/w9JMk4TvRxqt1mekSuJz64w==} + '@img/sharp-libvips-linux-ppc64@1.3.2': + resolution: {integrity: sha512-3z0NHDxD6n5I9gc05U1eW1AyRm+Gznzq3naMrthPNqE6oYykcogW0l/jfpJdjYnuNl8R7yI9pNbE1XiUeyq0Aw==} cpu: [ppc64] os: [linux] libc: [glibc] @@ -2987,8 +3078,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-libvips-linux-riscv64@1.3.3': - resolution: {integrity: sha512-HjPVx7yKz+0lqdhDlTw1tt90wamBoxhiXpvl1XZpJLiHH4RCJ5yDTqH+VlYPv2fwFs89JFw4c1IexYOcQUi4IQ==} + '@img/sharp-libvips-linux-riscv64@1.3.2': + resolution: {integrity: sha512-bsb4rI+NldGOsXuej2r8OdSS8+zXDVaCWxyWrcv6kneTOlgAHtZABRzBBCwdsPiD90J4myNJuHpg6kA20ImW/w==} cpu: [riscv64] os: [linux] libc: [glibc] @@ -2999,8 +3090,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-libvips-linux-s390x@1.3.3': - resolution: {integrity: sha512-neWLh+3yCNThxnfy3c4BbVBeGgt9aftno+XbT56iK28RgeDs3UOFWviLWlUu0bArYVYJaFDK+RRohbicUNCm8Q==} + '@img/sharp-libvips-linux-s390x@1.3.2': + resolution: {integrity: sha512-/ABshyj8gCpyIrNXnHn4LorDJ0HHm1VhXPBlxZ8zAtfVPAaSafXPGn+sUSIRiwaSBy0mmFjSjiXI5mkcwdChKQ==} cpu: [s390x] os: [linux] libc: [glibc] @@ -3011,8 +3102,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-libvips-linux-x64@1.3.3': - resolution: {integrity: sha512-4vKmvAst9nrowcqquKFAyZJUDolUaIp8uRiN0mWFguJ1IplC9/pitXtlnnlU4aa/eJw3J7i67V+pwUL+wZGdsA==} + '@img/sharp-libvips-linux-x64@1.3.2': + resolution: {integrity: sha512-ITPEtgffGJ0S6G9dRyw/366tJQqFRcHWPHhC+Stpg3Z8AEMrDrTr2lhdz4f/Y/HMbRh//7Z5mBzEpVdi62Oc3w==} cpu: [x64] os: [linux] libc: [glibc] @@ -3023,8 +3114,8 @@ packages: os: [linux] libc: [musl] - '@img/sharp-libvips-linuxmusl-arm64@1.3.3': - resolution: {integrity: sha512-Y9kQaLMuNoB0bPYOOdcZMaseNrFpPodIWWMrx+CZyydf2xn68j9WYc6sWWRrDwNkzCQjKYfc68L7jKjGlHMibw==} + '@img/sharp-libvips-linuxmusl-arm64@1.3.2': + resolution: {integrity: sha512-zE9EdiUzUmg5mDT5a1rk5fYJ6GWPloTwWBYDS14naqHsL+EaMpDj1AWnpLgh3u0YCORv2Tt50wrcrpYqkP97Kw==} cpu: [arm64] os: [linux] libc: [musl] @@ -3035,8 +3126,8 @@ packages: os: [linux] libc: [musl] - '@img/sharp-libvips-linuxmusl-x64@1.3.3': - resolution: {integrity: sha512-fj8Mv0HHfD1Rr+4I68+3agJynxDWtBFgicTbSOb9Bke6pIwzGcJ+RX/yHjmiEGFMCavY/dxvem7MyNaJF+wDiw==} + '@img/sharp-libvips-linuxmusl-x64@1.3.2': + resolution: {integrity: sha512-m0lrLiUt+lBYnCFr8qV/65yMR4E/c7/wf78I5eKTdkEakFAlZ9QlzEM3QIhhAwVeUhLAHLcCq7a7Vszq/oFNZQ==} cpu: [x64] os: [linux] libc: [musl] @@ -3048,8 +3139,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-linux-arm64@0.35.4': - resolution: {integrity: sha512-De4jpEnAU8Hd5oT0j1G3uL4ZvTuipVMn7YC6vPaJhy6/7EwEae0SVAoBrUMYQbkLGDm85taVWwuPc1a44LTzCQ==} + '@img/sharp-linux-arm64@0.35.3': + resolution: {integrity: sha512-QgKDspHPnrU+GQ55XPhGwyhC8acLVOOSyAvo1oVfFmrIXLkDNmGWzAfDZ4xK8oSA1qBQrALcHX0G5UZni/SuFQ==} engines: {node: '>=20.9.0'} cpu: [arm64] os: [linux] @@ -3062,8 +3153,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-linux-arm@0.35.4': - resolution: {integrity: sha512-7OAS8gI0EReKGVN2HssHlM6umJgxF5VI3xN0p9FA91p/YO+ou5hiNghLdZ5BEHztwaaK5+bLKRf8x/o2L2nk9A==} + '@img/sharp-linux-arm@0.35.3': + resolution: {integrity: sha512-affVWCTLooy8TSxbDx2qkzuDeaWLNVBA+P//FNBirHsXpP2fuBhk5AuboYUnrDnzoXes8GFjpTx0SBFOCRg+FA==} engines: {node: '>=20.9.0'} cpu: [arm] os: [linux] @@ -3076,8 +3167,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-linux-ppc64@0.35.4': - resolution: {integrity: sha512-2oYZJeIl4kCcMGk4ouZVjnkCtFrpQFlNEtJ6GbxzhHQchwH0NH/qEb9ykmOl29dqwMq+JhFdZn+1ak2FKhI9fQ==} + '@img/sharp-linux-ppc64@0.35.3': + resolution: {integrity: sha512-sMd8rDxmpLOwv/7N44klFjOD5DUO7FLdjiXDI0hoxYaf7Ar262dQIEkosE98bps+5HPLtp/EvNqeqQtOycP/IA==} engines: {node: '>=20.9.0'} cpu: [ppc64] os: [linux] @@ -3090,8 +3181,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-linux-riscv64@0.35.4': - resolution: {integrity: sha512-cPbNChoRURAWdebDIHSenxRpgEdy7JkPydSnUxRm9VvKD7m0/xVaR/8Fzlu81pk5nHEvHH87UZUA7cTtwnbJSA==} + '@img/sharp-linux-riscv64@0.35.3': + resolution: {integrity: sha512-0Eob78yjlYPfL5vMNWAW55l3R9Y6BQS/gOfe0ZcP9mEz9ohhKSt4im1hayiknXgf8AWrFqMvJcKIdmLmEe7yeQ==} engines: {node: '>=20.9.0'} cpu: [riscv64] os: [linux] @@ -3104,8 +3195,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-linux-s390x@0.35.4': - resolution: {integrity: sha512-RY0JFY8Fd6RonCBtHz+DvadaPkXDSI1AUn6yWL9TipqkZ1vY8w8evqdgyDFnkm4/K1ve1TvZiaePP5oSd4+WVQ==} + '@img/sharp-linux-s390x@0.35.3': + resolution: {integrity: sha512-KgAxQ0DxpNOq1rG2t5cgTgShJFGSuU7XO45cqC+1NVOuZnP6tlgZRuSYOfNupGkHID0o3cJOsw4DVeJpMovcGw==} engines: {node: '>=20.9.0'} cpu: [s390x] os: [linux] @@ -3118,8 +3209,8 @@ packages: os: [linux] libc: [glibc] - '@img/sharp-linux-x64@0.35.4': - resolution: {integrity: sha512-9qvvEAuk8k89TfWUoX2htWjbAMX8p+NxCppjpcg5k6xMsjhBQPTsoIh36h9Qde4WRuGpJeYnOjdosDn/cnv+OA==} + '@img/sharp-linux-x64@0.35.3': + resolution: {integrity: sha512-8pqvxubL2PGdhlPy6GLqzDYMUjyRmKAwKHYKixpdJYBUK7PJ0C029XdsnpFIdgRZG68fZiGdHVWcKPvtiPB4cA==} engines: {node: '>=20.9.0'} cpu: [x64] os: [linux] @@ -3132,8 +3223,8 @@ packages: os: [linux] libc: [musl] - '@img/sharp-linuxmusl-arm64@0.35.4': - resolution: {integrity: sha512-KB5jxpfWQTr0nc3xdHtWChdbifHrBGsd2SM62Eyxrl8afikm+f5qGBU75SJIZBT/S1MC8XyacdlXBMSWq6OURA==} + '@img/sharp-linuxmusl-arm64@0.35.3': + resolution: {integrity: sha512-Vz0iQjzzcSX3HCbfwFfCSG/9SCIqyO0mH2sXyiHaAYfBk0cRsCWXRyQYX0ovCK/PAQBbTzQ0dsPQHh5MAFL59w==} engines: {node: '>=20.9.0'} cpu: [arm64] os: [linux] @@ -3146,8 +3237,8 @@ packages: os: [linux] libc: [musl] - '@img/sharp-linuxmusl-x64@0.35.4': - resolution: {integrity: sha512-f+eZJZIQNEEd26RPSW+76chwOf1XtA2Y/O+5ocVyLliHkeih3e+jhLVBdNTd2rS3IbNXK8+ug93Vf5ZXtF5Lxg==} + '@img/sharp-linuxmusl-x64@0.35.3': + resolution: {integrity: sha512-6O1NPKcDVj9QEdg7Hx549EX8U0rp6yXQERqru6yRN7fGBn32UvIRJUlWnk+8xDCiG76hXVBbX82NZ/ZKr0euIg==} engines: {node: '>=20.9.0'} cpu: [x64] os: [linux] @@ -3158,12 +3249,12 @@ packages: engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} cpu: [wasm32] - '@img/sharp-wasm32@0.35.4': - resolution: {integrity: sha512-zQnl4Kwp7Q6NHsENtU2T/00Zi+w3AQNwz3+UaTyVBy2FpXrzXzGjndpK61onhZjRtRpQXxCTeqw19bVyXOh7jA==} + '@img/sharp-wasm32@0.35.3': + resolution: {integrity: sha512-cZ0XkcYGpHZkqW6iCkqTcmUC0CD9DhD5d/qeZlZkfRBn6GnHniZXLUo5+9xw8Iv76YE6LQFN9YNBlKREcCG76w==} engines: {node: '>=20.9.0'} - '@img/sharp-webcontainers-wasm32@0.35.4': - resolution: {integrity: sha512-ESfNkywmCfPNyaZjxooddJQiQ+l/nTpGEOGthxiLnIHXC/CmcBixnfwUleX9mCz9ovrUUvKMap/pm8RYbzfwaA==} + '@img/sharp-webcontainers-wasm32@0.35.3': + resolution: {integrity: sha512-2rnq7bX3NzeR2T4YWgz8qiG4h3TSdMe+vN1iQXpJleSJ3SM5zQ8Fy2SyyXAWlbxpEZ2Y+Z4u1BePgJEYbSy80Q==} engines: {node: '>=20.9.0'} cpu: [wasm32] @@ -3173,8 +3264,8 @@ packages: cpu: [arm64] os: [win32] - '@img/sharp-win32-arm64@0.35.4': - resolution: {integrity: sha512-iNdlBX9gLVvqe2I3uIJSIKTq6wckP/DYxZtcqxm09x5Gi24DnFBmPAWZmr60ZyYMG0xlzo6goG3670ar+RXvRw==} + '@img/sharp-win32-arm64@0.35.3': + resolution: {integrity: sha512-4bPwFdMbeC4JQ8L8LOyWp6nsHcboP5fxkp6iPOXz2Vg49R42TuMs2whkJ5OAP4/Ul035qOzy0AecOF9VOscn4w==} engines: {node: '>=20.9.0'} cpu: [arm64] os: [win32] @@ -3185,8 +3276,8 @@ packages: cpu: [ia32] os: [win32] - '@img/sharp-win32-ia32@0.35.4': - resolution: {integrity: sha512-kqRsbaa5CS6KHlpxnN7WhE6vAAugXyZButpRdvDWetlv6Qv4N9WTcrWzF7tXfB9T7MsoadqdI8hmwLq6UlLvtw==} + '@img/sharp-win32-ia32@0.35.3': + resolution: {integrity: sha512-r53mXsBN6lFUDiST764SvgwUdHAqM4rPAiDzAmf4fLoB6X/rkfyTrLCg6+g17wJJiCmB3JYgHuUldCWUIRFSXw==} engines: {node: ^20.9.0} cpu: [ia32] os: [win32] @@ -3197,8 +3288,8 @@ packages: cpu: [x64] os: [win32] - '@img/sharp-win32-x64@0.35.4': - resolution: {integrity: sha512-XtmnYhBcrORsJ4XJngyzr/EWP0hRZLAZRFaApdKuviyqF78+ylxh2y06ZmtULAMOnObJ3ucpN0AcwSWnMowTRg==} + '@img/sharp-win32-x64@0.35.3': + resolution: {integrity: sha512-D4y1vNeZrIIJCN+uHaWVtH86B+aCrdMYYjicy9pXHvbGZeGYLLSd3wdVuC37FxVXlU1ARsk84eKWfWMXGYEqvA==} engines: {node: '>=20.9.0'} cpu: [x64] os: [win32] @@ -3434,6 +3525,26 @@ packages: '@material/material-color-utilities@0.3.0': resolution: {integrity: sha512-ztmtTd6xwnuh2/xu+Vb01btgV8SQWYCaK56CkRK8gEkWe5TuDyBcYJ0wgkMRn+2VcE9KUmhvkz+N9GHrqw/C0g==} + '@microsoft/teams.api@2.0.14': + resolution: {integrity: sha512-mEHBgs7yklydQWTlfGFok5i7np2WxOKS3j6aMgRH0HVfiLqenPjGm0NAWKR/Hg29n9ODtGZZeuIXNCwIYQ8syA==} + engines: {node: '>=20'} + + '@microsoft/teams.apps@2.0.14': + resolution: {integrity: sha512-7re8a3pnAUSD5rAGlWbKQd07XtQJwyuZ4rI7EWyqBQT2iLhqUU1r4jtq3jQFpfov7xhADVV+oExCc7IbNyYuGw==} + engines: {node: '>=20'} + + '@microsoft/teams.cards@2.0.14': + resolution: {integrity: sha512-qrWnjJVgMPO8vvbLEiTeBLrrRLsr4rletQnuP9fPMXTTcrNx+Dh0gYWtQAOBvpoAuFo5tTXR/waNFNUm8IZtBw==} + engines: {node: '>=20'} + + '@microsoft/teams.common@2.0.14': + resolution: {integrity: sha512-cjf3b/2sr5RqqiOaDuogJQ9fUNRZjDSh9eBEAv6NqkigNNLLjDgEgEl5lLoJsPp4usvc3drwFkx6HayuEbT7vA==} + engines: {node: '>=20'} + + '@microsoft/teams.graph@2.0.14': + resolution: {integrity: sha512-PufhROXKhsC/h6ZKuquPzvNBB1Q9lHHu//vZGfRj3yD+hgtQkEz2YzXZDYC3h0bDN4ej2KtvkDGrsovqrnU0cQ==} + engines: {node: '>=20'} + '@modelcontextprotocol/sdk@1.29.0': resolution: {integrity: sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==} engines: {node: '>=18'} @@ -3682,8 +3793,8 @@ packages: '@open-draft/until@2.1.0': resolution: {integrity: sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg==} - '@opencode-ai/sdk@1.15.13': - resolution: {integrity: sha512-4TwojIoQ8EG6/mVBuUVYZXiFcwNmiiytEnjnvyuvSJjGwFIlw2YIBFxtSVC3FbwwbwHT63teh1RHiQUUC4U5xw==} + '@opencode-ai/sdk@1.18.25': + resolution: {integrity: sha512-GwgwhW+vE8FWSDw730SjzqNhsWXB0uJjbFOiqFkmM+USFuG13HuTlGe6SR2ixt+WXxoD6FV1hILWqsXyqej9hQ==} '@oslojs/encoding@1.1.0': resolution: {integrity: sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ==} @@ -5379,9 +5490,15 @@ packages: '@types/estree@1.0.9': resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==} + '@types/express-serve-static-core@4.19.9': + resolution: {integrity: sha512-QP2ESEe/ImWY0HDwNAnK9PvEffUyhLTnWkk7KXzHfyeWAnlrDe1fN77bXl6ia8KT3wPlmA7t9/VPRpnf4Ex9sg==} + '@types/express-serve-static-core@5.1.3': resolution: {integrity: sha512-dPfW8NFiOF4wOHc7+N/QSxlY9cfSsenewGbAz8C8U/MULPd/YZ27LvJUIlzaXie7e6Ove9YunJGgC9tbHD2cKw==} + '@types/express@4.17.25': + resolution: {integrity: sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==} + '@types/express@5.0.6': resolution: {integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==} @@ -5412,12 +5529,18 @@ packages: '@types/json-schema@7.0.15': resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + '@types/jsonwebtoken@9.0.10': + resolution: {integrity: sha512-asx5hIG9Qmf/1oStypjanR7iKTv0gXQ1Ov/jfrX6kS/EO0OFni8orbmGCn0672NHR3kXHwpAwR+B368ZGN/2rA==} + '@types/keyv@3.1.4': resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==} '@types/mdast@4.0.4': resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==} + '@types/mime@1.3.5': + resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==} + '@types/ms@2.1.0': resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==} @@ -5450,21 +5573,33 @@ packages: '@types/responselike@1.0.3': resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==} + '@types/send@0.17.6': + resolution: {integrity: sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==} + '@types/send@1.2.1': resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==} + '@types/serve-static@1.15.10': + resolution: {integrity: sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==} + '@types/serve-static@2.2.0': resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==} '@types/statuses@2.0.6': resolution: {integrity: sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==} + '@types/trusted-types@2.0.7': + resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==} + '@types/unist@2.0.11': resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==} '@types/unist@3.0.3': resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==} + '@types/vscode@1.95.0': + resolution: {integrity: sha512-0LBD8TEiNbet3NvWsmn59zLzOFu/txSlGxnv5yAFHCrhG9WvAnR3IvfHzMOs2aeWqgvNjq9pO99IUw8d3n+unw==} + '@types/webidl-conversions@7.0.3': resolution: {integrity: sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==} @@ -6032,6 +6167,10 @@ packages: engines: {node: '>=0.4.0'} hasBin: true + agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} + agent-base@7.1.4: resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} engines: {node: '>= 14'} @@ -6265,6 +6404,9 @@ packages: aws4fetch@1.0.20: resolution: {integrity: sha512-/djoAN709iY65ETD6LKCtyyEI04XIBP5xVvfmNxsEP0uJB5tyaGBztSryRr4HqMStr9R06PisQE7m9zDTXKu6g==} + axios@1.20.0: + resolution: {integrity: sha512-r8aOh8j9cGKpgQAqpzrUHnSIc6a59Y3Xf/cv8sy1DrHCkZHzQGEuoq1tARk6qSyDdtQGSDgpb9kFlruzPvrgwg==} + axobject-query@4.1.0: resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==} engines: {node: '>= 0.4'} @@ -6413,6 +6555,9 @@ packages: resolution: {integrity: sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==} engines: {node: '>=16.20.1'} + buffer-equal-constant-time@1.0.1: + resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==} + buffer-from@1.1.2: resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} @@ -6639,6 +6784,9 @@ packages: resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==} engines: {node: '>=12.5.0'} + colorette@2.0.20: + resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==} + combined-stream@1.0.8: resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} engines: {node: '>= 0.8'} @@ -6907,6 +7055,11 @@ packages: devlop@1.1.0: resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==} + dfx@1.0.15: + resolution: {integrity: sha512-LqHeOZLcOJB5D0+BUiy6XkthunolbJoSAAIOjXEiux5P6CzXPbJl0EkaWSDXTbkj/F/pdW9lk1zCC4XAl8yG+w==} + peerDependencies: + effect: 4.0.0-rc.112 + diff@8.0.3: resolution: {integrity: sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ==} engines: {node: '>=0.3.1'} @@ -6918,6 +7071,13 @@ packages: dir-compare@4.2.0: resolution: {integrity: sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==} + discord-api-types@0.38.53: + resolution: {integrity: sha512-HL1zz/UuZ+bbJjA/X8Kbxx9gk8v9rJAbTeWRNYKmIdjwJ7EovjlHgoJTxcLpATfNJ+AonOtMdy3Y5MVIJAAd/A==} + + discord-verify@1.2.0: + resolution: {integrity: sha512-8qlrMROW8DhpzWWzgNq9kpeLDxKanWa4EDVoj/ASVv2nr+dSr4JPmu2tFSydf3hAGI/OIJTnZyD0JulMYIxx4w==} + engines: {node: '>=16'} + dmg-builder@26.15.6: resolution: {integrity: sha512-nr5vQxEhM0REomp1qiHbc6V99yrfBZy+wUU56VXADfSOlLj8PdLqsHiRe7b+FbqKesiyv4ax+k1GVwGonYKuCg==} @@ -6937,6 +7097,9 @@ packages: resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} engines: {node: '>= 4'} + dompurify@3.4.14: + resolution: {integrity: sha512-dVoH9z+MY+C9IilgGCk3YfFqjLi3fChm2OiKJMzh6axrJ5qwxqWaZamgmHrpv22CN/KdbZJuGEGgfQoL00LTdg==} + domutils@3.2.2: resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==} @@ -7119,6 +7282,9 @@ packages: duplexer@0.1.2: resolution: {integrity: sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==} + ecdsa-sig-formatter@1.0.11: + resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==} + ee-first@1.1.1: resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} @@ -7176,9 +7342,6 @@ packages: resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==} engines: {node: '>= 0.8'} - encoding@0.1.13: - resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==} - end-of-stream@1.4.5: resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==} @@ -7741,6 +7904,15 @@ packages: flow-enums-runtime@0.0.6: resolution: {integrity: sha512-3PYnM29RFXwvAN6Pc/scUfkI7RwhQ/xqyLUyPNlXUp9S40zI8nup9tUSrTLSVnWGBN38FNiGWbwZOB6uR4OGdw==} + follow-redirects@1.16.0: + resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + fontace@0.4.1: resolution: {integrity: sha512-lDMvbAzSnHmbYMTEld5qdtvNH2/pWpICOqpean9IgC7vUbUJc3k+k5Dokp85CegamqQpFbXf0rAVkbzpyTA8aw==} @@ -7755,8 +7927,8 @@ packages: resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==} engines: {node: '>=14'} - form-data@4.0.5: - resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==} + form-data@4.0.6: + resolution: {integrity: sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==} engines: {node: '>= 6'} formatly@0.7.0: @@ -8045,14 +8217,14 @@ packages: resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} engines: {node: '>=10.19.0'} + https-proxy-agent@5.0.1: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} + https-proxy-agent@7.0.6: resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==} engines: {node: '>= 14'} - iconv-lite@0.6.3: - resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} - engines: {node: '>=0.10.0'} - iconv-lite@0.7.2: resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==} engines: {node: '>=0.10.0'} @@ -8272,6 +8444,9 @@ packages: resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==} hasBin: true + jose@4.15.9: + resolution: {integrity: sha512-1vUQX+IdDMVPj4k8kOxgUqlcK518yluMuGZwqlr44FS1ppZB/5GWh4rZG89erpOBOJjU/OBsnCVFfapsRz6nEA==} + jose@6.2.2: resolution: {integrity: sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ==} @@ -8351,9 +8526,27 @@ packages: jsonfile@6.2.1: resolution: {integrity: sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==} + jsonwebtoken@9.0.3: + resolution: {integrity: sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==} + engines: {node: '>=12', npm: '>=6'} + jszip@3.10.1: resolution: {integrity: sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==} + jwa@2.0.1: + resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==} + + jwks-rsa@3.2.2: + resolution: {integrity: sha512-BqTyEDV+lS8F2trk3A+qJnxV5Q9EqKCBJOPti3W97r7qTympCZjb7h2X6f2kc+0K3rsSTY1/6YG2eaXKoj497w==} + engines: {node: '>=14'} + + jws@4.0.1: + resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==} + + jwt-decode@4.0.0: + resolution: {integrity: sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA==} + engines: {node: '>=18'} + keyv@4.5.4: resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} @@ -8484,20 +8677,56 @@ packages: resolution: {integrity: sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==} engines: {node: '>=10'} + limiter@1.1.5: + resolution: {integrity: sha512-FWWMIEOxz3GwUI4Ts/IvgVy6LPvoMPgjMdQ185nN6psJyBJ4yOpzqm695/h5umdLJg2vW3GR5iG11MAkR2AzJA==} + + lint-staged@16.4.0: + resolution: {integrity: sha512-lBWt8hujh/Cjysw5GYVmZpFHXDCgZzhrOm8vbcUdobADZNOK/bRshr2kM3DfgrrtR1DQhfupW9gnIXOfiFi+bw==} + engines: {node: '>=20.17'} + hasBin: true + + listr2@9.0.5: + resolution: {integrity: sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==} + engines: {node: '>=20.0.0'} + locate-path@3.0.0: resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==} engines: {node: '>=6'} + lodash.clonedeep@4.5.0: + resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} + lodash.debounce@4.0.8: resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==} lodash.escaperegexp@4.1.2: resolution: {integrity: sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw==} + lodash.includes@4.3.0: + resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==} + + lodash.isboolean@3.0.3: + resolution: {integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==} + lodash.isequal@4.5.0: resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} deprecated: This package is deprecated. Use require('node:util').isDeepStrictEqual instead. + lodash.isinteger@4.0.4: + resolution: {integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==} + + lodash.isnumber@3.0.3: + resolution: {integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==} + + lodash.isplainobject@4.0.6: + resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==} + + lodash.isstring@4.0.1: + resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==} + + lodash.once@4.1.1: + resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==} + lodash.throttle@4.1.1: resolution: {integrity: sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==} @@ -8515,6 +8744,10 @@ packages: resolution: {integrity: sha512-ja1E3yCr9i/0hmBVaM0bfwDjnGy8I/s6PP4DFp+yP+a+mrHO4Rm7DtmnqROTUkHIkqffC84YY7AeqX6oFk0WFg==} engines: {node: '>=18'} + log-update@6.1.0: + resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==} + engines: {node: '>=18'} + long@4.0.0: resolution: {integrity: sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==} @@ -8543,6 +8776,9 @@ packages: resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==} engines: {node: '>=10'} + lru-memoizer@2.3.0: + resolution: {integrity: sha512-GXn7gyHAMhO13WSKrIiNfztwxodVsP8IoZ3XfrJV4yH2x0/OeTO/FIaAHTY5YekdGgW94njfuKmyyt1E0mR6Ug==} + lru_map@0.4.1: resolution: {integrity: sha512-I+lBvqMMFfqaV8CJCISjI3wbjmwVu/VyOoU7+qtu9d7ioW5klMgsTTiUOUp+DJvfTTzKXoPbyC6YfgkNcyPSOg==} @@ -8570,6 +8806,11 @@ packages: markdown-table@3.0.4: resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==} + marked@15.0.12: + resolution: {integrity: sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA==} + engines: {node: '>= 18'} + hasBin: true + marky@1.3.0: resolution: {integrity: sha512-ocnPZQLNpvbedwTy9kNrQEsknEfgvcLMvOtz3sFeWApDq1MXH1TqkCIx58xlpESsfwQOnuBO9beyQuNGzVvuhQ==} @@ -9597,6 +9838,10 @@ packages: resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} engines: {node: '>= 0.10'} + proxy-from-env@2.1.0: + resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==} + engines: {node: '>=10'} + pump@3.0.4: resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==} @@ -9883,6 +10128,9 @@ packages: resolution: {integrity: sha512-Z9VHtgYs48PiQC77X9O2Er8Hj4T+5BtFjT91/vi5Is1D04N72cA946ZslM1ImJw8ZctFBZWAVjM7S5wJNeHMpg==} engines: {node: '>= 20.0.0'} + reflect-metadata@0.2.2: + resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==} + reftools@1.1.9: resolution: {integrity: sha512-OVede/NQE13xBQ+ob5CKd5KyeJYU2YInb1bmV4nRoOfquZPkAkxuOXicSe1PvqIuZZ4kD13sPKBbR7UFDmli6w==} @@ -10033,6 +10281,9 @@ packages: resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==} engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + rfdc@1.4.1: + resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==} + rimraf@2.6.3: resolution: {integrity: sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==} deprecated: Rimraf versions prior to v4 are no longer supported @@ -10164,8 +10415,8 @@ packages: resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==} engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} - sharp@0.35.4: - resolution: {integrity: sha512-n++8XWcj+jCOr2IOl7h8LbKnGBDY4aPbmprMONBNFdn0ImXqpGVv5zliDs0V9HbmbCQLpbuo2ej9rAoOQTvMDA==} + sharp@0.35.3: + resolution: {integrity: sha512-ej0zVHuZGHCiABXcNxeYhpRnPNPAcvbG8RMdBAhDAxLKkCRVSpK3Iyu7qbqw3JMzoj0REeM6f3tJLtVwl0023Q==} engines: {node: '>=20.9.0'} peerDependencies: '@types/node': '*' @@ -10250,6 +10501,10 @@ packages: sisteransi@1.0.5: resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} + slice-ansi@7.1.2: + resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==} + engines: {node: '>=18'} + slice-ansi@8.0.0: resolution: {integrity: sha512-stxByr12oeeOyY2BlviTNQlYV5xOj47GirPr4yA1hE9JCtxfQN0+tVbkxwCtYDQWhEKWFHsEK48ORg5jrouCAg==} engines: {node: '>=20'} @@ -10258,10 +10513,6 @@ packages: resolution: {integrity: sha512-vZ7rfeehZui7wQs438JXBckYLkIIdfHOXsaVEUMyS5fHo1483l1bMdo0EDSWYclY0yZKFOipDy4KHuKs6ssvdg==} engines: {node: '>=8.0.0'} - smart-buffer@4.2.0: - resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==} - engines: {node: '>= 6.0.0', npm: '>= 3.0.0'} - smol-toml@1.7.0: resolution: {integrity: sha512-aqVvWoyO21L23mb+drl4RmMXbf6N7FdHjAhTRA9ZBL7apWBgfWC16KjrASI+1p9GAroljyMHj6fK67i0UiTNvQ==} engines: {node: '>= 18'} @@ -10270,10 +10521,6 @@ packages: resolution: {integrity: sha512-kCZr2V3ch9i00x8zXRhjUNVcjG9ijES5dDudkXvUVCT5QlJNQWElSJdZqyPemffHoLNUYwOcou0Fy+ojN0uHSQ==} engines: {node: '>= 18'} - socks@2.8.9: - resolution: {integrity: sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==} - engines: {node: '>= 10.0.0', npm: '>= 3.0.0'} - source-map-js@1.2.1: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} @@ -10375,6 +10622,10 @@ packages: resolution: {integrity: sha512-QwiXZgpRcKkhTj2Scnn++4PKtWsH0kpzZ62L2R6c/LUVYv7hVnZqcg2+sMuT6R7Jusu1vviK/MFsu6kNJfWlEQ==} engines: {node: '>=4'} + string-argv@0.3.2: + resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==} + engines: {node: '>=0.6.19'} + string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -10595,6 +10846,11 @@ packages: tslib@2.8.1: resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + tsx@4.23.12: + resolution: {integrity: sha512-FDf4L4sYzKtzWYhU/Xm0AQFdTjdIxNo9ElTf2mxXM6k8YMHXzYUe4yODVaXP4V9uMFbVg8c0qyBccK2OOxb45Q==} + engines: {node: '>=18.0.0'} + hasBin: true + type-fest@0.13.1: resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} engines: {node: '>=10'} @@ -11367,7 +11623,7 @@ snapshots: ansi-styles: 6.2.3 is-fullwidth-code-point: 5.1.0 - '@alchemy.run/cloudflare-runtime@2.0.0-beta.76(@distilled.cloud/cloudflare@1.0.0-rc.8(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)))(@effect/platform-bun@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(utf-8-validate@6.0.6))(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(@types/node@24.12.4)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(rolldown@1.2.5)(typescript@7.0.2)': + '@alchemy.run/cloudflare-runtime@2.0.0-beta.76(@distilled.cloud/cloudflare@1.0.0-rc.8(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)))(@effect/platform-bun@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(utf-8-validate@6.0.6))(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(@types/node@24.12.4)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(rolldown@1.2.5)(typescript@7.0.2)': dependencies: '@alchemy.run/node-utils': 2.0.0-beta.76 '@cloudflare/unenv-preset': 2.16.1(unenv@2.0.0-rc.24)(workerd@1.20260704.1) @@ -11376,7 +11632,7 @@ snapshots: capnp-es: 0.0.14(typescript@7.0.2) effect: 4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2) magic-string: 0.30.21 - sharp: 0.35.4(@types/node@24.12.4) + sharp: 0.35.3(@types/node@24.12.4) unenv: 2.0.0-rc.24 workerd: 1.20260704.1 yauzl: 3.4.0 @@ -11384,7 +11640,7 @@ snapshots: '@effect/platform-bun': 4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(utf-8-validate@6.0.6) '@effect/platform-node': 4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6) rolldown: 1.2.5 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' transitivePeerDependencies: - '@types/node' - proxy-agent @@ -11771,6 +12027,13 @@ snapshots: '@aws/lambda-invoke-store@0.2.4': {} + '@azure/msal-common@16.13.0': {} + + '@azure/msal-node@5.6.0': + dependencies: + '@azure/msal-common': 16.13.0 + jsonwebtoken: 9.0.3 + '@babel/code-frame@7.29.7': dependencies: '@babel/helper-validator-identifier': 7.29.7 @@ -12648,11 +12911,11 @@ snapshots: react: 19.2.6 scheduler: 0.27.0 - '@effect/openapi-generator@4.0.0-rc.112(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(encoding@0.1.13)': + '@effect/openapi-generator@4.0.0-rc.112(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))': dependencies: '@effect/platform-node': 4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6) effect: 4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2) - swagger2openapi: 7.0.8(encoding@0.1.13) + swagger2openapi: 7.0.8 transitivePeerDependencies: - encoding @@ -12916,11 +13179,6 @@ snapshots: tslib: 2.8.1 optional: true - '@emnapi/runtime@1.11.3': - dependencies: - tslib: 2.8.1 - optional: true - '@emnapi/wasi-threads@1.2.1': dependencies: tslib: 2.8.1 @@ -13709,9 +13967,9 @@ snapshots: '@img/sharp-libvips-darwin-arm64': 1.2.4 optional: true - '@img/sharp-darwin-arm64@0.35.4': + '@img/sharp-darwin-arm64@0.35.3': optionalDependencies: - '@img/sharp-libvips-darwin-arm64': 1.3.3 + '@img/sharp-libvips-darwin-arm64': 1.3.2 optional: true '@img/sharp-darwin-x64@0.34.5': @@ -13719,74 +13977,74 @@ snapshots: '@img/sharp-libvips-darwin-x64': 1.2.4 optional: true - '@img/sharp-darwin-x64@0.35.4': + '@img/sharp-darwin-x64@0.35.3': optionalDependencies: - '@img/sharp-libvips-darwin-x64': 1.3.3 + '@img/sharp-libvips-darwin-x64': 1.3.2 optional: true - '@img/sharp-freebsd-wasm32@0.35.4': + '@img/sharp-freebsd-wasm32@0.35.3': dependencies: - '@img/sharp-wasm32': 0.35.4 + '@img/sharp-wasm32': 0.35.3 optional: true '@img/sharp-libvips-darwin-arm64@1.2.4': optional: true - '@img/sharp-libvips-darwin-arm64@1.3.3': + '@img/sharp-libvips-darwin-arm64@1.3.2': optional: true '@img/sharp-libvips-darwin-x64@1.2.4': optional: true - '@img/sharp-libvips-darwin-x64@1.3.3': + '@img/sharp-libvips-darwin-x64@1.3.2': optional: true '@img/sharp-libvips-linux-arm64@1.2.4': optional: true - '@img/sharp-libvips-linux-arm64@1.3.3': + '@img/sharp-libvips-linux-arm64@1.3.2': optional: true '@img/sharp-libvips-linux-arm@1.2.4': optional: true - '@img/sharp-libvips-linux-arm@1.3.3': + '@img/sharp-libvips-linux-arm@1.3.2': optional: true '@img/sharp-libvips-linux-ppc64@1.2.4': optional: true - '@img/sharp-libvips-linux-ppc64@1.3.3': + '@img/sharp-libvips-linux-ppc64@1.3.2': optional: true '@img/sharp-libvips-linux-riscv64@1.2.4': optional: true - '@img/sharp-libvips-linux-riscv64@1.3.3': + '@img/sharp-libvips-linux-riscv64@1.3.2': optional: true '@img/sharp-libvips-linux-s390x@1.2.4': optional: true - '@img/sharp-libvips-linux-s390x@1.3.3': + '@img/sharp-libvips-linux-s390x@1.3.2': optional: true '@img/sharp-libvips-linux-x64@1.2.4': optional: true - '@img/sharp-libvips-linux-x64@1.3.3': + '@img/sharp-libvips-linux-x64@1.3.2': optional: true '@img/sharp-libvips-linuxmusl-arm64@1.2.4': optional: true - '@img/sharp-libvips-linuxmusl-arm64@1.3.3': + '@img/sharp-libvips-linuxmusl-arm64@1.3.2': optional: true '@img/sharp-libvips-linuxmusl-x64@1.2.4': optional: true - '@img/sharp-libvips-linuxmusl-x64@1.3.3': + '@img/sharp-libvips-linuxmusl-x64@1.3.2': optional: true '@img/sharp-linux-arm64@0.34.5': @@ -13794,9 +14052,9 @@ snapshots: '@img/sharp-libvips-linux-arm64': 1.2.4 optional: true - '@img/sharp-linux-arm64@0.35.4': + '@img/sharp-linux-arm64@0.35.3': optionalDependencies: - '@img/sharp-libvips-linux-arm64': 1.3.3 + '@img/sharp-libvips-linux-arm64': 1.3.2 optional: true '@img/sharp-linux-arm@0.34.5': @@ -13804,9 +14062,9 @@ snapshots: '@img/sharp-libvips-linux-arm': 1.2.4 optional: true - '@img/sharp-linux-arm@0.35.4': + '@img/sharp-linux-arm@0.35.3': optionalDependencies: - '@img/sharp-libvips-linux-arm': 1.3.3 + '@img/sharp-libvips-linux-arm': 1.3.2 optional: true '@img/sharp-linux-ppc64@0.34.5': @@ -13814,9 +14072,9 @@ snapshots: '@img/sharp-libvips-linux-ppc64': 1.2.4 optional: true - '@img/sharp-linux-ppc64@0.35.4': + '@img/sharp-linux-ppc64@0.35.3': optionalDependencies: - '@img/sharp-libvips-linux-ppc64': 1.3.3 + '@img/sharp-libvips-linux-ppc64': 1.3.2 optional: true '@img/sharp-linux-riscv64@0.34.5': @@ -13824,9 +14082,9 @@ snapshots: '@img/sharp-libvips-linux-riscv64': 1.2.4 optional: true - '@img/sharp-linux-riscv64@0.35.4': + '@img/sharp-linux-riscv64@0.35.3': optionalDependencies: - '@img/sharp-libvips-linux-riscv64': 1.3.3 + '@img/sharp-libvips-linux-riscv64': 1.3.2 optional: true '@img/sharp-linux-s390x@0.34.5': @@ -13834,9 +14092,9 @@ snapshots: '@img/sharp-libvips-linux-s390x': 1.2.4 optional: true - '@img/sharp-linux-s390x@0.35.4': + '@img/sharp-linux-s390x@0.35.3': optionalDependencies: - '@img/sharp-libvips-linux-s390x': 1.3.3 + '@img/sharp-libvips-linux-s390x': 1.3.2 optional: true '@img/sharp-linux-x64@0.34.5': @@ -13844,9 +14102,9 @@ snapshots: '@img/sharp-libvips-linux-x64': 1.2.4 optional: true - '@img/sharp-linux-x64@0.35.4': + '@img/sharp-linux-x64@0.35.3': optionalDependencies: - '@img/sharp-libvips-linux-x64': 1.3.3 + '@img/sharp-libvips-linux-x64': 1.3.2 optional: true '@img/sharp-linuxmusl-arm64@0.34.5': @@ -13854,9 +14112,9 @@ snapshots: '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 optional: true - '@img/sharp-linuxmusl-arm64@0.35.4': + '@img/sharp-linuxmusl-arm64@0.35.3': optionalDependencies: - '@img/sharp-libvips-linuxmusl-arm64': 1.3.3 + '@img/sharp-libvips-linuxmusl-arm64': 1.3.2 optional: true '@img/sharp-linuxmusl-x64@0.34.5': @@ -13864,9 +14122,9 @@ snapshots: '@img/sharp-libvips-linuxmusl-x64': 1.2.4 optional: true - '@img/sharp-linuxmusl-x64@0.35.4': + '@img/sharp-linuxmusl-x64@0.35.3': optionalDependencies: - '@img/sharp-libvips-linuxmusl-x64': 1.3.3 + '@img/sharp-libvips-linuxmusl-x64': 1.3.2 optional: true '@img/sharp-wasm32@0.34.5': @@ -13874,32 +14132,32 @@ snapshots: '@emnapi/runtime': 1.11.1 optional: true - '@img/sharp-wasm32@0.35.4': + '@img/sharp-wasm32@0.35.3': dependencies: - '@emnapi/runtime': 1.11.3 + '@emnapi/runtime': 1.11.2 optional: true - '@img/sharp-webcontainers-wasm32@0.35.4': + '@img/sharp-webcontainers-wasm32@0.35.3': dependencies: - '@img/sharp-wasm32': 0.35.4 + '@img/sharp-wasm32': 0.35.3 optional: true '@img/sharp-win32-arm64@0.34.5': optional: true - '@img/sharp-win32-arm64@0.35.4': + '@img/sharp-win32-arm64@0.35.3': optional: true '@img/sharp-win32-ia32@0.34.5': optional: true - '@img/sharp-win32-ia32@0.35.4': + '@img/sharp-win32-ia32@0.35.3': optional: true '@img/sharp-win32-x64@0.34.5': optional: true - '@img/sharp-win32-x64@0.35.4': + '@img/sharp-win32-x64@0.35.3': optional: true '@inquirer/ansi@1.0.2': @@ -14232,6 +14490,49 @@ snapshots: '@material/material-color-utilities@0.3.0': {} + '@microsoft/teams.api@2.0.14': + dependencies: + '@microsoft/teams.cards': 2.0.14 + '@microsoft/teams.common': 2.0.14 + jwt-decode: 4.0.0 + qs: 6.15.3 + transitivePeerDependencies: + - debug + - supports-color + + '@microsoft/teams.apps@2.0.14': + dependencies: + '@azure/msal-node': 5.6.0 + '@microsoft/teams.api': 2.0.14 + '@microsoft/teams.common': 2.0.14 + '@microsoft/teams.graph': 2.0.14 + axios: 1.20.0 + cors: 2.8.6 + express: 5.2.1 + jsonwebtoken: 9.0.3 + jwks-rsa: 3.2.2 + reflect-metadata: 0.2.2 + transitivePeerDependencies: + - debug + - supports-color + + '@microsoft/teams.cards@2.0.14': {} + + '@microsoft/teams.common@2.0.14': + dependencies: + axios: 1.20.0 + transitivePeerDependencies: + - debug + - supports-color + + '@microsoft/teams.graph@2.0.14': + dependencies: + '@microsoft/teams.common': 2.0.14 + qs: 6.15.3 + transitivePeerDependencies: + - debug + - supports-color + '@modelcontextprotocol/sdk@1.29.0(zod@4.4.3)': dependencies: '@hono/node-server': 1.19.14(hono@4.12.27) @@ -14477,7 +14778,7 @@ snapshots: '@open-draft/until@2.1.0': optional: true - '@opencode-ai/sdk@1.15.13': + '@opencode-ai/sdk@1.18.25': dependencies: cross-spawn: 7.0.6 @@ -14834,7 +15135,7 @@ snapshots: '@prisma/debug@7.2.0': {} - '@prisma/dev@0.20.0(typescript@6.0.3)': + '@prisma/dev@0.20.0(typescript@7.0.2)': dependencies: '@electric-sql/pglite': 0.3.15 '@electric-sql/pglite-socket': 0.0.20(@electric-sql/pglite@0.3.15) @@ -14851,7 +15152,7 @@ snapshots: proper-lockfile: 4.1.2 remeda: 2.33.4 std-env: 3.10.0 - valibot: 1.2.0(typescript@6.0.3) + valibot: 1.2.0(typescript@7.0.2) zeptomatch: 2.1.0 transitivePeerDependencies: - typescript @@ -15357,7 +15658,7 @@ snapshots: '@rolldown/binding-win32-x64-msvc@1.2.5': optional: true - '@rolldown/plugin-babel@0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5)': + '@rolldown/plugin-babel@0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5)': dependencies: '@babel/core': 7.29.7 picomatch: 4.0.4 @@ -15365,7 +15666,7 @@ snapshots: optionalDependencies: '@babel/plugin-transform-runtime': 7.29.7(@babel/core@7.29.7) '@babel/runtime': 7.29.7 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' '@rolldown/pluginutils@1.0.0-rc.17': optional: true @@ -15677,12 +15978,12 @@ snapshots: '@tailwindcss/oxide-win32-arm64-msvc': 4.3.3 '@tailwindcss/oxide-win32-x64-msvc': 4.3.3 - '@tailwindcss/vite@4.3.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))': + '@tailwindcss/vite@4.3.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))': dependencies: '@tailwindcss/node': 4.3.3 '@tailwindcss/oxide': 4.3.3 tailwindcss: 4.3.3 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' '@tanstack/devtools-event-client@0.4.3': {} @@ -15745,7 +16046,7 @@ snapshots: transitivePeerDependencies: - supports-color - '@tanstack/router-plugin@1.168.13(@tanstack/react-router@1.170.10(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))': + '@tanstack/router-plugin@1.168.13(@tanstack/react-router@1.170.10(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))': dependencies: '@babel/core': 7.29.7 '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7) @@ -15762,7 +16063,7 @@ snapshots: zod: 4.4.3 optionalDependencies: '@tanstack/react-router': 1.170.10(react-dom@19.2.6(react@19.2.6))(react@19.2.6) - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' transitivePeerDependencies: - supports-color @@ -15877,6 +16178,14 @@ snapshots: '@types/estree@1.0.9': {} + '@types/express-serve-static-core@4.19.9': + dependencies: + '@types/node': 24.12.4 + '@types/qs': 6.15.1 + '@types/range-parser': 1.2.7 + '@types/send': 1.2.1 + optional: true + '@types/express-serve-static-core@5.1.3': dependencies: '@types/node': 24.12.4 @@ -15884,6 +16193,14 @@ snapshots: '@types/range-parser': 1.2.7 '@types/send': 1.2.1 + '@types/express@4.17.25': + dependencies: + '@types/body-parser': 1.19.6 + '@types/express-serve-static-core': 4.19.9 + '@types/qs': 6.15.1 + '@types/serve-static': 1.15.10 + optional: true + '@types/express@5.0.6': dependencies: '@types/body-parser': 1.19.6 @@ -15916,6 +16233,11 @@ snapshots: '@types/json-schema@7.0.15': {} + '@types/jsonwebtoken@9.0.10': + dependencies: + '@types/ms': 2.1.0 + '@types/node': 24.12.4 + '@types/keyv@3.1.4': dependencies: '@types/node': 24.12.4 @@ -15924,6 +16246,9 @@ snapshots: dependencies: '@types/unist': 3.0.3 + '@types/mime@1.3.5': + optional: true + '@types/ms@2.1.0': {} '@types/nlcst@2.0.3': @@ -15958,10 +16283,23 @@ snapshots: dependencies: '@types/node': 24.12.4 + '@types/send@0.17.6': + dependencies: + '@types/mime': 1.3.5 + '@types/node': 24.12.4 + optional: true + '@types/send@1.2.1': dependencies: '@types/node': 24.12.4 + '@types/serve-static@1.15.10': + dependencies: + '@types/http-errors': 2.0.5 + '@types/node': 24.12.4 + '@types/send': 0.17.6 + optional: true + '@types/serve-static@2.2.0': dependencies: '@types/http-errors': 2.0.5 @@ -15970,10 +16308,15 @@ snapshots: '@types/statuses@2.0.6': optional: true + '@types/trusted-types@2.0.7': + optional: true + '@types/unist@2.0.11': {} '@types/unist@3.0.3': {} + '@types/vscode@1.95.0': {} + '@types/webidl-conversions@7.0.3': optional: true @@ -16071,36 +16414,36 @@ snapshots: optionalDependencies: ajv: 6.15.0 - '@vitejs/plugin-react@6.0.2(@rolldown/plugin-babel@0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(babel-plugin-react-compiler@1.0.0)': + '@vitejs/plugin-react@6.0.2(@rolldown/plugin-babel@0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5))(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(babel-plugin-react-compiler@1.0.0)': dependencies: '@rolldown/pluginutils': 1.0.1 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' optionalDependencies: - '@rolldown/plugin-babel': 0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5) + '@rolldown/plugin-babel': 0.2.3(@babel/core@7.29.7)(@babel/plugin-transform-runtime@7.29.7(@babel/core@7.29.7))(@babel/runtime@7.29.7)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(rolldown@1.2.5) babel-plugin-react-compiler: 1.0.0 - '@vitest/browser-preview@4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11)': + '@vitest/browser-preview@4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11)': dependencies: '@testing-library/dom': 10.4.1 '@testing-library/user-event': 14.6.1(@testing-library/dom@10.4.1) - '@vitest/browser': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) - vitest: 4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) + '@vitest/browser': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) + vitest: 4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) transitivePeerDependencies: - bufferutil - msw - utf-8-validate - vite - '@vitest/browser@4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11)': + '@vitest/browser@4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11)': dependencies: '@blazediff/core': 1.9.1 - '@vitest/mocker': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) + '@vitest/mocker': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) '@vitest/utils': 4.1.11 magic-string: 0.30.21 pngjs: 7.0.0 sirv: 3.0.2 tinyrainbow: 3.1.0 - vitest: 4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) + vitest: 4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) ws: 8.21.0(bufferutil@4.1.0)(utf-8-validate@6.0.6) transitivePeerDependencies: - bufferutil @@ -16117,14 +16460,14 @@ snapshots: chai: 6.2.2 tinyrainbow: 3.1.0 - '@vitest/mocker@4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))': + '@vitest/mocker@4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))': dependencies: '@vitest/spy': 4.1.11 estree-walker: 3.0.3 magic-string: 0.30.21 optionalDependencies: msw: 2.12.11(@types/node@24.12.4)(typescript@7.0.2) - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' '@vitest/pretty-format@4.1.11': dependencies: @@ -16150,7 +16493,7 @@ snapshots: convert-source-map: 2.0.0 tinyrainbow: 3.1.0 - '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)': + '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)': dependencies: '@oxc-project/runtime': 0.146.0 '@oxc-project/types': 0.146.0 @@ -16172,11 +16515,12 @@ snapshots: fsevents: 2.3.3 jiti: 2.7.0 terser: 5.48.0 + tsx: 4.23.12 typescript: 6.0.3 unrun: 0.2.39 yaml: 2.9.0 - '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)': + '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)': dependencies: '@oxc-project/runtime': 0.146.0 '@oxc-project/types': 0.146.0 @@ -16198,6 +16542,7 @@ snapshots: fsevents: 2.3.3 jiti: 2.7.0 terser: 5.48.0 + tsx: 4.23.12 typescript: 7.0.2 unrun: 0.2.39 yaml: 2.9.0 @@ -16405,6 +16750,12 @@ snapshots: acorn@8.16.0: {} + agent-base@6.0.2: + dependencies: + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + agent-base@7.1.4: {} agent-cli-detector@0.1.6: {} @@ -16450,9 +16801,9 @@ snapshots: json-schema-traverse: 1.0.0 require-from-string: 2.0.2 - alchemy@2.0.0-beta.76(b3825b36417e56a486ccb5f22a7f3d7e): + alchemy@2.0.0-beta.76(2a29e483e9ca6fbc5e022c796b06f03f): dependencies: - '@alchemy.run/cloudflare-runtime': 2.0.0-beta.76(@distilled.cloud/cloudflare@1.0.0-rc.8(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)))(@effect/platform-bun@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(utf-8-validate@6.0.6))(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(@types/node@24.12.4)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(rolldown@1.2.5)(typescript@7.0.2) + '@alchemy.run/cloudflare-runtime': 2.0.0-beta.76(@distilled.cloud/cloudflare@1.0.0-rc.8(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)))(@effect/platform-bun@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(utf-8-validate@6.0.6))(@effect/platform-node@4.0.0-rc.112(bufferutil@4.1.0)(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(redis@6.2.1)(utf-8-validate@6.0.6))(@types/node@24.12.4)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2))(rolldown@1.2.5)(typescript@7.0.2) '@alchemy.run/floci': 2.0.0-beta.76(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) '@alchemy.run/node-utils': 2.0.0-beta.76 '@aws-sdk/credential-providers': 3.1062.0 @@ -16472,7 +16823,7 @@ snapshots: '@libsql/client': 0.17.3(bufferutil@4.1.0)(utf-8-validate@6.0.6) '@octokit/rest': 22.0.1 '@octokit/webhooks': 14.2.0 - '@prisma/dev': 0.20.0(typescript@6.0.3) + '@prisma/dev': 0.20.0(typescript@7.0.2) '@smithy/node-config-provider': 4.4.6 '@smithy/shared-ini-file-loader': 4.5.6 '@smithy/types': 4.14.3 @@ -16497,9 +16848,9 @@ snapshots: '@effect/sql-pg': 4.0.0-rc.112(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)) drizzle-kit: 1.0.0-rc.5-ab785fc drizzle-orm: 1.0.0-rc.5-ab785fc(8ab70e2706da13c78d64d8a92fef1884) - mongodb: 6.21.0(@aws-sdk/credential-providers@3.1062.0)(socks@2.8.9) + mongodb: 6.21.0(@aws-sdk/credential-providers@3.1062.0) pg: 8.23.0 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' ws: 8.21.3(bufferutil@4.1.0)(utf-8-validate@6.0.6) transitivePeerDependencies: - '@types/node' @@ -16628,7 +16979,7 @@ snapshots: assertion-error@2.0.1: {} - astro@7.0.3(@astrojs/markdown-remark@7.2.0)(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1)(@types/node@24.12.4)(aws4fetch@1.0.20)(idb-keyval@6.2.1)(ioredis@5.11.0)(jiti@2.7.0)(rollup@4.61.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0): + astro@7.0.3(@astrojs/markdown-remark@7.2.0)(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1)(@types/node@24.12.4)(aws4fetch@1.0.20)(idb-keyval@6.2.1)(ioredis@5.11.0)(jiti@2.7.0)(rollup@4.61.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0): dependencies: '@astrojs/compiler-rs': 0.2.3(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1) '@astrojs/internal-helpers': 0.10.0 @@ -16681,8 +17032,8 @@ snapshots: unist-util-visit: 5.1.0 unstorage: 1.17.5(aws4fetch@1.0.20)(idb-keyval@6.2.1)(ioredis@5.11.0) vfile: 6.0.3 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)' - vitefu: 1.1.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)) + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)' + vitefu: 1.1.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)) xxhash-wasm: 1.1.0 yargs-parser: 22.0.0 zod: 4.4.3 @@ -16747,6 +17098,16 @@ snapshots: aws4fetch@1.0.20: {} + axios@1.20.0: + dependencies: + follow-redirects: 1.16.0 + form-data: 4.0.6 + https-proxy-agent: 5.0.1 + proxy-from-env: 2.1.0 + transitivePeerDependencies: + - debug + - supports-color + axobject-query@4.1.0: {} babel-dead-code-elimination@1.0.12: @@ -16954,6 +17315,8 @@ snapshots: bson@6.10.4: optional: true + buffer-equal-constant-time@1.0.1: {} + buffer-from@1.1.2: {} bufferutil@4.1.0: @@ -17190,6 +17553,8 @@ snapshots: color-convert: 2.0.1 color-string: 1.9.1 + colorette@2.0.20: {} + combined-stream@1.0.8: dependencies: delayed-stream: 1.0.0 @@ -17429,6 +17794,13 @@ snapshots: dependencies: dequal: 2.0.3 + dfx@1.0.15(effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2)): + dependencies: + discord-api-types: 0.38.53 + effect: 4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2) + optionalDependencies: + discord-verify: 1.2.0 + diff@8.0.3: {} diff@9.0.0: {} @@ -17438,6 +17810,13 @@ snapshots: minimatch: 3.1.5 p-limit: 3.1.0 + discord-api-types@0.38.53: {} + + discord-verify@1.2.0: + dependencies: + '@types/express': 4.17.25 + optional: true + dmg-builder@26.15.6(electron-builder-squirrel-windows@26.15.6): dependencies: app-builder-lib: 26.15.6(dmg-builder@26.15.6)(electron-builder-squirrel-windows@26.15.6) @@ -17464,6 +17843,10 @@ snapshots: dependencies: domelementtype: 2.3.0 + dompurify@3.4.14: + optionalDependencies: + '@types/trusted-types': 2.0.7 + domutils@3.2.2: dependencies: dom-serializer: 2.0.0 @@ -17518,6 +17901,10 @@ snapshots: duplexer@0.1.2: {} + ecdsa-sig-formatter@1.0.11: + dependencies: + safe-buffer: 5.2.1 + ee-first@1.1.1: {} effect@4.0.0-rc.112(patch_hash=8bef799f35729cf3465eb428196f617b434a7c9f658d56acb2874d74b21b98b2): @@ -17561,7 +17948,7 @@ snapshots: builder-util: 26.15.3 builder-util-runtime: 9.7.0 chalk: 4.1.2 - form-data: 4.0.5 + form-data: 4.0.6 fs-extra: 10.1.0 lazy-val: 1.0.5 mime: 2.6.0 @@ -17621,11 +18008,6 @@ snapshots: encodeurl@2.0.0: {} - encoding@0.1.13: - dependencies: - iconv-lite: 0.6.3 - optional: true - end-of-stream@1.4.5: dependencies: once: 1.4.0 @@ -18438,6 +18820,8 @@ snapshots: flow-enums-runtime@0.0.6: {} + follow-redirects@1.16.0: {} + fontace@0.4.1: dependencies: fontkitten: 1.0.3 @@ -18453,7 +18837,7 @@ snapshots: cross-spawn: 7.0.6 signal-exit: 4.1.0 - form-data@4.0.5: + form-data@4.0.6: dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 @@ -18845,17 +19229,19 @@ snapshots: quick-lru: 5.1.1 resolve-alpn: 1.2.1 - https-proxy-agent@7.0.6: + https-proxy-agent@5.0.1: dependencies: - agent-base: 7.1.4 + agent-base: 6.0.2 debug: 4.4.3 transitivePeerDependencies: - supports-color - iconv-lite@0.6.3: + https-proxy-agent@7.0.6: dependencies: - safer-buffer: 2.1.2 - optional: true + agent-base: 7.1.4 + debug: 4.4.3 + transitivePeerDependencies: + - supports-color iconv-lite@0.7.2: dependencies: @@ -19060,6 +19446,8 @@ snapshots: jiti@2.7.0: {} + jose@4.15.9: {} + jose@6.2.2: {} jose@6.2.3: {} @@ -19121,6 +19509,19 @@ snapshots: optionalDependencies: graceful-fs: 4.2.11 + jsonwebtoken@9.0.3: + dependencies: + jws: 4.0.1 + lodash.includes: 4.3.0 + lodash.isboolean: 3.0.3 + lodash.isinteger: 4.0.4 + lodash.isnumber: 3.0.3 + lodash.isplainobject: 4.0.6 + lodash.isstring: 4.0.1 + lodash.once: 4.1.1 + ms: 2.1.3 + semver: 7.8.5 + jszip@3.10.1: dependencies: lie: 3.3.0 @@ -19128,6 +19529,29 @@ snapshots: readable-stream: 2.3.8 setimmediate: 1.0.5 + jwa@2.0.1: + dependencies: + buffer-equal-constant-time: 1.0.1 + ecdsa-sig-formatter: 1.0.11 + safe-buffer: 5.2.1 + + jwks-rsa@3.2.2: + dependencies: + '@types/jsonwebtoken': 9.0.10 + debug: 4.4.3 + jose: 4.15.9 + limiter: 1.1.5 + lru-memoizer: 2.3.0 + transitivePeerDependencies: + - supports-color + + jws@4.0.1: + dependencies: + jwa: 2.0.1 + safe-buffer: 5.2.1 + + jwt-decode@4.0.0: {} + keyv@4.5.4: dependencies: json-buffer: 3.0.1 @@ -19247,17 +19671,53 @@ snapshots: lilconfig@2.1.0: {} + limiter@1.1.5: {} + + lint-staged@16.4.0: + dependencies: + commander: 14.0.3 + listr2: 9.0.5 + picomatch: 4.0.4 + string-argv: 0.3.2 + tinyexec: 1.2.4 + yaml: 2.9.0 + + listr2@9.0.5: + dependencies: + cli-truncate: 5.2.0 + colorette: 2.0.20 + eventemitter3: 5.0.4 + log-update: 6.1.0 + rfdc: 1.4.1 + wrap-ansi: 9.0.2 + locate-path@3.0.0: dependencies: p-locate: 3.0.0 path-exists: 3.0.0 + lodash.clonedeep@4.5.0: {} + lodash.debounce@4.0.8: {} lodash.escaperegexp@4.1.2: {} + lodash.includes@4.3.0: {} + + lodash.isboolean@3.0.3: {} + lodash.isequal@4.5.0: {} + lodash.isinteger@4.0.4: {} + + lodash.isnumber@3.0.3: {} + + lodash.isplainobject@4.0.6: {} + + lodash.isstring@4.0.1: {} + + lodash.once@4.1.1: {} + lodash.throttle@4.1.1: {} lodash@4.17.21: {} @@ -19273,6 +19733,14 @@ snapshots: is-unicode-supported: 2.1.0 yoctocolors: 2.1.2 + log-update@6.1.0: + dependencies: + ansi-escapes: 7.3.0 + cli-cursor: 5.0.0 + slice-ansi: 7.1.2 + strip-ansi: 7.2.0 + wrap-ansi: 9.0.2 + long@4.0.0: {} longest-streak@3.1.0: {} @@ -19295,6 +19763,11 @@ snapshots: dependencies: yallist: 4.0.0 + lru-memoizer@2.3.0: + dependencies: + lodash.clonedeep: 4.5.0 + lru-cache: 6.0.0 + lru_map@0.4.1: {} lucide-react@0.564.0(react@19.2.6): @@ -19321,6 +19794,8 @@ snapshots: markdown-table@3.0.4: {} + marked@15.0.12: {} + marky@1.3.0: {} matcher@3.0.0: @@ -20149,14 +20624,13 @@ snapshots: whatwg-url: 14.2.0 optional: true - mongodb@6.21.0(@aws-sdk/credential-providers@3.1062.0)(socks@2.8.9): + mongodb@6.21.0(@aws-sdk/credential-providers@3.1062.0): dependencies: '@mongodb-js/saslprep': 1.4.13 bson: 6.10.4 mongodb-connection-string-url: 3.0.2 optionalDependencies: '@aws-sdk/credential-providers': 3.1062.0 - socks: 2.8.9 optional: true mrmime@2.0.1: {} @@ -20243,11 +20717,9 @@ snapshots: node-fetch-native@1.6.7: {} - node-fetch@2.7.0(encoding@0.1.13): + node-fetch@2.7.0: dependencies: whatwg-url: 5.0.0 - optionalDependencies: - encoding: 0.1.13 node-forge@1.4.0: {} @@ -20472,7 +20944,7 @@ snapshots: '@oxc-resolver/binding-win32-arm64-msvc': 11.24.2 '@oxc-resolver/binding-win32-x64-msvc': 11.24.2 - oxfmt@0.64.0(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)): + oxfmt@0.64.0(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)): dependencies: tinypool: 2.1.0 optionalDependencies: @@ -20495,7 +20967,7 @@ snapshots: '@oxfmt/binding-win32-arm64-msvc': 0.64.0 '@oxfmt/binding-win32-ia32-msvc': 0.64.0 '@oxfmt/binding-win32-x64-msvc': 0.64.0 - vite-plus: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + vite-plus: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) oxlint-tsgolint@7.0.2001: optionalDependencies: @@ -20506,7 +20978,7 @@ snapshots: '@oxlint-tsgolint/win32-arm64': 7.0.2001 '@oxlint-tsgolint/win32-x64': 7.0.2001 - oxlint@1.79.0(oxlint-tsgolint@7.0.2001)(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)): + oxlint@1.79.0(oxlint-tsgolint@7.0.2001)(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)): optionalDependencies: '@oxlint/binding-android-arm-eabi': 1.79.0 '@oxlint/binding-android-arm64': 1.79.0 @@ -20528,7 +21000,7 @@ snapshots: '@oxlint/binding-win32-ia32-msvc': 1.79.0 '@oxlint/binding-win32-x64-msvc': 1.79.0 oxlint-tsgolint: 7.0.2001 - vite-plus: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + vite-plus: 0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) p-cancelable@2.1.1: {} @@ -20820,6 +21292,8 @@ snapshots: forwarded: 0.2.0 ipaddr.js: 1.9.1 + proxy-from-env@2.1.0: {} + pump@3.0.4: dependencies: end-of-stream: 1.4.5 @@ -21236,6 +21710,8 @@ snapshots: - '@node-rs/xxhash' - '@opentelemetry/api' + reflect-metadata@0.2.2: {} + reftools@1.1.9: {} regenerate-unicode-properties@10.2.2: @@ -21436,6 +21912,8 @@ snapshots: reusify@1.1.0: {} + rfdc@1.4.1: {} + rimraf@2.6.3: dependencies: glob: 7.2.3 @@ -21692,37 +22170,37 @@ snapshots: '@img/sharp-win32-ia32': 0.34.5 '@img/sharp-win32-x64': 0.34.5 - sharp@0.35.4(@types/node@24.12.4): + sharp@0.35.3(@types/node@24.12.4): dependencies: '@img/colour': 1.1.0 detect-libc: 2.1.2 semver: 7.8.5 optionalDependencies: - '@img/sharp-darwin-arm64': 0.35.4 - '@img/sharp-darwin-x64': 0.35.4 - '@img/sharp-freebsd-wasm32': 0.35.4 - '@img/sharp-libvips-darwin-arm64': 1.3.3 - '@img/sharp-libvips-darwin-x64': 1.3.3 - '@img/sharp-libvips-linux-arm': 1.3.3 - '@img/sharp-libvips-linux-arm64': 1.3.3 - '@img/sharp-libvips-linux-ppc64': 1.3.3 - '@img/sharp-libvips-linux-riscv64': 1.3.3 - '@img/sharp-libvips-linux-s390x': 1.3.3 - '@img/sharp-libvips-linux-x64': 1.3.3 - '@img/sharp-libvips-linuxmusl-arm64': 1.3.3 - '@img/sharp-libvips-linuxmusl-x64': 1.3.3 - '@img/sharp-linux-arm': 0.35.4 - '@img/sharp-linux-arm64': 0.35.4 - '@img/sharp-linux-ppc64': 0.35.4 - '@img/sharp-linux-riscv64': 0.35.4 - '@img/sharp-linux-s390x': 0.35.4 - '@img/sharp-linux-x64': 0.35.4 - '@img/sharp-linuxmusl-arm64': 0.35.4 - '@img/sharp-linuxmusl-x64': 0.35.4 - '@img/sharp-webcontainers-wasm32': 0.35.4 - '@img/sharp-win32-arm64': 0.35.4 - '@img/sharp-win32-ia32': 0.35.4 - '@img/sharp-win32-x64': 0.35.4 + '@img/sharp-darwin-arm64': 0.35.3 + '@img/sharp-darwin-x64': 0.35.3 + '@img/sharp-freebsd-wasm32': 0.35.3 + '@img/sharp-libvips-darwin-arm64': 1.3.2 + '@img/sharp-libvips-darwin-x64': 1.3.2 + '@img/sharp-libvips-linux-arm': 1.3.2 + '@img/sharp-libvips-linux-arm64': 1.3.2 + '@img/sharp-libvips-linux-ppc64': 1.3.2 + '@img/sharp-libvips-linux-riscv64': 1.3.2 + '@img/sharp-libvips-linux-s390x': 1.3.2 + '@img/sharp-libvips-linux-x64': 1.3.2 + '@img/sharp-libvips-linuxmusl-arm64': 1.3.2 + '@img/sharp-libvips-linuxmusl-x64': 1.3.2 + '@img/sharp-linux-arm': 0.35.3 + '@img/sharp-linux-arm64': 0.35.3 + '@img/sharp-linux-ppc64': 0.35.3 + '@img/sharp-linux-riscv64': 0.35.3 + '@img/sharp-linux-s390x': 0.35.3 + '@img/sharp-linux-x64': 0.35.3 + '@img/sharp-linuxmusl-arm64': 0.35.3 + '@img/sharp-linuxmusl-x64': 0.35.3 + '@img/sharp-webcontainers-wasm32': 0.35.3 + '@img/sharp-win32-arm64': 0.35.3 + '@img/sharp-win32-ia32': 0.35.3 + '@img/sharp-win32-x64': 0.35.3 '@types/node': 24.12.4 shebang-command@2.0.0: @@ -21826,6 +22304,11 @@ snapshots: sisteransi@1.0.5: {} + slice-ansi@7.1.2: + dependencies: + ansi-styles: 6.2.3 + is-fullwidth-code-point: 5.1.0 + slice-ansi@8.0.0: dependencies: ansi-styles: 6.2.3 @@ -21833,19 +22316,10 @@ snapshots: slugify@1.6.9: {} - smart-buffer@4.2.0: - optional: true - smol-toml@1.7.0: {} smol-toml@1.8.0: {} - socks@2.8.9: - dependencies: - ip-address: 10.2.0 - smart-buffer: 4.2.0 - optional: true - source-map-js@1.2.1: {} source-map-support@0.5.21: @@ -21926,6 +22400,8 @@ snapshots: strict-uri-encode@2.0.0: {} + string-argv@0.3.2: {} + string-width@4.2.3: dependencies: emoji-regex: 8.0.0 @@ -22013,10 +22489,10 @@ snapshots: picocolors: 1.1.1 sax: 1.6.0 - swagger2openapi@7.0.8(encoding@0.1.13): + swagger2openapi@7.0.8: dependencies: call-me-maybe: 1.0.2 - node-fetch: 2.7.0(encoding@0.1.13) + node-fetch: 2.7.0 node-fetch-h2: 2.3.0 node-readfiles: 0.2.0 oas-kit-common: 1.0.8 @@ -22150,6 +22626,12 @@ snapshots: tslib@2.8.1: {} + tsx@4.23.12: + dependencies: + esbuild: 0.28.1 + optionalDependencies: + fsevents: 2.3.3 + type-fest@0.13.1: optional: true @@ -22406,14 +22888,9 @@ snapshots: uuid@7.0.3: {} - valibot@1.2.0(typescript@6.0.3): - optionalDependencies: - typescript: 6.0.3 - valibot@1.2.0(typescript@7.0.2): optionalDependencies: typescript: 7.0.2 - optional: true validate-npm-package-name@5.0.1: {} @@ -22443,25 +22920,25 @@ snapshots: '@types/unist': 3.0.3 vfile-message: 4.0.3 - vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0): + vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0): dependencies: '@oxc-project/types': 0.146.0 '@oxlint/plugins': 1.79.0 - '@vitest/browser': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) - '@vitest/browser-preview': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) + '@vitest/browser': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) + '@vitest/browser-preview': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) '@vitest/expect': 4.1.11 - '@vitest/mocker': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) + '@vitest/mocker': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) '@vitest/pretty-format': 4.1.11 '@vitest/runner': 4.1.11 '@vitest/snapshot': 4.1.11 '@vitest/spy': 4.1.11 '@vitest/utils': 4.1.11 - '@voidzero-dev/vite-plus-core': 0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0) - oxfmt: 0.64.0(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)) - oxlint: 1.79.0(oxlint-tsgolint@7.0.2001)(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)) + '@voidzero-dev/vite-plus-core': 0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0) + oxfmt: 0.64.0(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)) + oxlint: 1.79.0(oxlint-tsgolint@7.0.2001)(vite-plus@0.3.0(@types/node@24.12.4)(bufferutil@4.1.0)(esbuild@0.28.1)(jiti@2.7.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)) oxlint-tsgolint: 7.0.2001 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' - vitest: 4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vitest: 4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) optionalDependencies: '@voidzero-dev/vite-plus-darwin-arm64': 0.3.0 '@voidzero-dev/vite-plus-darwin-x64': 0.3.0 @@ -22501,14 +22978,14 @@ snapshots: - utf-8-validate - yaml - vitefu@1.1.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)): + vitefu@1.1.3(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)): optionalDependencies: - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@6.0.3)(unrun@0.2.39)(yaml@2.9.0)' - vitest@4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)): + vitest@4.1.11(@types/node@24.12.4)(@vitest/browser-preview@4.1.11)(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)): dependencies: '@vitest/expect': 4.1.11 - '@vitest/mocker': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) + '@vitest/mocker': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2)) '@vitest/pretty-format': 4.1.11 '@vitest/runner': 4.1.11 '@vitest/snapshot': 4.1.11 @@ -22525,11 +23002,11 @@ snapshots: tinyexec: 1.2.4 tinyglobby: 0.2.17 tinyrainbow: 3.1.0 - vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' + vite: '@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0)' why-is-node-running: 2.3.0 optionalDependencies: '@types/node': 24.12.4 - '@vitest/browser-preview': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) + '@vitest/browser-preview': 4.1.11(@voidzero-dev/vite-plus-core@0.3.0(@types/node@24.12.4)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.48.0)(tsx@4.23.12)(typescript@7.0.2)(unrun@0.2.39)(yaml@2.9.0))(bufferutil@4.1.0)(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(utf-8-validate@6.0.6)(vitest@4.1.11) transitivePeerDependencies: - msw diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 8a4bf972f82f..43317bb1532b 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -23,6 +23,7 @@ allowBuilds: workerd: false catalog: + dfx: 1.0.15 "@clerk/backend": 3.14.0 "@clerk/clerk-js": 6.30.1 "@clerk/electron": 0.0.37 @@ -194,3 +195,4 @@ supportedArchitectures: cpu: [current, x64] libc: [current, glibc] os: [current, linux] +# (workspace already includes apps/*) diff --git a/scripts/agent-gh.mjs b/scripts/agent-gh.mjs new file mode 100644 index 000000000000..620c280db2e9 --- /dev/null +++ b/scripts/agent-gh.mjs @@ -0,0 +1,62 @@ +#!/usr/bin/env node +/** + * Agent-facing `gh` policy shim. + * + * Installed at `.tools/bin/gh` by `scripts/install-git-hooks.mjs`. + * + * When coding-agent env markers are set and the command would publish a PR + * (`gh pr ready`, the ready_for_review APIs), the ship gate runs first and the + * command then proceeds. Only a failing gate stops it — publishing is gated, not + * forbidden. `pnpm pr:ready` remains the explicit path and is unchanged; it sets + * AGENT_PR_SHIP=1 so the gate runs once, not twice. + * + * Humans / non-agents: transparent pass-through to the next `gh` on PATH. + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodePath from "node:path"; +import * as NodeProcess from "node:process"; +import * as NodeURL from "node:url"; +import { isCodingAgent } from "./lib/agent-env.mjs"; +import { findRealGh, requiresShipGate } from "./lib/agent-gh-policy.mjs"; + +const selfPath = NodeURL.fileURLToPath(import.meta.url); +const argv = NodeProcess.argv.slice(2); + +let shipping = false; + +if (isCodingAgent()) { + const gate = requiresShipGate(argv); + if (gate.required) { + console.error(`agent gh: ${gate.reason}`); + // Imported here rather than at module scope: `gh` is on the hot path for + // ordinary commands and must not pay for the gate's dependencies to run + // `gh pr view`. + const { runAgentShipGate } = await import("./agent-pre-push.mjs"); + // Exits non-zero itself if any check fails, so a red gate stops the publish + // and a green one falls through to the real `gh` below. + await runAgentShipGate({ root: NodeProcess.cwd() }); + shipping = true; + } +} + +const realGh = findRealGh({ selfPath }); +if (!realGh) { + console.error("agent gh: could not resolve real `gh` binary (set AGENT_GH_REAL)"); + NodeProcess.exit(127); +} + +// Avoid re-entering this shim if PATH still prefers us. +const env = { ...NodeProcess.env }; +const toolsBin = NodePath.resolve(NodePath.dirname(selfPath), "..", ".tools", "bin"); +const pathParts = (env["PATH"] ?? "").split(NodePath.delimiter).filter(Boolean); +env["PATH"] = pathParts.filter((p) => NodePath.resolve(p) !== toolsBin).join(NodePath.delimiter); +env["AGENT_GH_REAL"] = realGh; +// The gate passed, so anything this command spawns is already cleared to ship. +if (shipping) env["AGENT_PR_SHIP"] = "1"; + +const result = NodeChildProcess.spawnSync(realGh, argv, { + stdio: "inherit", + env, + shell: false, +}); +NodeProcess.exit(result.status === null ? 1 : result.status); diff --git a/scripts/agent-pr-ready.mjs b/scripts/agent-pr-ready.mjs new file mode 100644 index 000000000000..dcaa1d7c3977 --- /dev/null +++ b/scripts/agent-pr-ready.mjs @@ -0,0 +1,74 @@ +#!/usr/bin/env node +/** + * Agent (and human) publish path: require HEAD to contain latest fork/dev, + * run the full ship gate, then mark the PR ready. + * + * pnpm pr:ready + * + * This is the explicit path, not the only one: raw `gh pr ready` also runs the + * gate, because the shim runs it before passing the command through. What this + * adds is PR-state handling — a clear error when there is no open PR, and gate- + * only behaviour when the PR is already ready. AGENT_PR_SHIP=1 below marks the + * gate as already passed so the shim does not run it a second time. + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodeProcess from "node:process"; +import { runAgentShipGate } from "./agent-pre-push.mjs"; +import { assertUpToDateWithForkDev } from "./lib/agent-fork-dev.mjs"; +import { resolveOpenPrState } from "./lib/agent-pr-state.mjs"; + +const root = NodeProcess.cwd(); +const prState = resolveOpenPrState({ cwd: root }); + +if (prState.mode === "none") { + console.error( + "agent pr:ready: no open PR for this branch — open a draft first (`gh pr create --draft`)", + ); + NodeProcess.exit(1); +} + +if (prState.mode === "unknown") { + console.error(`agent pr:ready: cannot resolve PR state (${prState.detail ?? "gh failed"})`); + NodeProcess.exit(1); +} + +const forkDev = assertUpToDateWithForkDev({ cwd: root }); +if (!forkDev.ok) { + console.error(`agent pr:ready: ${forkDev.detail}`); + NodeProcess.exit(1); +} +console.error(`agent pr:ready: up to date with ${forkDev.ref}`); + +if (prState.mode === "ready") { + console.error( + `agent pr:ready: PR${prState.pr?.number != null ? ` #${prState.pr.number}` : ""} is already ready — running ship gate only`, + ); + await runAgentShipGate({ root }); + NodeProcess.exit(0); +} + +// draft → full gate then undraft +console.error( + `agent pr:ready: full ship gate then ready PR${prState.pr?.number != null ? ` #${prState.pr.number}` : ""}`, +); +await runAgentShipGate({ root }); + +const env = { ...NodeProcess.env, AGENT_PR_SHIP: "1" }; +const readyArgs = + prState.pr?.number != null ? ["pr", "ready", String(prState.pr.number)] : ["pr", "ready"]; + +console.error("agent pr:ready: marking PR ready for review"); +const result = NodeChildProcess.spawnSync("gh", readyArgs, { + stdio: "inherit", + cwd: root, + env, + shell: false, +}); +const status = result.status === null ? 1 : result.status; +if (status !== 0) { + console.error(`agent pr:ready: gh pr ready failed (exit ${status})`); + NodeProcess.exit(status); +} + +console.error("agent pr:ready: ok — PR is ready; CI will run the full suite"); +NodeProcess.exit(0); diff --git a/scripts/agent-pre-push.mjs b/scripts/agent-pre-push.mjs new file mode 100644 index 000000000000..13619b732439 --- /dev/null +++ b/scripts/agent-pre-push.mjs @@ -0,0 +1,186 @@ +#!/usr/bin/env node +/** + * Husky pre-push entry for coding agents only. + * + * Humans: no-op (exit 0) — self-responsible; not forced by the hook. + * + * Agents: + * - Draft PR or no open PR: changed-file `vp check` (fmt + lint of files + * changed against fork/dev) plus workspace `vpr typecheck`. + * Commits already pay lint-staged. + * - Ready-for-review PR (or unknown PR state): full ship gate (1–3). + * - Publish path is `pnpm pr:ready` (not raw `gh pr ready`) — catch up to + * fork/dev, run the full gate, then undraft. + * See scripts/agent-pr-ready.mjs + scripts/agent-gh.mjs. + * + * Ship gate mirrors the CI JS quality path: + * 1. `vp check` — format + lint (changed files on draft; workspace on full) + * 2. `vpr typecheck` — workspace TypeScript (draft and full) + * 3. `vp run test` — unit tests (full / publish only) + * + * Detection: GROK_AGENT / T3_AGENT / AI_AGENT / Claude / Cursor / Codex env. + * Humans only: SKIP_AGENT_PREPUSH=1 git push + * Agents must never set that flag or use git push --no-verify. + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodePath from "node:path"; +import * as NodeProcess from "node:process"; +import * as NodeURL from "node:url"; +import { isCodingAgent } from "./lib/agent-env.mjs"; +import { filesForChangedShipCheck } from "./lib/agent-fork-dev.mjs"; +import { resolveOpenPrState, shipGateScopeForPush } from "./lib/agent-pr-state.mjs"; +import { + isShipGateForce, + isShipGateShaCached, + isShipGateStaticCached, + readHeadSha, + readShipGateCache, + writeShipGateCache, +} from "./lib/agent-ship-gate-cache.mjs"; + +export { isCodingAgent }; + +/** + * The gate shells out to `vp` / `vpr`, which live in the repository's + * `node_modules/.bin`. pnpm and husky both put that on PATH, so every historical + * caller happened to work and the dependency stayed invisible — until the `gh` + * shim started running the gate from a bare process, where `vpr typecheck` died + * with "command not found". Make the gate supply its own PATH so it does not + * depend on how it was invoked. + * + * @param {string} root + * @param {NodeJS.ProcessEnv} env + * @returns {NodeJS.ProcessEnv} + */ +const withRepoBin = (root, env) => { + const repoBin = NodePath.join(root, "node_modules", ".bin"); + const current = (env["PATH"] ?? "").split(NodePath.delimiter).filter(Boolean); + if (current.some((entry) => NodePath.resolve(entry) === repoBin)) return env; + return { ...env, PATH: [repoBin, ...current].join(NodePath.delimiter) }; +}; + +const run = (label, args, opts = {}) => { + console.error(`agent ship-gate: ${label}`); + const result = NodeChildProcess.spawnSync(args[0], args.slice(1), { + stdio: "inherit", + // File lists must not go through `sh -c` concatenation: a sync merge's + // changed-file argv is large enough to E2BIG even after dropping `.repos/`. + shell: opts.shell ?? true, + cwd: opts.cwd ?? NodeProcess.cwd(), + env: opts.env ?? NodeProcess.env, + }); + const status = result.status === null ? 1 : result.status; + if (status !== 0) { + console.error(`agent ship-gate: failed: ${label} (exit ${status})`); + NodeProcess.exit(status); + } +}; + +/** + * Agent ship gate. Shared by pre-push and `pnpm pr:ready`. + * + * `scope: "changed"` — `vp check` on files changed against fork/dev, then + * workspace `vpr typecheck` (draft / no-PR). + * `scope: "full"` (default) — workspace `vp check` + `vpr typecheck` + `vp run test`. + * + * Caches HEAD SHA under `.run/agent-ship-gate.json` so a full run is never + * double-paid for the same commit. Changed-file runs are not cached as full. + * Force: AGENT_SHIP_GATE_FORCE=1. + * + * @param {{ root?: string, scope?: "full" | "changed", force?: boolean, env?: NodeJS.ProcessEnv }} [opts] + * @returns {Promise<{ status: "cached" | "ok", sha: string | null, scope: "full" | "changed" }>} + */ +export const runAgentShipGate = async (opts = {}) => { + const root = opts.root ?? NodeProcess.cwd(); + const env = withRepoBin(root, opts.env ?? NodeProcess.env); + const force = opts.force === true || isShipGateForce(env); + const scope = opts.scope === "changed" || opts.scope === "static" ? "changed" : "full"; + const headSha = readHeadSha(root); + const cache = readShipGateCache(root); + + if (scope === "changed") { + const files = filesForChangedShipCheck({ cwd: root }); + if (files.length === 0) { + console.error("agent ship-gate: no files changed against fork/dev — skip fmt/lint"); + } else { + run("vp check (changed)", ["vp", "check", "--no-error-on-unmatched-pattern", ...files], { + cwd: root, + env, + shell: false, + }); + } + run("vpr typecheck", ["vpr", "typecheck"], { cwd: root, env }); + console.error( + `agent ship-gate: changed ok — ${files.length} file${files.length === 1 ? "" : "s"} + typecheck; full gate on publish`, + ); + return { status: "ok", sha: headSha, scope }; + } + + const alreadyCached = !force && headSha && isShipGateShaCached(headSha, cache); + + if (alreadyCached) { + console.error( + `agent ship-gate: skip — ${headSha.slice(0, 12)} already validated (cache .run/agent-ship-gate.json; force with AGENT_SHIP_GATE_FORCE=1)`, + ); + return { status: "cached", sha: headSha, scope }; + } + + const staticCached = !force && headSha && isShipGateStaticCached(headSha, cache); + + if (staticCached) { + console.error( + `agent ship-gate: skip check/typecheck — ${headSha.slice(0, 12)} already passed static`, + ); + } else { + run("vp check", ["vp", "check"], { cwd: root, env }); + run("vpr typecheck", ["vpr", "typecheck"], { cwd: root, env }); + } + + run("vp run test", ["vp", "run", "test"], { cwd: root, env }); + + if (headSha) { + try { + writeShipGateCache(root, headSha, { stage: "complete" }); + console.error(`agent ship-gate: cached ${headSha.slice(0, 12)} (.run/agent-ship-gate.json)`); + } catch (error) { + console.error(`agent ship-gate: could not write cache: ${error?.message ?? error}`); + } + } + + console.error("agent ship-gate: ok"); + return { status: "ok", sha: headSha, scope }; +}; + +const thisFile = NodeURL.fileURLToPath(import.meta.url); +const invokedAs = NodeProcess.argv[1] ? NodePath.resolve(NodeProcess.argv[1]) : ""; + +if (invokedAs === thisFile) { + if (!isCodingAgent()) { + NodeProcess.exit(0); + } + + const root = NodeProcess.cwd(); + const prState = resolveOpenPrState({ cwd: root }); + const scope = shipGateScopeForPush(prState.mode); + + if (scope === "changed") { + const why = + prState.mode === "draft" + ? `draft PR${prState.pr?.number != null ? ` #${prState.pr.number}` : ""}` + : "no open PR"; + console.error( + `agent pre-push: ${why} — changed-file check + typecheck (full gate on publish via pnpm pr:ready)`, + ); + } else if (prState.mode === "unknown") { + console.error( + `agent pre-push: PR state unknown (${prState.detail ?? "gh failed"}) — fail closed, running full ship gate`, + ); + } else { + console.error( + `agent pre-push: ready PR${prState.pr?.number != null ? ` #${prState.pr.number}` : ""} — running full ship gate`, + ); + } + + await runAgentShipGate({ root, scope }); + NodeProcess.exit(0); +} diff --git a/scripts/agent-pre-push.test.mjs b/scripts/agent-pre-push.test.mjs new file mode 100644 index 000000000000..0b09a28329b4 --- /dev/null +++ b/scripts/agent-pre-push.test.mjs @@ -0,0 +1,420 @@ +import { assert, it } from "@effect/vitest"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { isCodingAgent } from "./agent-pre-push.mjs"; +import { findRealGh, requiresShipGate, stripGhGlobalFlags } from "./lib/agent-gh-policy.mjs"; +import { + assertUpToDateWithForkDev, + filesForChangedShipCheck, + listChangedFilesAgainstForkDev, + resolveForkDevRef, +} from "./lib/agent-fork-dev.mjs"; +import { + classifyPrPayload, + parseRepoSlug, + resolveOpenPrState, + shipGateScopeForPush, + shouldRunShipGateOnPush, +} from "./lib/agent-pr-state.mjs"; +import { + isShipGateForce, + isShipGateShaCached, + isShipGateStaticCached, + readShipGateCache, + writeShipGateCache, +} from "./lib/agent-ship-gate-cache.mjs"; + +it("humans: empty env is not an agent", () => { + assert.equal(isCodingAgent({}), false); +}); + +it("humans: SKIP_AGENT_PREPUSH wins even if GROK_AGENT is set", () => { + assert.equal(isCodingAgent({ GROK_AGENT: "1", SKIP_AGENT_PREPUSH: "1" }), false); +}); + +it("agents: GROK_AGENT / T3_AGENT / AI_AGENT", () => { + assert.equal(isCodingAgent({ GROK_AGENT: "1" }), true); + assert.equal(isCodingAgent({ T3_AGENT: "1" }), true); + assert.equal(isCodingAgent({ AI_AGENT: "1" }), true); +}); + +it("agents: Claude / Cursor / Codex markers", () => { + assert.equal(isCodingAgent({ CLAUDECODE: "1" }), true); + assert.equal(isCodingAgent({ CURSOR_AGENT: "1" }), true); + assert.equal(isCodingAgent({ CODEX_CI: "1" }), true); +}); + +it("truthy: 0 / false / no are not agents", () => { + assert.equal(isCodingAgent({ GROK_AGENT: "0" }), false); + assert.equal(isCodingAgent({ GROK_AGENT: "false" }), false); +}); + +it("PR payload: draft / ready / closed", () => { + assert.equal(classifyPrPayload(null), "none"); + assert.equal(classifyPrPayload({ isDraft: true, state: "OPEN" }), "draft"); + assert.equal(classifyPrPayload({ isDraft: false, state: "OPEN" }), "ready"); + assert.equal(classifyPrPayload({ isDraft: false, state: "MERGED" }), "none"); + assert.equal(classifyPrPayload({ isDraft: true, state: "CLOSED" }), "none"); +}); + +it("resolveForkDevRef: prefers origin/fork/dev", () => { + const seen = []; + const ref = resolveForkDevRef({ + cwd: "/repo", + runGit: (args) => { + seen.push(args); + if (args.includes("origin/fork/dev")) return { status: 0, stdout: "abc\n" }; + return { status: 1, stdout: "" }; + }, + }); + assert.equal(ref, "origin/fork/dev"); + assert.equal(seen[0]?.includes("origin/fork/dev"), true); +}); + +it("listChangedFilesAgainstForkDev: diffs merge-base..HEAD", () => { + const files = listChangedFilesAgainstForkDev({ + cwd: "/repo", + runGit: (args) => { + if (args.includes("rev-parse")) return { status: 0, stdout: "abc\n" }; + if (args[0] === "merge-base" && args[1] === "HEAD") return { status: 0, stdout: "base123\n" }; + if (args[0] === "diff") return { status: 0, stdout: "AGENTS.md\nscripts/x.mjs\n" }; + return { status: 1, stdout: "" }; + }, + }); + assert.deepEqual(files, ["AGENTS.md", "scripts/x.mjs"]); +}); + +it("filesForChangedShipCheck: drops .repos vendor trees", () => { + const files = filesForChangedShipCheck({ + cwd: "/repo", + runGit: (args) => { + if (args.includes("rev-parse")) return { status: 0, stdout: "abc\n" }; + if (args[0] === "merge-base" && args[1] === "HEAD") return { status: 0, stdout: "base123\n" }; + if (args[0] === "diff") { + return { + status: 0, + stdout: "AGENTS.md\n.repos/effect-smol/x.ts\n.repos/alchemy-effect/y.ts\n", + }; + } + return { status: 1, stdout: "" }; + }, + }); + assert.deepEqual(files, ["AGENTS.md"]); +}); + +it("assertUpToDateWithForkDev: fails when fork/dev is not an ancestor", () => { + const result = assertUpToDateWithForkDev({ + cwd: "/repo", + fetch: false, + runGit: (args) => { + if (args.includes("rev-parse")) return { status: 0, stdout: "abc\n" }; + if (args.includes("--is-ancestor")) return { status: 1, stdout: "" }; + return { status: 0, stdout: "" }; + }, + }); + assert.equal(result.ok, false); + assert.match(result.detail ?? "", /not up to date/); +}); + +it("assertUpToDateWithForkDev: ok when fork/dev is an ancestor", () => { + const result = assertUpToDateWithForkDev({ + cwd: "/repo", + fetch: false, + runGit: (args) => { + if (args.includes("rev-parse")) return { status: 0, stdout: "abc\n" }; + if (args.includes("--is-ancestor")) return { status: 0, stdout: "" }; + return { status: 0, stdout: "" }; + }, + }); + assert.equal(result.ok, true); + assert.equal(result.ref, "origin/fork/dev"); +}); + +it("full ship gate on push: only ready + unknown", () => { + assert.equal(shouldRunShipGateOnPush("none"), false); + assert.equal(shouldRunShipGateOnPush("draft"), false); + assert.equal(shouldRunShipGateOnPush("ready"), true); + assert.equal(shouldRunShipGateOnPush("unknown"), true); +}); + +it("push scope: draft/none = changed, ready/unknown = full", () => { + assert.equal(shipGateScopeForPush("none"), "changed"); + assert.equal(shipGateScopeForPush("draft"), "changed"); + assert.equal(shipGateScopeForPush("ready"), "full"); + assert.equal(shipGateScopeForPush("unknown"), "full"); +}); + +const pinned = (runGh) => ({ branch: "feature", repoSlug: "owner/repo", runGh }); + +it("parseRepoSlug: ssh / https / trailing .git", () => { + assert.equal(parseRepoSlug("git@github.com:patroza/t3code.git"), "patroza/t3code"); + assert.equal(parseRepoSlug("https://github.com/patroza/t3code.git"), "patroza/t3code"); + assert.equal(parseRepoSlug("https://github.com/patroza/t3code"), "patroza/t3code"); + assert.equal(parseRepoSlug("ssh://git@github.com/patroza/t3code.git"), "patroza/t3code"); + assert.equal(parseRepoSlug(""), null); + assert.equal(parseRepoSlug(null), null); +}); + +it("resolveOpenPrState: empty list → none", () => { + const state = resolveOpenPrState(pinned(() => ({ status: 0, stdout: "[]", stderr: "" }))); + assert.equal(state.mode, "none"); +}); + +it("resolveOpenPrState: draft list → draft", () => { + const state = resolveOpenPrState( + pinned(() => ({ + status: 0, + stdout: JSON.stringify([ + { number: 42, url: "https://example/42", isDraft: true, state: "OPEN" }, + ]), + stderr: "", + })), + ); + assert.equal(state.mode, "draft"); + assert.equal(state.pr?.number, 42); +}); + +it("resolveOpenPrState: strips ANSI and shell noise and disables forced color", () => { + let seenEnv; + const state = resolveOpenPrState({ + ...pinned(() => ({ status: 0, stdout: "[]", stderr: "" })), + env: { FORCE_COLOR: "1", CLICOLOR_FORCE: "1" }, + runGh: (_args, opts) => { + seenEnv = opts.env; + return { + status: 0, + stdout: `direnv: loading\n\u001b[32m${JSON.stringify([ + { number: 42, isDraft: true, state: "OPEN" }, + ])}\u001b[0m\n`, + stderr: "", + }; + }, + }); + assert.equal(state.mode, "draft"); + assert.equal(seenEnv.FORCE_COLOR, undefined); + assert.equal(seenEnv.CLICOLOR_FORCE, undefined); + assert.equal(seenEnv.NO_COLOR, "1"); + assert.equal(seenEnv.GH_FORCE_TTY, "0"); +}); + +it("resolveOpenPrState: ready list → ready", () => { + const state = resolveOpenPrState( + pinned(() => ({ + status: 0, + stdout: JSON.stringify([{ number: 7, isDraft: false, state: "OPEN" }]), + stderr: "", + })), + ); + assert.equal(state.mode, "ready"); +}); + +it("resolveOpenPrState: gh crash → unknown (fail closed)", () => { + const state = resolveOpenPrState(pinned(() => ({ status: 2, stdout: "", stderr: "HTTP 401" }))); + assert.equal(state.mode, "unknown"); +}); + +it("resolveOpenPrState: uses --head branch + --repo origin", () => { + let seen = null; + resolveOpenPrState( + pinned((args) => { + seen = args; + return { status: 0, stdout: "[]", stderr: "" }; + }), + ); + assert.isOk(seen.includes("list")); + assert.equal(seen[seen.indexOf("--head") + 1], "feature"); + assert.equal(seen[seen.indexOf("--repo") + 1], "owner/repo"); +}); + +it("resolveOpenPrState: T3CODE_FORK_REPOSITORY overrides origin", () => { + let seen = null; + resolveOpenPrState({ + branch: "feature", + env: { T3CODE_FORK_REPOSITORY: "acme/repo" }, + runGit: () => { + throw new Error("git must not be called when the fork repo is set"); + }, + runGh: (args) => { + seen = args; + return { status: 0, stdout: "[]", stderr: "" }; + }, + }); + assert.equal(seen[seen.indexOf("--repo") + 1], "acme/repo"); +}); + +it("resolveOpenPrState: detached HEAD → unknown (fail closed)", () => { + const state = resolveOpenPrState({ + branch: "HEAD", + repoSlug: "owner/repo", + runGh: () => { + throw new Error("gh must not be called without a branch"); + }, + }); + assert.equal(state.mode, "unknown"); +}); + +it("resolveOpenPrState: no origin repo → unknown (fail closed)", () => { + const state = resolveOpenPrState({ + branch: "feature", + repoSlug: null, + runGh: () => { + throw new Error("gh must not be called without a repo"); + }, + }); + assert.equal(state.mode, "unknown"); +}); + +it("gh policy: pr ready needs the ship gate unless AGENT_PR_SHIP", () => { + assert.equal(requiresShipGate(["pr", "ready"], {}).required, true); + assert.equal(requiresShipGate(["pr", "ready", "12"], {}).required, true); + assert.equal(requiresShipGate(["pr", "ready"], { AGENT_PR_SHIP: "1" }).required, false); + assert.equal(requiresShipGate(["pr", "view"], {}).required, false); + assert.equal(requiresShipGate(["pr", "create", "--draft"], {}).required, false); +}); + +it("gh policy: says the gate is running, not that the command is refused", () => { + const reason = requiresShipGate(["pr", "ready"], {}).reason ?? ""; + assert.equal(reason.includes("ship gate"), true); + assert.equal(/must not|blocked|forbidden/i.test(reason), false); +}); + +it("gh policy: strips -R before matching pr ready", () => { + assert.deepEqual(stripGhGlobalFlags(["-R", "o/r", "pr", "ready"]), ["pr", "ready"]); + assert.equal(requiresShipGate(["-R", "pingdotgg/t3code", "pr", "ready"], {}).required, true); +}); + +it("gh policy: ready_for_review api paths need the ship gate", () => { + assert.equal( + requiresShipGate(["api", "repos/o/r/pulls/1/ready_for_review", "-X", "POST"], {}).required, + true, + ); + assert.equal( + requiresShipGate( + [ + "api", + "graphql", + "-f", + "query=mutation { markPullRequestReadyForReview(input: {}) { clientMutationId } }", + ], + {}, + ).required, + true, + ); +}); + +it("ship-gate cache: match / miss / force", () => { + const sha = "a".repeat(40); + const other = "b".repeat(40); + assert.equal(isShipGateShaCached(sha, { sha }), true); + assert.equal(isShipGateShaCached(sha.toUpperCase(), { sha }), true); + assert.equal(isShipGateShaCached(other, { sha }), false); + assert.equal(isShipGateShaCached(null, { sha }), false); + assert.equal(isShipGateShaCached(sha, null), false); + assert.equal(isShipGateStaticCached(sha, { staticSha: sha }), true); + assert.equal(isShipGateStaticCached(sha, { sha }), true); + assert.equal(isShipGateStaticCached(sha, { staticSha: other }), false); + assert.equal(isShipGateForce({}), false); + assert.equal(isShipGateForce({ AGENT_SHIP_GATE_FORCE: "1" }), true); + assert.equal(isShipGateForce({ AGENT_SHIP_GATE_FORCE: "0" }), false); +}); + +it("ship-gate cache: write + read roundtrip (complete)", () => { + const files = new Map(); + const root = "/tmp/agent-ship-gate-test-root"; + const sha = "c".repeat(40); + writeShipGateCache(root, sha, { + stage: "complete", + mkdirSync: () => {}, + writeFileSync: (file, data) => { + files.set(file, data); + }, + readFileSync: (file) => { + if (!files.has(file)) throw new Error("ENOENT"); + return files.get(file); + }, + now: () => new Date("2026-08-02T00:00:00.000Z"), + }); + assert.equal(files.size, 1); + const written = [...files.values()][0]; + assert.match(written, new RegExp(sha)); + const cache = readShipGateCache(root, { + readFileSync: (file) => { + if (!files.has(file)) throw new Error("ENOENT"); + return files.get(file); + }, + }); + assert.equal(cache?.sha, sha); + assert.equal(cache?.staticSha, sha); + assert.equal(isShipGateShaCached(sha, cache), true); + assert.equal(isShipGateStaticCached(sha, cache), true); +}); + +it("ship-gate cache: static does not demote complete", () => { + const files = new Map(); + const root = "/tmp/agent-ship-gate-static-test"; + const sha = "d".repeat(40); + const io = { + mkdirSync: () => {}, + writeFileSync: (file, data) => { + files.set(file, data); + }, + readFileSync: (file) => { + if (!files.has(file)) throw new Error("ENOENT"); + return files.get(file); + }, + now: () => new Date("2026-08-02T00:00:00.000Z"), + }; + writeShipGateCache(root, sha, { ...io, stage: "complete" }); + writeShipGateCache(root, sha, { ...io, stage: "static" }); + const cache = readShipGateCache(root, io); + assert.equal(cache?.sha, sha); + assert.equal(isShipGateShaCached(sha, cache), true); +}); + +// A host that fronts `gh` with the GitHub App wrapper also exports +// T3_GITHUB_REAL_GH so children that reorder PATH keep minting config. That +// variable names the *unauthenticated* binary the wrapper execs after minting, +// so preferring it makes every shimmed `gh` call fail with "gh auth login" — +// which is exactly how server-side PR lookups lost their badges. +it("findRealGh prefers the App-aware gh on PATH over the raw T3_GITHUB_REAL_GH binary", () => { + const root = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "agent-gh-real-")); + const wrapperDir = NodePath.join(root, "wrapper"); + const rawDir = NodePath.join(root, "raw"); + NodeFS.mkdirSync(wrapperDir); + NodeFS.mkdirSync(rawDir); + const wrapper = NodePath.join(wrapperDir, "gh"); + const raw = NodePath.join(rawDir, "gh"); + for (const file of [wrapper, raw]) { + NodeFS.writeFileSync(file, "#!/bin/sh\nexit 0\n"); + NodeFS.chmodSync(file, 0o755); + } + + assert.equal( + findRealGh({ + env: { PATH: wrapperDir, T3_GITHUB_REAL_GH: raw }, + selfPath: NodePath.join(root, "agent-gh.mjs"), + }), + wrapper, + ); + + // Still usable as a last resort when PATH offers no gh at all. + assert.equal( + findRealGh({ + env: { PATH: NodePath.join(root, "empty"), T3_GITHUB_REAL_GH: raw }, + selfPath: NodePath.join(root, "agent-gh.mjs"), + }), + raw, + ); + + // An explicit override still wins over both. + assert.equal( + findRealGh({ + env: { PATH: wrapperDir, AGENT_GH_REAL: raw, T3_GITHUB_REAL_GH: raw }, + selfPath: NodePath.join(root, "agent-gh.mjs"), + }), + raw, + ); + + NodeFS.rmSync(root, { recursive: true, force: true }); +}); diff --git a/scripts/build-desktop-artifact.test.ts b/scripts/build-desktop-artifact.test.ts index b601d3997fd7..0a5b055553bc 100644 --- a/scripts/build-desktop-artifact.test.ts +++ b/scripts/build-desktop-artifact.test.ts @@ -5,8 +5,8 @@ import * as NodePath from "node:path"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { assert, it } from "@effect/vitest"; import * as ConfigProvider from "effect/ConfigProvider"; -import * as FileSystem from "effect/FileSystem"; import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; @@ -40,6 +40,7 @@ import { MacPasskeySigningConfigurationResolutionError, MissingMacPasskeyProvisioningProfileError, packWindowsServerAsar, + promoteDesktopBuildArtifacts, preflightLinuxDesktopBuild, preflightMacDesktopBuild, preflightWindowsDesktopBuild, @@ -258,6 +259,40 @@ const makeWindowsPayloadFixture = Effect.fn("test.makeWindowsPayloadFixture")(fu }); it.layer(NodeServices.layer)("build-desktop-artifact", (it) => { + it.effect("promotes unpacked desktop directories recursively", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ + prefix: "desktop-artifact-promotion-", + }); + const stageDist = path.join(root, "stage-dist"); + const output = path.join(root, "release"); + const executable = path.join(stageDist, "linux-unpacked", "t3code"); + const resource = path.join(stageDist, "linux-unpacked", "resources", "app.asar"); + + yield* fs.makeDirectory(path.dirname(resource), { recursive: true }); + yield* fs.writeFileString(executable, "binary"); + yield* fs.writeFileString(resource, "asar"); + yield* fs.writeFileString(path.join(stageDist, "builder-debug.yml"), "debug"); + + const artifacts = yield* promoteDesktopBuildArtifacts(stageDist, output, "linux", "x64"); + + assert.deepStrictEqual(artifacts.map((artifact) => path.basename(artifact)).sort(), [ + "builder-debug.yml", + "linux-unpacked", + ]); + assert.equal( + yield* fs.readFileString(path.join(output, "linux-unpacked", "t3code")), + "binary", + ); + assert.equal( + yield* fs.readFileString(path.join(output, "linux-unpacked", "resources", "app.asar")), + "asar", + ); + }), + ); + it("resolves the dedicated nightly updater channel from nightly versions", () => { assert.equal(resolveDesktopUpdateChannel("0.0.17-nightly.20260413.42"), "nightly"); assert.equal(resolveDesktopUpdateChannel("0.0.17"), "latest"); @@ -655,7 +690,14 @@ it.layer(NodeServices.layer)("build-desktop-artifact", (it) => { ...WINDOWS_SERVER_EXTRA_RESOURCES, ]); assert.deepStrictEqual(win.nsis, { differentialPackage: true }); - // The Claude SDK platform packages and .bin shims never ship. + // Native binaries and helper executables cannot load from inside an + // asar; everything else stays packed. The Claude SDK platform packages + // and .bin shims never ship. + assert.equal( + WINDOWS_NATIVE_ASAR_UNPACK_GLOB, + "{*.node,**/*.node,*.dll,**/*.dll,*.exe,**/*.exe,*.so,**/*.so,*.so.*,**/*.so.*,*.dylib,**/*.dylib}", + ); + assert.deepStrictEqual(WINDOWS_SERVER_ASAR_IGNORE_GLOBS, [ "**/node_modules/@anthropic-ai/claude-agent-sdk-*", "**/node_modules/@anthropic-ai/claude-agent-sdk-*/**", diff --git a/scripts/build-desktop-artifact.ts b/scripts/build-desktop-artifact.ts index 44d5f0ab12f4..017416b73eaf 100644 --- a/scripts/build-desktop-artifact.ts +++ b/scripts/build-desktop-artifact.ts @@ -765,6 +765,38 @@ export class WslNodePtyManifestReadError extends Schema.TaggedError null)); + if (!stat || (stat.type !== "File" && stat.type !== "Directory")) continue; + + const to = path.join(outputDir, entry); + yield* fs.copy(from, to); + copiedArtifacts.push(to); + } + + if (copiedArtifacts.length === 0) { + return yield* new DesktopBuildNoArtifactsProducedError({ + distPath: stageDistDir, + platform, + arch, + }); + } + return copiedArtifacts; +}); + export class LinuxIconResizeError extends Schema.TaggedError()( "LinuxIconResizeError", { @@ -1002,8 +1034,13 @@ export const WINDOWS_SERVER_ASAR_RESOURCE = "server.asar"; // dlopen/spawn need real files, so native modules, shared libraries, and // helper executables live in each archive's .unpacked sibling (the standard // asar redirect convention). Everything else stays packed. +// Include both `*.ext` and `**/*.ext`. `@electron/asar` 3.4's unpack matcher +// treats `*.node` as a basename match at any depth on some hosts, and +// `**/*.node` as the nested match on others; either pattern alone can leave +// `.unpacked` siblings missing and fail the pack. export const WINDOWS_NATIVE_ASAR_UNPACK_GLOB = - "{**/*.node,**/*.dll,**/*.exe,**/*.so,**/*.so.*,**/*.dylib}"; + "{*.node,**/*.node,*.dll,**/*.dll,*.exe,**/*.exe,*.so,**/*.so,*.so.*,**/*.so.*,*.dylib,**/*.dylib}"; + // Mirrors DESKTOP_FILE_EXCLUSIONS for the hand-packed sidecar: the Claude SDK // platform packages are dead weight (see above), and node_modules/.bin shims // are never spawned at runtime (and are symlinks on POSIX build hosts, which @@ -2761,20 +2798,20 @@ export const createBuildConfig = Effect.fn("createBuildConfig")(function* ( executableName: "t3code", icon: "icons", category: "Development", - // electron-builder turns these into MimeType=x-scheme-handler/; - // in the .desktop entry (Exec already gets %U), so browsers can hand - // t3code:// OAuth callbacks to the app. + desktop: { + entry: { + StartupWMClass: "t3code", + // Register the external deep-link scheme so xdg-open can launch T3. + // electron-builder keeps %U on Exec when MimeType is present. + MimeType: "x-scheme-handler/t3code;x-scheme-handler/t3code-dev;", + }, + }, protocols: [ { name: "T3 Code", schemes: ["t3code", "t3code-dev"], }, ], - desktop: { - entry: { - StartupWMClass: "t3code", - }, - }, }; } @@ -3958,27 +3995,12 @@ const buildDesktopArtifact = Effect.fn("buildDesktopArtifact")(function* ( }); } - const stageEntries = yield* fs.readDirectory(stageDistDir); - yield* fs.makeDirectory(options.outputDir, { recursive: true }); - - const copiedArtifacts: string[] = []; - for (const entry of stageEntries) { - const from = path.join(stageDistDir, entry); - const stat = yield* fs.stat(from).pipe(Effect.orElseSucceed(() => null)); - if (!stat || stat.type !== "File") continue; - - const to = path.join(options.outputDir, entry); - yield* fs.copyFile(from, to); - copiedArtifacts.push(to); - } - - if (copiedArtifacts.length === 0) { - return yield* new DesktopBuildNoArtifactsProducedError({ - distPath: stageDistDir, - platform: options.platform, - arch: options.arch, - }); - } + const copiedArtifacts = yield* promoteDesktopBuildArtifacts( + stageDistDir, + options.outputDir, + options.platform, + options.arch, + ); yield* Effect.log("[desktop-artifact] Done. Artifacts:").pipe( Effect.annotateLogs({ artifacts: copiedArtifacts }), diff --git a/scripts/classify-deployment-diff.sh b/scripts/classify-deployment-diff.sh new file mode 100755 index 000000000000..d82d4beafea3 --- /dev/null +++ b/scripts/classify-deployment-diff.sh @@ -0,0 +1,131 @@ +#!/usr/bin/env bash + +set -euo pipefail + +base_sha="${1:-}" +head_sha="${2:-}" + +if [[ ! "${base_sha}" =~ ^[0-9a-f]{40}$ ]] || [[ ! "${head_sha}" =~ ^[0-9a-f]{40}$ ]]; then + echo "usage: $0 " >&2 + exit 2 +fi + +is_non_runtime_path() { + case "$1" in + .agents/* | .github/* | docs/* | \ + AGENTS.md | CLAUDE.md | README.md | */README.md | \ + *.md | *.mdx | *.snap | \ + *.test.* | *.spec.* | \ + test/* | tests/* | */test/* | */tests/* | \ + */__snapshots__/* | */__tests__/* | */testUtils/* | */fixtures/* | \ + apps/server/scripts/acp-mock-agent.ts | scripts/release-smoke.ts) + return 0 + ;; + *) + return 1 + ;; + esac +} + +runtime_paths=() +non_runtime_paths=() +while IFS= read -r -d '' path; do + if is_non_runtime_path "${path}"; then + non_runtime_paths+=("${path}") + else + runtime_paths+=("${path}") + fi +done < <(git diff --name-only -z "${base_sha}" "${head_sha}") + +printf 'Changed paths: %d runtime, %d non-runtime\n' \ + "${#runtime_paths[@]}" "${#non_runtime_paths[@]}" + +server=false +# server_code tracks whether the SERVER PROCESS's own code (not just the web +# bundle it serves) changed. apps/web changes leave server=true but keep the +# server hot-swappable: the running process serves dist/client live from disk, +# so new assets can be swapped in without a restart. Only a true server_code +# change forces a process restart. +server_code=false +discord=false +vscode=false +mobile=false +desktop=false + +select_all() { + server=true + server_code=true + discord=true + vscode=true + mobile=true + desktop=true +} + +for path in "${runtime_paths[@]}"; do + case "${path}" in + apps/discord-bot/*) + discord=true + ;; + apps/vscode/*) + vscode=true + ;; + apps/mobile/*) + mobile=true + ;; + apps/desktop/*) + desktop=true + ;; + apps/server/*) + server=true + server_code=true + ;; + apps/web/*) + # The web application is served by both standalone servers and packaged + # desktop clients. It changes the served bundle but not the server process + # code, so the server can be hot-swapped (assets replaced on disk) rather + # than restarted. Desktop bundles its own copy, so it still rebuilds. + server=true + desktop=true + ;; + packages/contracts/* | packages/shared/* | packages/client-runtime/*) + # These packages cross every client/server boundary in the private fleet. + select_all + ;; + *) + # Root manifests, lockfiles, build tooling, and newly introduced runtime + # paths are deliberately conservative until assigned a narrower owner. + select_all + ;; + esac +done + +deploy=false +if [[ "${server}" == "true" || "${discord}" == "true" || "${vscode}" == "true" || + "${mobile}" == "true" || "${desktop}" == "true" ]]; then + deploy=true +fi + +# The server target is affected purely through its served web bundle (no server +# process code changed), so ops can hot-swap dist/client on the running server +# instead of restarting it. Hot-swap MUST promote a complete tree atomically +# (stage → rename); never delete the live dist/client first or desktop opens +# to "Not Found" / 503. Desktop, if flagged, still rebuilds independently. +web_hot_swap=false +if [[ "${server}" == "true" && "${server_code}" == "false" ]]; then + web_hot_swap=true +fi + +if [[ "${deploy}" == "true" ]]; then + printf 'Runtime-affecting paths:\n' + printf ' %s\n' "${runtime_paths[@]}" +else + printf 'Only tests, documentation, agent metadata, or CI metadata changed.\n' +fi + +printf 'deploy=%s\n' "${deploy}" +printf 'server=%s\n' "${server}" +printf 'web_hot_swap=%s\n' "${web_hot_swap}" +printf 'discord=%s\n' "${discord}" +printf 'vscode=%s\n' "${vscode}" +printf 'mobile=%s\n' "${mobile}" +printf 'desktop=%s\n' "${desktop}" diff --git a/scripts/classify-deployment-diff.test.sh b/scripts/classify-deployment-diff.test.sh new file mode 100755 index 000000000000..b11346eadb83 --- /dev/null +++ b/scripts/classify-deployment-diff.test.sh @@ -0,0 +1,56 @@ +#!/usr/bin/env bash + +set -euo pipefail + +root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +work="$(mktemp -d)" +trap 'rm -rf "${work}"' EXIT + +git -C "${work}" init --quiet +git -C "${work}" config user.email test@example.com +git -C "${work}" config user.name Test +mkdir -p "${work}/seed" +touch "${work}/seed/.keep" +git -C "${work}" add seed/.keep +git -C "${work}" commit --quiet -m seed +base="$(git -C "${work}" rev-parse HEAD)" + +assert_scope() { + local path="$1" + local expected="$2" + local output + + mkdir -p "${work}/$(dirname "${path}")" + printf 'changed\n' >"${work}/${path}" + git -C "${work}" add "${path}" + git -C "${work}" commit --quiet -m "change ${path}" + output="$( + cd "${work}" + bash "${root}/scripts/classify-deployment-diff.sh" "${base}" "$(git rev-parse HEAD)" + )" + while IFS='=' read -r key value; do + [[ "$(sed -n "s/^${key}=//p" <<<"${output}")" == "${value}" ]] || { + printf 'expected %s=%s for %s\n%s\n' "${key}" "${value}" "${path}" "${output}" >&2 + exit 1 + } + done <<<"${expected}" + git -C "${work}" reset --quiet --hard "${base}" +} + +assert_scope apps/discord-bot/src/main.ts $'deploy=true\ndiscord=true\nserver=false\nvscode=false\nmobile=false\ndesktop=false' +assert_scope apps/vscode/src/extension.ts $'deploy=true\ndiscord=false\nserver=false\nvscode=true\nmobile=false\ndesktop=false' +assert_scope apps/mobile/src/App.tsx $'deploy=true\ndiscord=false\nserver=false\nvscode=false\nmobile=true\ndesktop=false' +assert_scope apps/desktop/src/main.ts $'deploy=true\ndiscord=false\nserver=false\nvscode=false\nmobile=false\ndesktop=true' +# Server process code changed -> must restart, not hot-swap. +assert_scope apps/server/src/server.ts $'deploy=true\ndiscord=false\nserver=true\nvscode=false\nmobile=false\ndesktop=false\nweb_hot_swap=false' +# Web-only change -> server target affected purely via its served bundle, so it +# is hot-swappable (assets replaced on the running server); desktop still rebuilds. +assert_scope apps/web/src/App.tsx $'deploy=true\ndiscord=false\nserver=true\nvscode=false\nmobile=false\ndesktop=true\nweb_hot_swap=true' +# Cross-boundary packages force a full restart, so no hot-swap. +assert_scope packages/client-runtime/src/index.ts $'deploy=true\ndiscord=true\nserver=true\nvscode=true\nmobile=true\ndesktop=true\nweb_hot_swap=false' +assert_scope pnpm-lock.yaml $'deploy=true\ndiscord=true\nserver=true\nvscode=true\nmobile=true\ndesktop=true\nweb_hot_swap=false' +# Discord-only change never touches the server, so no web hot-swap either. +assert_scope apps/discord-bot/src/handler.ts $'deploy=true\nserver=false\nweb_hot_swap=false' +assert_scope docs/deployment.md $'deploy=false\ndiscord=false\nserver=false\nvscode=false\nmobile=false\ndesktop=false\nweb_hot_swap=false' + +echo "deployment classifier tests passed" diff --git a/scripts/clean-tsgo-backups.mjs b/scripts/clean-tsgo-backups.mjs new file mode 100644 index 000000000000..41cba1f0646c --- /dev/null +++ b/scripts/clean-tsgo-backups.mjs @@ -0,0 +1,24 @@ +// Deletes stale tsgo backup files left behind by `effect-tsgo patch`. +// +// The patch command backs up the real tsgo binary to `tsgo.original`, and if +// that name is taken it writes `tsgo.original.1`, `.2`, ... without ever +// cleaning up. On runners that restore node_modules from a build cache +// (Vercel), backups accumulate across deploys until patch hard-fails at 101 +// with "Too many backup files exist". Removing them is safe: from the second +// patch onward the backup is just the previously-patched binary, and pnpm +// restores the pristine one whenever the package is re-materialized. +// +// Runs as part of `prepare`, so it must only use node builtins. +import * as NodeFS from "node:fs"; + +const backups = NodeFS.globSync( + "node_modules/.pnpm/@typescript+{native-preview-*,typescript-*}/node_modules/@typescript/{native-preview-*,typescript-*}/lib/{tsgo,tsc}{,.exe}.original*", +); + +for (const backup of backups) { + NodeFS.rmSync(backup, { force: true }); +} + +if (backups.length > 0) { + console.log(`Removed ${backups.length} stale tsgo backup(s)`); +} diff --git a/scripts/dev-runner.test.ts b/scripts/dev-runner.test.ts index 1a63d8d74edf..440ceea0bee2 100644 --- a/scripts/dev-runner.test.ts +++ b/scripts/dev-runner.test.ts @@ -159,6 +159,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { baseEnv: {}, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: undefined, browser: undefined, autoBootstrapProjectFromCwd: undefined, @@ -221,6 +222,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { baseEnv: {}, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: "/tmp/custom-t3", browser: false, autoBootstrapProjectFromCwd: false, @@ -275,6 +277,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { }, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: undefined, browser: undefined, autoBootstrapProjectFromCwd: undefined, @@ -298,6 +301,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { }, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: undefined, browser: undefined, autoBootstrapProjectFromCwd: undefined, @@ -319,6 +323,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { baseEnv: {}, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: "/tmp/my-t3", browser: undefined, autoBootstrapProjectFromCwd: undefined, @@ -347,6 +352,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { }, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: "/tmp/my-t3", browser: true, autoBootstrapProjectFromCwd: undefined, @@ -376,6 +382,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { baseEnv: {}, serverOffset: 0, webOffset: 0, + mobileOffset: 0, t3Home: undefined, browser: undefined, autoBootstrapProjectFromCwd: undefined, @@ -766,7 +773,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { checkPortAvailability: (port) => Effect.succeed(!taken.has(port)), }); - assert.deepStrictEqual(offsets, { serverOffset: 1, webOffset: 1 }); + assert.deepStrictEqual(offsets, { serverOffset: 1, webOffset: 1, mobileOffset: 1 }); }), ); @@ -781,7 +788,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { checkPortAvailability: (port) => Effect.succeed(!taken.has(port)), }); - assert.deepStrictEqual(offsets, { serverOffset: 0, webOffset: 1 }); + assert.deepStrictEqual(offsets, { serverOffset: 0, webOffset: 1, mobileOffset: 0 }); }), ); @@ -796,7 +803,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { checkPortAvailability: (port) => Effect.succeed(!taken.has(port)), }); - assert.deepStrictEqual(offsets, { serverOffset: 1, webOffset: 1 }); + assert.deepStrictEqual(offsets, { serverOffset: 1, webOffset: 1, mobileOffset: 0 }); }), ); @@ -810,7 +817,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { checkPortAvailability: () => Effect.succeed(false), }); - assert.deepStrictEqual(offsets, { serverOffset: 0, webOffset: 0 }); + assert.deepStrictEqual(offsets, { serverOffset: 0, webOffset: 0, mobileOffset: 0 }); }), ); @@ -824,7 +831,7 @@ it.layer(NodeServices.layer)("dev-runner", (it) => { checkPortAvailability: () => Effect.succeed(false), }); - assert.deepStrictEqual(offsets, { serverOffset: 0, webOffset: 0 }); + assert.deepStrictEqual(offsets, { serverOffset: 0, webOffset: 0, mobileOffset: 0 }); }), ); }); diff --git a/scripts/dev-runner.ts b/scripts/dev-runner.ts index c4062955e9d5..ed80ed6ad1a1 100644 --- a/scripts/dev-runner.ts +++ b/scripts/dev-runner.ts @@ -26,6 +26,7 @@ Object.assign(process.env, loadRepoEnv()); const BASE_SERVER_PORT = 13773; const BASE_WEB_PORT = 5733; +const BASE_MOBILE_PORT = 8081; const MAX_HASH_OFFSET = 3000; const MAX_PORT = 65535; const DESKTOP_DEV_LOOPBACK_HOST = "127.0.0.1"; @@ -83,6 +84,10 @@ const MODE_ARGS = { "dev:server": ["run", "--filter=t3", "dev"], "dev:web": ["run", "--filter=@t3tools/web", "dev"], "dev:desktop": ["run", "--filter=@t3tools/desktop", "--filter=@t3tools/web", "dev"], + "dev:mobile": ["run", "--filter=@t3tools/mobile", "dev"], + "dev:mobile:client": ["run", "--filter=@t3tools/mobile", "dev:client"], + "run:mobile:ios": ["run", "--filter=@t3tools/mobile", "ios:dev"], + "run:mobile:android": ["run", "--filter=@t3tools/mobile", "android:dev"], } as const satisfies Record>; type DevMode = keyof typeof MODE_ARGS; @@ -137,8 +142,10 @@ export class DevRunnerPortExhaustedError extends Schema.TaggedError()( "DevRunnerProcessExitError", { - mode: Schema.Literals(["dev", "dev:server", "dev:web", "dev:desktop"]), + mode: Schema.Literals([ + "dev", + "dev:server", + "dev:web", + "dev:desktop", + "dev:mobile", + "dev:mobile:client", + "run:mobile:ios", + "run:mobile:android", + ]), executable: Schema.Literal("vp"), argumentCount: Schema.Number, shell: Schema.Boolean, @@ -295,6 +320,7 @@ interface CreateDevRunnerEnvInput { readonly baseEnv: NodeJS.ProcessEnv; readonly serverOffset: number; readonly webOffset: number; + readonly mobileOffset?: number; readonly t3Home: string | undefined; readonly browser: boolean | undefined; readonly autoBootstrapProjectFromCwd: boolean | undefined; @@ -309,6 +335,7 @@ export function createDevRunnerEnv({ baseEnv, serverOffset, webOffset, + mobileOffset, t3Home, browser, autoBootstrapProjectFromCwd, @@ -320,12 +347,12 @@ export function createDevRunnerEnv({ return Effect.gen(function* () { const serverPort = port ?? BASE_SERVER_PORT + serverOffset; const webPort = BASE_WEB_PORT + webOffset; + const mobilePort = mobileOffset !== undefined ? BASE_MOBILE_PORT + mobileOffset : undefined; // Precedence (--home-dir > worktree .t3 > ambient T3CODE_HOME) is resolved // by the caller; an unset t3Home here genuinely means "use the default". const configuredBaseDir = t3Home?.trim() || undefined; const resolvedBaseDir = yield* resolveBaseDir(configuredBaseDir); const isDesktopMode = mode === "dev:desktop"; - const output: NodeJS.ProcessEnv = { ...baseEnv, PORT: String(webPort), @@ -340,6 +367,11 @@ export function createDevRunnerEnv({ delete output.T3CODE_HOME; } + if (mobilePort !== undefined) { + output.EXPO_PORT = String(mobilePort); + // Also set for Metro directly in some cases + output.METRO_PORT = String(mobilePort); + } // A dev-runner server is never launcher-managed. When the shell that runs // this script was itself spawned by the machine's managed t3 service (an // agent working inside T3 Code), these leak through and the child server @@ -495,6 +527,7 @@ interface FindFirstAvailableOffsetInput { readonly startOffset: number; readonly requireServerPort: boolean; readonly requireWebPort: boolean; + readonly requireMobilePort?: boolean; readonly checkPortAvailability?: PortAvailabilityCheck; } @@ -502,6 +535,7 @@ export function findFirstAvailableOffset({ startOffset, requireServerPort, requireWebPort, + requireMobilePort = false, checkPortAvailability, }: FindFirstAvailableOffsetInput): Effect.Effect { return Effect.gen(function* () { @@ -510,13 +544,19 @@ export function findFirstAvailableOffset({ for (let candidate = startOffset; ; candidate += 1) { const { serverPort, webPort } = portPairForOffset(candidate); + const mobilePort = BASE_MOBILE_PORT + candidate; const serverPortOutOfRange = serverPort > MAX_PORT; const webPortOutOfRange = webPort > MAX_PORT; + const mobilePortOutOfRange = mobilePort > MAX_PORT; if ( (requireServerPort && serverPortOutOfRange) || (requireWebPort && webPortOutOfRange) || - (!requireServerPort && !requireWebPort && (serverPortOutOfRange || webPortOutOfRange)) + (requireMobilePort && mobilePortOutOfRange) || + (!requireServerPort && + !requireWebPort && + !requireMobilePort && + (serverPortOutOfRange || webPortOutOfRange || mobilePortOutOfRange)) ) { break; } @@ -532,6 +572,9 @@ export function findFirstAvailableOffset({ if (requireWebPort) { checks.push(checkPort(webPort, "web")); } + if (requireMobilePort) { + checks.push(checkPort(mobilePort)); + } if (checks.length === 0) { return candidate; @@ -547,8 +590,10 @@ export function findFirstAvailableOffset({ startOffset, requireServerPort, requireWebPort, + requireMobilePort: requireMobilePort ?? false, baseServerPort: BASE_SERVER_PORT, baseWebPort: BASE_WEB_PORT, + baseMobilePort: BASE_MOBILE_PORT, maximumPort: MAX_PORT, }); }); @@ -569,7 +614,7 @@ export function resolveModePortOffsets({ hasExplicitDevUrl, checkPortAvailability, }: ResolveModePortOffsetsInput): Effect.Effect< - { readonly serverOffset: number; readonly webOffset: number }, + { readonly serverOffset: number; readonly webOffset: number; readonly mobileOffset: number }, DevRunnerPortExhaustedError, R > { @@ -579,7 +624,7 @@ export function resolveModePortOffsets({ if (mode === "dev:web") { if (hasExplicitDevUrl) { - return { serverOffset: startOffset, webOffset: startOffset }; + return { serverOffset: startOffset, webOffset: startOffset, mobileOffset: startOffset }; } const webOffset = yield* findFirstAvailableOffset({ @@ -588,12 +633,12 @@ export function resolveModePortOffsets({ requireWebPort: true, checkPortAvailability: checkPort, }); - return { serverOffset: startOffset, webOffset }; + return { serverOffset: startOffset, webOffset, mobileOffset: startOffset }; } if (mode === "dev:server") { if (hasExplicitServerPort) { - return { serverOffset: startOffset, webOffset: startOffset }; + return { serverOffset: startOffset, webOffset: startOffset, mobileOffset: startOffset }; } const serverOffset = yield* findFirstAvailableOffset({ @@ -602,7 +647,26 @@ export function resolveModePortOffsets({ requireWebPort: false, checkPortAvailability: checkPort, }); - return { serverOffset, webOffset: serverOffset }; + return { serverOffset, webOffset: serverOffset, mobileOffset: startOffset }; + } + + const isMobileMode = + mode === "dev:mobile" || + mode === "dev:mobile:client" || + mode === "run:mobile:ios" || + mode === "run:mobile:android"; + + if (isMobileMode) { + // For mobile modes, find an offset where the Metro port (8081+) is free. + // We still use the same offset for server/web env vars. + const mobileOffset = yield* findFirstAvailableOffset({ + startOffset, + requireServerPort: false, + requireWebPort: false, + requireMobilePort: true, + checkPortAvailability: checkPort, + }); + return { serverOffset: startOffset, webOffset: startOffset, mobileOffset }; } const sharedOffset = yield* findFirstAvailableOffset({ @@ -612,7 +676,7 @@ export function resolveModePortOffsets({ checkPortAvailability: checkPort, }); - return { serverOffset: sharedOffset, webOffset: sharedOffset }; + return { serverOffset: sharedOffset, webOffset: sharedOffset, mobileOffset: sharedOffset }; }); } @@ -663,7 +727,7 @@ export function runDevRunnerWithInput(input: DevRunnerCliInput) { worktreePath, }); - const { serverOffset, webOffset } = yield* resolveModePortOffsets({ + const { serverOffset, webOffset, mobileOffset } = yield* resolveModePortOffsets({ mode: input.mode, startOffset: offset, hasExplicitServerPort: input.port !== undefined, @@ -691,6 +755,7 @@ export function runDevRunnerWithInput(input: DevRunnerCliInput) { serverOffset, webOffset, t3Home: resolvedT3Home, + mobileOffset, browser: input.browser, autoBootstrapProjectFromCwd: input.autoBootstrapProjectFromCwd, logWebSocketEvents: input.logWebSocketEvents, @@ -701,12 +766,13 @@ export function runDevRunnerWithInput(input: DevRunnerCliInput) { const selectionSuffix = serverOffset !== offset || webOffset !== offset - ? ` selectedOffset(server=${serverOffset},web=${webOffset})` + ? ` selectedOffset(server=${serverOffset},web=${webOffset},mobile=${mobileOffset})` : ""; const baseDir = env.T3CODE_HOME ?? (yield* DEFAULT_T3_HOME); + const mobilePortInfo = env.EXPO_PORT ? ` mobilePort=${env.EXPO_PORT}` : ""; yield* Effect.logInfo( - `[dev-runner] mode=${input.mode} source=${source}${selectionSuffix} serverPort=${String(env.T3CODE_PORT)} webPort=${String(env.PORT)} baseDir=${baseDir}`, + `[dev-runner] mode=${input.mode} source=${source}${selectionSuffix} serverPort=${String(env.T3CODE_PORT)} webPort=${String(env.PORT)}${mobilePortInfo} baseDir=${baseDir}`, ); // Before the share block: --dry-run only resolves and prints. Sharing would @@ -801,11 +867,23 @@ export function runDevRunnerWithInput(input: DevRunnerCliInput) { } } - const spawnCommand = yield* resolveSpawnCommand( - "vp", - [...MODE_ARGS[input.mode], ...input.runArgs], - { env }, - ); + const isMobileMode = + input.mode === "dev:mobile" || + input.mode === "dev:mobile:client" || + input.mode === "run:mobile:ios" || + input.mode === "run:mobile:android"; + + let vpArgs: string[] = [...MODE_ARGS[input.mode]]; + if (isMobileMode && env.EXPO_PORT) { + // Pass --port to expo start / expo run so it uses the allocated mobile port (e.g. 8081 + offset) + if (!vpArgs.includes("--")) { + vpArgs.push("--"); + } + vpArgs.push("--port", env.EXPO_PORT); + } + vpArgs = [...vpArgs, ...input.runArgs]; + + const spawnCommand = yield* resolveSpawnCommand("vp", vpArgs, { env }); const processContext = { mode: input.mode, executable: "vp" as const, diff --git a/scripts/easignore.test.ts b/scripts/easignore.test.ts new file mode 100644 index 000000000000..d32f73c3e488 --- /dev/null +++ b/scripts/easignore.test.ts @@ -0,0 +1,54 @@ +// @effect-diagnostics nodeBuiltinImport:off - Verifies EAS ignore behavior through git's matcher. +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; + +import { describe, expect, it } from "vite-plus/test"; + +const repositoryRoot = NodePath.join( + NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)), + "..", +); + +function isIgnored(cwd: string, path: string): boolean { + try { + NodeChildProcess.execFileSync("git", ["check-ignore", "--no-index", "--quiet", path], { + cwd, + stdio: "ignore", + }); + return true; + } catch { + return false; + } +} + +describe("EAS archive ignore rules", () => { + it("keeps mobile native TypeScript sources while excluding root native tooling", () => { + const fixtureRoot = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-easignore-")); + + try { + NodeChildProcess.execFileSync("git", ["init", "--quiet"], { + cwd: fixtureRoot, + stdio: "ignore", + }); + NodeFS.copyFileSync( + NodePath.join(repositoryRoot, ".easignore"), + NodePath.join(fixtureRoot, ".gitignore"), + ); + + const rootNativeFile = "native/host.swift"; + const mobileNativeFile = "apps/mobile/src/native/native-glass.ts"; + for (const path of [rootNativeFile, mobileNativeFile]) { + NodeFS.mkdirSync(NodePath.dirname(NodePath.join(fixtureRoot, path)), { recursive: true }); + NodeFS.writeFileSync(NodePath.join(fixtureRoot, path), "fixture\n"); + } + + expect(isIgnored(fixtureRoot, rootNativeFile)).toBe(true); + expect(isIgnored(fixtureRoot, mobileNativeFile)).toBe(false); + } finally { + NodeFS.rmSync(fixtureRoot, { force: true, recursive: true }); + } + }); +}); diff --git a/scripts/hooks/post-checkout-server-dist.test.mjs b/scripts/hooks/post-checkout-server-dist.test.mjs new file mode 100644 index 000000000000..0f192b504796 --- /dev/null +++ b/scripts/hooks/post-checkout-server-dist.test.mjs @@ -0,0 +1,39 @@ +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; +import { assert, it } from "@effect/vitest"; + +const repoRoot = NodePath.resolve( + NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)), + "../..", +); +const hook = NodePath.join(repoRoot, ".githooks", "post-checkout"); + +it("keeps apps/server/dist/client across a branch checkout wipe", () => { + const work = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "post-checkout-server-dist-")); + try { + NodeChildProcess.execFileSync("git", ["init", "-q"], { cwd: work }); + const serverIndex = NodePath.join(work, "apps/server/dist/client/index.html"); + const webGone = NodePath.join(work, "apps/web/dist/gone.txt"); + const packageGone = NodePath.join(work, "packages/shared/dist/gone.txt"); + NodeFS.mkdirSync(NodePath.dirname(serverIndex), { recursive: true }); + NodeFS.writeFileSync(serverIndex, "live spa"); + NodeFS.mkdirSync(NodePath.dirname(webGone), { recursive: true }); + NodeFS.writeFileSync(webGone, "wipe me"); + NodeFS.mkdirSync(NodePath.dirname(packageGone), { recursive: true }); + NodeFS.writeFileSync(packageGone, "wipe me"); + + NodeChildProcess.execFileSync("sh", [hook, "HEAD", "HEAD", "1"], { cwd: work }); + + assert.isTrue( + NodeFS.existsSync(serverIndex), + "post-checkout must not delete apps/server/dist (live-served web assets)", + ); + assert.isFalse(NodeFS.existsSync(webGone), "other apps/*/dist should still clear"); + assert.isFalse(NodeFS.existsSync(packageGone), "packages/*/dist should still clear"); + } finally { + NodeFS.rmSync(work, { recursive: true, force: true }); + } +}); diff --git a/scripts/hooks/post-checkout.test.sh b/scripts/hooks/post-checkout.test.sh new file mode 100755 index 000000000000..2bef916f1850 --- /dev/null +++ b/scripts/hooks/post-checkout.test.sh @@ -0,0 +1,101 @@ +#!/usr/bin/env bash +# Exercises the tracked native hooks configured by install-git-hooks.mjs: a raw +# `git worktree add` must fire post-checkout and commits must use the checked-in +# pre-commit hook from that worktree. + +set -euo pipefail + +root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)" +hook="${root}/.githooks/post-checkout" +[ -f "${hook}" ] || { + echo "missing ${hook}" >&2 + exit 1 +} + +work="$(mktemp -d)" +git init -q "${work}/main" +cd "${work}/main" +git config user.email t@example.com +git config user.name t +mkdir -p .githooks +install -m 0755 "${hook}" .githooks/post-checkout +printf '#!/bin/sh\necho FIRED > "$(git rev-parse --show-toplevel)/.precommit"\n' >.githooks/pre-commit +chmod +x .githooks/pre-commit +git add -A +git commit -q -m init + +# A file checkout (third argument 0) must not reconcile dependencies. +out="$(sh "${hook}" 2>&1 || true)" +[ -z "${out}" ] || { + echo "FAIL: file checkout should be silent/no-op, got: ${out}" >&2 + exit 1 +} + +# Wire the tracked hook directory the way install-git-hooks.mjs does. +git config core.hooksPath .githooks + +# --- a fresh `git worktree add` fires post-checkout (no pnpm-lock -> clean skip, exit 0) --- +git worktree add -q "${work}/wt" HEAD +# post-checkout must not abort the checkout even with nothing to install. +test -d "${work}/wt" + +# A commit in the fresh worktree runs its tracked native pre-commit hook. +cd "${work}/wt" +git config user.email t@example.com +git config user.name t +echo change >f.txt +git add f.txt +git commit -q -m c +[ -f "${work}/wt/.precommit" ] && grep -q FIRED "${work}/wt/.precommit" || { + echo "FAIL: native pre-commit did not run" >&2 + exit 1 +} + +# Dependency preparation is best-effort for native Git, but T3's explicit pass +# requests the real exit status so it can persist a degraded-worktree activity. +printf '{}\n' >package.json +printf 'lockfileVersion: 9\n' >pnpm-lock.yaml +sh .githooks/post-checkout HEAD HEAD 1 >/dev/null 2>&1 || { + echo "FAIL: native checkout preparation failure must soft-fail" >&2 + exit 1 +} +set +e +T3CODE_WORKTREE_PREPARATION_STRICT=1 sh .githooks/post-checkout HEAD HEAD 1 >/dev/null 2>&1 +strict_status=$? +set -e +[ "${strict_status}" -ne 0 ] || { + echo "FAIL: strict checkout preparation should preserve the package-manager failure" >&2 + exit 1 +} + +# App-created worktrees can defer the dependency phase to T3's visible async +# setup terminal without weakening strict failures for normal preparation. +deferred_out="$( + T3CODE_DEFER_DEPENDENCY_INSTALL=1 T3CODE_WORKTREE_PREPARATION_STRICT=1 \ + sh .githooks/post-checkout HEAD HEAD 1 2>&1 +)" +case "${deferred_out}" in + *"dependency installation deferred to T3 workspace initialization"*) ;; + *) + echo "FAIL: deferred preparation did not report the async handoff" >&2 + exit 1 + ;; +esac + +# Live t3 serve / Discord-only deploys read apps/server/dist/client from disk. +# A branch checkout must not 503 "Web assets unavailable" by wiping that tree. +cd "${work}/main" +mkdir -p apps/server/dist/client apps/web/dist +printf 'live\n' >apps/server/dist/client/index.html +printf 'wipe\n' >apps/web/dist/gone.txt +sh .githooks/post-checkout HEAD HEAD 1 >/dev/null 2>&1 +[ -f apps/server/dist/client/index.html ] || { + echo "FAIL: post-checkout wiped apps/server/dist/client" >&2 + exit 1 +} +[ ! -e apps/web/dist/gone.txt ] || { + echo "FAIL: post-checkout left apps/web/dist" >&2 + exit 1 +} + +echo "worktree post-checkout hook tests passed" diff --git a/scripts/install-git-hooks.mjs b/scripts/install-git-hooks.mjs new file mode 100644 index 000000000000..93e1bbedd2f8 --- /dev/null +++ b/scripts/install-git-hooks.mjs @@ -0,0 +1,58 @@ +#!/usr/bin/env node +// Installs tracked native Git hooks (runs from the root `prepare` script). +// +// Always installs `.tools/bin/gh` — agent policy shim that blocks `gh pr ready` +// (use `pnpm pr:ready`). Put `$REPO/.tools/bin` first on PATH in agent sessions. +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; +import * as NodeProcess from "node:process"; +import * as NodeURL from "node:url"; + +const root = NodePath.resolve(NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)), ".."); + +const installAgentGhShim = () => { + const toolsBin = NodePath.join(root, ".tools", "bin"); + const agentGh = NodePath.join(root, "scripts", "agent-gh.mjs"); + NodeFS.mkdirSync(toolsBin, { recursive: true }); + const shimPath = NodePath.join(toolsBin, "gh"); + const shim = `#!/usr/bin/env bash +# Installed by scripts/install-git-hooks.mjs — agent gh policy shim. +# Blocks coding-agent \`gh pr ready\`; use \`pnpm pr:ready\` instead. +set -euo pipefail +exec node ${JSON.stringify(agentGh)} "$@" +`; + NodeFS.writeFileSync(shimPath, shim, { encoding: "utf8", mode: 0o755 }); + try { + NodeFS.chmodSync(shimPath, 0o755); + } catch { + // best-effort on platforms without chmod + } +}; + +try { + installAgentGhShim(); +} catch (error) { + console.error(`install-git-hooks: could not install agent gh shim: ${error?.message ?? error}`); +} + +for (const name of ["post-checkout", "pre-commit", "pre-push"]) { + const p = NodePath.join(root, ".githooks", name); + if (NodeFS.existsSync(p)) { + try { + NodeFS.chmodSync(p, 0o755); + } catch { + // best-effort + } + } +} + +try { + NodeChildProcess.execFileSync("git", ["config", "core.hooksPath", ".githooks"], { cwd: root }); +} catch (error) { + console.error( + `install-git-hooks: could not configure native hooks dir: ${error?.message ?? error}`, + ); +} + +NodeProcess.exit(0); diff --git a/scripts/lib/agent-env.mjs b/scripts/lib/agent-env.mjs new file mode 100644 index 000000000000..003483ff05f5 --- /dev/null +++ b/scripts/lib/agent-env.mjs @@ -0,0 +1,26 @@ +/** + * Shared agent-env detection (pre-push, gh shim, pr:ready). + */ +import * as NodeProcess from "node:process"; + +const truthy = (v) => { + if (v == null || v === "") return false; + const s = String(v).toLowerCase(); + return s !== "0" && s !== "false" && s !== "no" && s !== "off"; +}; + +/** @param {NodeJS.ProcessEnv} env */ +export const isCodingAgent = (env = NodeProcess.env) => { + if (truthy(env["SKIP_AGENT_PREPUSH"])) return false; + return ( + truthy(env["GROK_AGENT"]) || + truthy(env["T3_AGENT"]) || + truthy(env["AI_AGENT"]) || + truthy(env["CLAUDECODE"]) || + truthy(env["CLAUDE_CODE"]) || + truthy(env["CURSOR_AGENT"]) || + truthy(env["CURSOR_TRACE_ID"]) || + truthy(env["CODEX_CI"]) || + truthy(env["CODEX_SANDBOX"]) + ); +}; diff --git a/scripts/lib/agent-fork-dev.mjs b/scripts/lib/agent-fork-dev.mjs new file mode 100644 index 000000000000..e431c517816f --- /dev/null +++ b/scripts/lib/agent-fork-dev.mjs @@ -0,0 +1,124 @@ +/** + * fork/dev helpers for the agent ship gate. + * + * Draft / no-PR pushes lint+format only the files changed against fork/dev. + * Publishing requires HEAD to contain the current fork/dev tip. + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodeProcess from "node:process"; + +export const FORK_DEV_REFS = ["origin/fork/dev", "fork/dev"]; + +const defaultRunGit = (args, opts) => { + const result = NodeChildProcess.spawnSync("git", args, { + encoding: "utf8", + cwd: opts.cwd, + shell: false, + }); + return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" }; +}; + +/** + * @param {{ + * cwd?: string + * runGit?: (args: string[], opts: { cwd: string }) => { status: number | null, stdout: string } + * }} [opts] + * @returns {string | null} + */ +export const resolveForkDevRef = (opts = {}) => { + const cwd = opts.cwd ?? NodeProcess.cwd(); + const runGit = opts.runGit ?? defaultRunGit; + for (const ref of FORK_DEV_REFS) { + const result = runGit(["rev-parse", "--verify", ref], { cwd }); + if ((result.status ?? 1) === 0) return ref; + } + return null; +}; + +/** + * Files changed on HEAD relative to the merge-base with fork/dev. + * Falls back to the files in HEAD itself when fork/dev is missing. + * + * @param {{ + * cwd?: string + * runGit?: (args: string[], opts: { cwd: string }) => { status: number | null, stdout: string } + * }} [opts] + * @returns {string[]} + */ +export const listChangedFilesAgainstForkDev = (opts = {}) => { + const cwd = opts.cwd ?? NodeProcess.cwd(); + const runGit = opts.runGit ?? defaultRunGit; + const ref = resolveForkDevRef({ cwd, runGit }); + const result = (() => { + if (!ref) { + return runGit( + ["diff-tree", "--no-commit-id", "--name-only", "--diff-filter=ACMR", "-r", "HEAD"], + { cwd }, + ); + } + const mergeBase = runGit(["merge-base", "HEAD", ref], { cwd }); + const base = String(mergeBase.stdout ?? "").trim(); + if ((mergeBase.status ?? 1) !== 0 || !base) { + return runGit( + ["diff-tree", "--no-commit-id", "--name-only", "--diff-filter=ACMR", "-r", "HEAD"], + { cwd }, + ); + } + return runGit(["diff", "--name-only", "--diff-filter=ACMR", `${base}..HEAD`], { cwd }); + })(); + if ((result.status ?? 1) !== 0) return []; + return String(result.stdout ?? "") + .split("\n") + .map((line) => line.trim()) + .filter(Boolean); +}; + +/** + * Vendored reference trees are ignored by `vp check` / oxlint. Passing thousands + * of them as argv (typical of an upstream Effect/Alchemy ref sync) overflows + * `spawnSync({ shell: true })` with E2BIG and fails the changed-file ship gate. + * + * @param {string} file + * @returns {boolean} + */ +export const isIgnoredVendorPath = (file) => { + const normalized = file.replaceAll("\\", "/"); + return ( + normalized === ".repos" || normalized.startsWith(".repos/") || normalized.includes("/.repos/") + ); +}; + +/** + * @param {Parameters[0]} [opts] + * @returns {string[]} + */ +export const filesForChangedShipCheck = (opts = {}) => + listChangedFilesAgainstForkDev(opts).filter((file) => !isIgnoredVendorPath(file)); + +/** + * @param {{ + * cwd?: string + * runGit?: (args: string[], opts: { cwd: string }) => { status: number | null, stdout: string } + * fetch?: boolean + * }} [opts] + * @returns {{ ok: true, ref: string } | { ok: false, detail: string }} + */ +export const assertUpToDateWithForkDev = (opts = {}) => { + const cwd = opts.cwd ?? NodeProcess.cwd(); + const runGit = opts.runGit ?? defaultRunGit; + if (opts.fetch !== false) { + runGit(["fetch", "origin", "fork/dev"], { cwd }); + } + const ref = resolveForkDevRef({ cwd, runGit }); + if (!ref) { + return { ok: false, detail: "cannot resolve origin/fork/dev (fetch it, then retry)" }; + } + const ancestor = runGit(["merge-base", "--is-ancestor", ref, "HEAD"], { cwd }); + if ((ancestor.status ?? 1) !== 0) { + return { + ok: false, + detail: `HEAD is not up to date with ${ref} — rebase or merge latest fork/dev before publishing`, + }; + } + return { ok: true, ref }; +}; diff --git a/scripts/lib/agent-gh-policy.mjs b/scripts/lib/agent-gh-policy.mjs new file mode 100644 index 000000000000..a8efdaca39f4 --- /dev/null +++ b/scripts/lib/agent-gh-policy.mjs @@ -0,0 +1,174 @@ +/** + * Agent policy for `gh`: recognise the invocations that publish a pull request + * (undraft / ready-for-review side channels) so the shim can run the ship gate + * before letting them through. Publishing is gated, never refused — only a + * failing gate stops it. `pnpm pr:ready` sets AGENT_PR_SHIP=1 so its own undraft + * call does not re-run the gate it just passed. + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; +import * as NodeProcess from "node:process"; +import * as NodeURL from "node:url"; + +const truthy = (v) => { + if (v == null || v === "") return false; + const s = String(v).toLowerCase(); + return s !== "0" && s !== "false" && s !== "no" && s !== "off"; +}; + +/** @param {NodeJS.ProcessEnv} [env] */ +export const isAgentPrShipAllowed = (env = NodeProcess.env) => truthy(env["AGENT_PR_SHIP"]); + +/** + * Strip leading global `gh` flags so subcommands are at the front. + * @param {string[]} argv + */ +export const stripGhGlobalFlags = (argv) => { + const args = [...argv]; + const skipValue = new Set(["-R", "--repo", "-h", "--hostname", "-p", "--path", "--config-dir"]); + while (args.length > 0) { + const a = args[0]; + if (a === "--") { + args.shift(); + break; + } + if (!a.startsWith("-")) break; + if ( + a.includes("=") && + (a.startsWith("-R=") || a.startsWith("--repo=") || a.startsWith("--hostname=")) + ) { + args.shift(); + continue; + } + if (skipValue.has(a)) { + args.shift(); + if (args.length > 0) args.shift(); + continue; + } + // Unknown global flag with possible value — stop rather than mis-parse. + if (a.startsWith("-") && args.length > 1 && !args[1].startsWith("-") && !a.includes("=")) { + // boolean globals like --help stay; leave them for gh + break; + } + args.shift(); + } + return args; +}; + +/** + * Does this `gh` invocation publish a pull request, and therefore have to pass + * the ship gate first? + * + * Publishing is not refused — it is gated. The shim runs the same gate + * `pnpm pr:ready` runs and then lets the command through; only a failing gate + * stops it. Refusing outright just moved the work to a command the agent had to + * remember, and left repositories without a `pr:ready` equivalent with no route + * at all. + * + * @param {string[]} argv args after the gh binary name + * @param {NodeJS.ProcessEnv} [env] + * @returns {{ required: boolean, reason?: string }} + */ +export const requiresShipGate = (argv, env = NodeProcess.env) => { + // Already gated: `pnpm pr:ready` sets this for its own undraft call, so the + // gate runs once rather than twice. + if (isAgentPrShipAllowed(env)) return { required: false }; + + const args = stripGhGlobalFlags(argv); + if (args.length === 0) return { required: false }; + + // gh pr ready [number] + if (args[0] === "pr" && args[1] === "ready") { + return { + required: true, + reason: "`gh pr ready` publishes this PR — running the ship gate first", + }; + } + + // REST / GraphQL undraft side channels via `gh api` + if (args[0] === "api") { + const joined = args.join(" "); + if (/ready_for_review/i.test(joined) || /markPullRequestReadyForReview/i.test(joined)) { + return { + required: true, + reason: "this `gh api` call publishes a PR — running the ship gate first", + }; + } + } + + return { required: false }; +}; + +/** + * Resolve the real `gh` binary, skipping this policy shim when it is on PATH. + * @param {{ env?: NodeJS.ProcessEnv, selfPath?: string }} [opts] + * @returns {string | null} + */ +export const findRealGh = (opts = {}) => { + const env = opts.env ?? NodeProcess.env; + // Set by this shim for its own child, so honour it first. + if (env["AGENT_GH_REAL"] && NodeFS.existsSync(env["AGENT_GH_REAL"])) { + return env["AGENT_GH_REAL"]; + } + + // NOT T3_GITHUB_REAL_GH here: that names the *unauthenticated* binary the + // GitHub App wrapper execs after it mints an installation token, and hosts + // export it precisely so a child that reorders PATH keeps minting config. + // Delegating straight to it skips minting, so every `gh` call the shim + // fronts fails with "gh auth login" — which is how server-side PR lookups + // silently lost their badges. Prefer whatever PATH resolves (the App-aware + // `gh`), and fall back to the raw binary only when nothing else exists. + + const selfPath = opts.selfPath + ? NodePath.resolve(opts.selfPath) + : NodeURL.fileURLToPath(import.meta.url); + + const pathEnv = env["PATH"] ?? ""; + for (const dir of pathEnv.split(NodePath.delimiter).filter(Boolean)) { + for (const name of ["gh", "gh.real"]) { + const candidate = NodePath.join(dir, name); + try { + if (!NodeFS.existsSync(candidate)) continue; + const resolved = NodeFS.realpathSync(candidate); + // Skip our shim (scripts/agent-gh.mjs launched via .tools/bin/gh). + if (resolved === selfPath) continue; + if (resolved.endsWith(`${NodePath.sep}agent-gh.mjs`)) continue; + if (resolved.includes(`${NodePath.sep}.tools${NodePath.sep}bin${NodePath.sep}gh`)) continue; + // Prefer executables; on Windows skip the check. + try { + NodeFS.accessSync(candidate, NodeFS.constants.X_OK); + } catch { + continue; + } + return candidate; + } catch { + // try next + } + } + } + + // Only now consider the raw binary the App wrapper execs: better an + // unauthenticated `gh` than none, but never in preference to the wrapper. + if (env["T3_GITHUB_REAL_GH"] && NodeFS.existsSync(env["T3_GITHUB_REAL_GH"])) { + return env["T3_GITHUB_REAL_GH"]; + } + + // Last resort: ask the shell (may return us — caller must detect loops). + const which = NodeChildProcess.spawnSync("bash", ["-lc", "command -v gh"], { + encoding: "utf8", + env, + shell: false, + }); + if (which.status === 0) { + const p = which.stdout.trim(); + if ( + p && + !p.endsWith("agent-gh.mjs") && + !p.includes(`${NodePath.sep}.tools${NodePath.sep}bin${NodePath.sep}gh`) + ) { + return p; + } + } + return null; +}; diff --git a/scripts/lib/agent-pr-state.mjs b/scripts/lib/agent-pr-state.mjs new file mode 100644 index 000000000000..b5ba0a5fbec4 --- /dev/null +++ b/scripts/lib/agent-pr-state.mjs @@ -0,0 +1,200 @@ +/** + * Resolve whether the current branch's open PR should enforce the agent ship gate. + * + * Modes: + * none — no open PR (or closed/merged): changed-file check + typecheck + * draft — open draft PR: changed-file check + typecheck + * ready — open non-draft PR: full ship gate on every agent push + * unknown — gh missing / failed: fail closed (run the full gate) + * + * This fork lives under `patroza/t3code` but `gh` defaults to the upstream + * parent (`pingdotgg/t3code`). A bare `gh pr view` therefore never finds the + * fork's PRs, which would silently disable the gate. `.envrc` sets `GH_REPO` + * to fix that for interactive shells, but the pre-push hook must not depend on + * direnv being loaded — so resolve the PR against the fork repo explicitly: + * `T3CODE_FORK_REPOSITORY` when set, else the `origin` remote, passed as + * `gh pr list --head --repo` (an explicit `--repo` overrides GH_REPO). + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodeProcess from "node:process"; + +/** + * @param {{ isDraft?: boolean, state?: string } | null | undefined} pr + * @returns {"none" | "draft" | "ready"} + */ +export const classifyPrPayload = (pr) => { + if (pr == null) return "none"; + const state = String(pr.state ?? "").toUpperCase(); + if (state === "CLOSED" || state === "MERGED") return "none"; + if (pr.isDraft === true) return "draft"; + return "ready"; +}; + +/** + * @param {"none" | "draft" | "ready" | "unknown"} mode + * @returns {boolean} + */ +export const shouldRunShipGateOnPush = (mode) => mode === "ready" || mode === "unknown"; + +/** + * How much of the gate a push pays for. + * + * Draft / no-PR: format + lint of files changed against fork/dev, plus typecheck. + * Ready / unknown: full workspace check + typecheck + unit tests. + * + * @param {"none" | "draft" | "ready" | "unknown"} mode + * @returns {"full" | "changed"} + */ +export const shipGateScopeForPush = (mode) => (shouldRunShipGateOnPush(mode) ? "full" : "changed"); + +/** Strip ANSI color codes so `gh --json` stays parseable when color is forced. */ +const stripAnsi = (text) => String(text).replace(/\u001b\[[0-9;]*m/g, ""); + +/** Return the JSON array while ignoring shell integration noise around it. */ +const extractJsonArray = (text) => { + const cleaned = stripAnsi(text).trim(); + const start = cleaned.indexOf("["); + const end = cleaned.lastIndexOf("]"); + if (start === -1 || end === -1 || end < start) return cleaned; + return cleaned.slice(start, end + 1); +}; + +/** + * Parse `owner/repo` from a GitHub remote URL (ssh, https, or git protocol). + * @param {string | null | undefined} url + * @returns {string | null} + */ +export const parseRepoSlug = (url) => { + if (!url) return null; + const trimmed = String(url).trim(); + const match = trimmed.match( + /(?:git@[^:]+:|ssh:\/\/[^/]+\/|https?:\/\/[^/]+\/|git:\/\/[^/]+\/)([^/]+\/[^/]+?)(?:\.git)?\/?$/, + ); + return match ? match[1] : null; +}; + +/** + * @param {{ + * cwd?: string + * env?: NodeJS.ProcessEnv + * branch?: string + * repoSlug?: string | null + * runGh?: (args: string[], opts: { cwd: string, env: NodeJS.ProcessEnv }) => + * { status: number | null, stdout: string, stderr: string, error?: NodeJS.ErrnoException } + * runGit?: (args: string[], opts: { cwd: string }) => + * { status: number | null, stdout: string, error?: NodeJS.ErrnoException } + * }} [opts] + * @returns {{ mode: "none" | "draft" | "ready" | "unknown", pr: { number?: number, url?: string, isDraft?: boolean, state?: string } | null, detail?: string }} + */ +export const resolveOpenPrState = (opts = {}) => { + const cwd = opts.cwd ?? NodeProcess.cwd(); + const env = { ...(opts.env ?? NodeProcess.env) }; + delete env.FORCE_COLOR; + delete env.CLICOLOR_FORCE; + env.NO_COLOR = "1"; + env.CLICOLOR = "0"; + env.GH_FORCE_TTY = "0"; + env.TERM = "dumb"; + const runGh = + opts.runGh ?? + ((args, runOpts) => { + const result = NodeChildProcess.spawnSync("gh", args, { + encoding: "utf8", + cwd: runOpts.cwd, + env: runOpts.env, + shell: false, + }); + return { + status: result.status, + stdout: result.stdout ?? "", + stderr: result.stderr ?? "", + error: result.error, + }; + }); + const runGit = + opts.runGit ?? + ((args, runOpts) => { + const result = NodeChildProcess.spawnSync("git", args, { + encoding: "utf8", + cwd: runOpts.cwd, + shell: false, + }); + return { status: result.status, stdout: result.stdout ?? "", error: result.error }; + }); + + const gitValue = (args) => { + const r = runGit(args, { cwd }); + if (r.error || (r.status !== null && r.status !== 0)) return null; + const v = String(r.stdout ?? "").trim(); + return v || null; + }; + + const branch = opts.branch ?? gitValue(["rev-parse", "--abbrev-ref", "HEAD"]); + const repoSlug = + opts.repoSlug !== undefined + ? opts.repoSlug + : env["T3CODE_FORK_REPOSITORY"]?.trim() || + parseRepoSlug(gitValue(["remote", "get-url", "origin"])); + + // Detached HEAD or unknown origin: we cannot pin the PR to the fork repo. + // Fail closed so the gate still runs rather than silently skipping. + if (!branch || branch === "HEAD" || !repoSlug) { + return { + mode: "unknown", + pr: null, + detail: + !branch || branch === "HEAD" ? "no branch (detached HEAD?)" : "cannot resolve origin repo", + }; + } + + const result = runGh( + [ + "pr", + "list", + "--head", + branch, + "--repo", + repoSlug, + "--state", + "open", + "--json", + "number,url,isDraft,state", + ], + { cwd, env }, + ); + + if (result.error && result.error.code === "ENOENT") { + return { mode: "unknown", pr: null, detail: "gh not found on PATH" }; + } + + const status = result.status === null ? 1 : result.status; + const stderr = stripAnsi(result.stderr ?? "").trim(); + const stdout = extractJsonArray(result.stdout ?? ""); + + // gh error (auth / network / bad repo): fail closed, run the gate. + if (status !== 0) { + return { + mode: "unknown", + pr: null, + detail: stderr.trim() || stdout || `gh pr list exited ${status}`, + }; + } + + if (!stdout) { + return { mode: "none", pr: null, detail: "no open PR for branch" }; + } + + try { + const list = JSON.parse(stdout); + const pr = Array.isArray(list) ? list[0] : list; + if (!pr) return { mode: "none", pr: null, detail: "no open PR for branch" }; + const mode = classifyPrPayload(pr); + return { mode, pr, detail: mode === "none" ? `PR ${pr.number} is ${pr.state}` : undefined }; + } catch (error) { + return { + mode: "unknown", + pr: null, + detail: `failed to parse gh pr list JSON: ${error?.message ?? error}`, + }; + } +}; diff --git a/scripts/lib/agent-ship-gate-cache.mjs b/scripts/lib/agent-ship-gate-cache.mjs new file mode 100644 index 000000000000..11b84f723645 --- /dev/null +++ b/scripts/lib/agent-ship-gate-cache.mjs @@ -0,0 +1,174 @@ +/** + * Persist the last HEAD SHA that passed the agent ship gate. + * pre-push and `pnpm pr:ready` share this so the same commit is never double-paid. + * + * Path: `.run/agent-ship-gate.json` (under gitignored `.run/`). + * + * Checkpoints, cheapest first — each implies the ones before it: + * static — `vp check` + `vpr typecheck` (what a draft / no-PR push pays) + * complete — plus `vp run test` (ready PR / publish) + */ +import * as NodeChildProcess from "node:child_process"; +import * as NodeFS from "node:fs"; +import * as NodePath from "node:path"; +import * as NodeProcess from "node:process"; + +export const SHIP_GATE_CACHE_REL = NodePath.join(".run", "agent-ship-gate.json"); + +/** @param {string} [root] */ +export const shipGateCachePath = (root = NodeProcess.cwd()) => + NodePath.join(root, SHIP_GATE_CACHE_REL); + +/** + * @param {string} [root] + * @param {{ runGit?: (args: string[], opts: { cwd: string }) => { status: number | null, stdout: string } }} [opts] + * @returns {string | null} full SHA or null + */ +export const readHeadSha = (root = NodeProcess.cwd(), opts = {}) => { + const runGit = + opts.runGit ?? + ((args, runOpts) => { + const result = NodeChildProcess.spawnSync("git", args, { + encoding: "utf8", + cwd: runOpts.cwd, + shell: false, + }); + return { status: result.status, stdout: result.stdout ?? "" }; + }); + const result = runGit(["rev-parse", "HEAD"], { cwd: root }); + if (result.status !== 0) return null; + const sha = String(result.stdout).trim(); + return /^[0-9a-f]{40}$/i.test(sha) ? sha.toLowerCase() : null; +}; + +export const SHIP_GATE_STAGES = ["static", "complete"]; + +/** + * @param {string} [root] + * @param {{ readFileSync?: typeof NodeFS.readFileSync }} [opts] + * @returns {{ sha?: string, validatedAt?: string, staticSha?: string, staticAt?: string } | null} + */ +export const readShipGateCache = (root = NodeProcess.cwd(), opts = {}) => { + const readFileSync = opts.readFileSync ?? NodeFS.readFileSync; + const file = shipGateCachePath(root); + const readSha = (value) => { + const normalized = typeof value === "string" ? value.trim().toLowerCase() : ""; + return /^[0-9a-f]{40}$/i.test(normalized) ? normalized : undefined; + }; + try { + const raw = readFileSync(file, "utf8"); + const parsed = JSON.parse(raw); + const sha = readSha(parsed?.sha); + // Legacy caches only had `sha` meaning full complete; treat as both stages. + const staticSha = readSha(parsed?.staticSha) ?? sha; + if (!sha && !staticSha) return null; + return { + sha, + validatedAt: typeof parsed.validatedAt === "string" ? parsed.validatedAt : undefined, + staticSha, + staticAt: + typeof parsed.staticAt === "string" + ? parsed.staticAt + : typeof parsed.validatedAt === "string" + ? parsed.validatedAt + : undefined, + }; + } catch { + return null; + } +}; + +/** + * Highest checkpoint the cache records for `headSha`, as an index into + * SHIP_GATE_STAGES; -1 when the cache describes another commit. + * @param {string | null | undefined} headSha + * @param {{ sha?: string, staticSha?: string } | null | undefined} cache + */ +export const cachedStage = (headSha, cache) => { + if (!headSha || !cache) return -1; + const h = headSha.toLowerCase(); + if (cache.sha && cache.sha.toLowerCase() === h) return SHIP_GATE_STAGES.indexOf("complete"); + if (cache.staticSha && cache.staticSha.toLowerCase() === h) + return SHIP_GATE_STAGES.indexOf("static"); + return -1; +}; + +/** + * @param {string} root + * @param {string} sha + * @param {{ + * stage?: "static" | "complete" + * writeFileSync?: typeof NodeFS.writeFileSync + * mkdirSync?: typeof NodeFS.mkdirSync + * readFileSync?: typeof NodeFS.readFileSync + * now?: () => Date + * }} [opts] + */ +export const writeShipGateCache = (root, sha, opts = {}) => { + const writeFileSync = opts.writeFileSync ?? NodeFS.writeFileSync; + const mkdirSync = opts.mkdirSync ?? NodeFS.mkdirSync; + const now = opts.now ?? (() => new Date()); + const stage = opts.stage ?? "complete"; + const normalized = String(sha).trim().toLowerCase(); + if (!/^[0-9a-f]{40}$/i.test(normalized)) { + throw new Error(`writeShipGateCache: invalid sha ${sha}`); + } + // Never demote the same commit: a draft push (static) landing after a full + // run would otherwise make the next publish re-pay tests it already passed. + if (SHIP_GATE_STAGES.indexOf(stage) < cachedStage(normalized, readShipGateCache(root, opts))) { + return; + } + const file = shipGateCachePath(root); + const at = now().toISOString(); + const existing = readShipGateCache(root, opts) ?? {}; + const value = + stage === "static" + ? { + ...existing, + staticSha: normalized, + staticAt: at, + } + : { + sha: normalized, + validatedAt: at, + staticSha: normalized, + staticAt: existing.staticAt ?? at, + }; + mkdirSync(NodePath.dirname(file), { recursive: true }); + writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, "utf8"); +}; + +/** + * Full gate (check + typecheck + test) already passed for this SHA. + * @param {string | null | undefined} headSha + * @param {{ sha?: string } | null | undefined} cache + */ +export const isShipGateShaCached = (headSha, cache) => { + if (!headSha || !cache?.sha) return false; + return headSha.toLowerCase() === cache.sha.toLowerCase(); +}; + +/** + * Static gate (check + typecheck) already passed for this SHA. + * Full cache also satisfies static. + * @param {string | null | undefined} headSha + * @param {{ sha?: string, staticSha?: string } | null | undefined} cache + */ +export const isShipGateStaticCached = (headSha, cache) => { + if (!headSha || !cache) return false; + const h = headSha.toLowerCase(); + if (cache.sha && cache.sha.toLowerCase() === h) return true; + if (cache.staticSha && cache.staticSha.toLowerCase() === h) return true; + return false; +}; + +/** + * Force re-run even when SHA is cached. + * @param {NodeJS.ProcessEnv} [env] + */ +export const isShipGateForce = (env = NodeProcess.env) => { + const v = env["AGENT_SHIP_GATE_FORCE"]; + if (v == null || v === "") return false; + const s = String(v).toLowerCase(); + return s !== "0" && s !== "false" && s !== "no" && s !== "off"; +}; diff --git a/scripts/lib/cli-external-packages.test.ts b/scripts/lib/cli-external-packages.test.ts index e894359eccb5..07c5647da1a4 100644 --- a/scripts/lib/cli-external-packages.test.ts +++ b/scripts/lib/cli-external-packages.test.ts @@ -194,9 +194,9 @@ it.layer(NodeServices.layer)("external package dependency closure", (it) => { if (!manifest) continue; const declared = { - ...(manifest.dependencies ?? {}), - ...(manifest.optionalDependencies ?? {}), - ...(manifest.peerDependencies ?? {}), + ...manifest.dependencies, + ...manifest.optionalDependencies, + ...manifest.peerDependencies, }; for (const dependency of Object.keys(declared)) { if (!isRuntimeExternal(dependency)) { diff --git a/scripts/lib/disk-backed-tmp.test.ts b/scripts/lib/disk-backed-tmp.test.ts new file mode 100644 index 000000000000..519b2312c9be --- /dev/null +++ b/scripts/lib/disk-backed-tmp.test.ts @@ -0,0 +1,41 @@ +// @effect-diagnostics nodeBuiltinImport:off +import { describe, expect, it } from "vite-plus/test"; +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { diskBackedWorkRoot, mkdtempDiskBacked } from "./disk-backed-tmp.ts"; + +describe("diskBackedWorkRoot", () => { + it("prefers explicit env var", () => { + const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "disk-backed-env-")); + const prev = process.env.T3_REBASE_WORK_ROOT; + process.env.T3_REBASE_WORK_ROOT = dir; + try { + expect(diskBackedWorkRoot({ subdir: "rebase-work", envVar: "T3_REBASE_WORK_ROOT" })).toBe( + dir, + ); + } finally { + if (prev === undefined) delete process.env.T3_REBASE_WORK_ROOT; + else process.env.T3_REBASE_WORK_ROOT = prev; + NodeFS.rmSync(dir, { recursive: true, force: true }); + } + }); + + it("mkdtempDiskBacked creates a unique directory under the work root", () => { + const root = diskBackedWorkRoot({ subdir: "rebase-work", envVar: "T3_REBASE_WORK_ROOT" }); + const a = mkdtempDiskBacked("rebase-pr-stack-", { + subdir: "rebase-work", + envVar: "T3_REBASE_WORK_ROOT", + }); + const b = mkdtempDiskBacked("rebase-pr-stack-", { + subdir: "rebase-work", + envVar: "T3_REBASE_WORK_ROOT", + }); + expect(a).not.toBe(b); + expect(a.startsWith(root)).toBe(true); + expect(NodeFS.statSync(a).isDirectory()).toBe(true); + NodeFS.rmSync(a, { recursive: true, force: true }); + NodeFS.rmSync(b, { recursive: true, force: true }); + }); +}); diff --git a/scripts/lib/disk-backed-tmp.ts b/scripts/lib/disk-backed-tmp.ts new file mode 100644 index 000000000000..2f9ec939e3d7 --- /dev/null +++ b/scripts/lib/disk-backed-tmp.ts @@ -0,0 +1,104 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Disk-backed work roots for multi-GB tooling (stack rebase, compose, clones). + * + * `/tmp` is often tmpfs (host Arch) or the guest's RAM rootfs (t3vm). Putting full + * git workdirs there OOMs or fills root. Prefer HOME/.t3/ (or T3CODE_HOME + * when that is the data volume), with TMPDIR only if it is not a tmpfs. + */ +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +function isTmpfsPath(dir: string): boolean { + try { + // Linux: /proc/mounts. Best-effort — if unreadable, assume not tmpfs. + const mounts = NodeFS.readFileSync("/proc/mounts", "utf8"); + let bestLen = -1; + let bestFs = ""; + const resolved = NodeFS.realpathSync(dir); + for (const line of mounts.split("\n")) { + const parts = line.split(/\s+/); + if (parts.length < 3) continue; + const mountPoint = parts[1]!; + const fsType = parts[2]!; + if ( + (resolved === mountPoint || + resolved.startsWith(mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`)) && + mountPoint.length > bestLen + ) { + bestLen = mountPoint.length; + bestFs = fsType; + } + } + return bestFs === "tmpfs" || bestFs === "ramfs"; + } catch { + return false; + } +} + +function tryMkdir(dir: string): boolean { + try { + NodeFS.mkdirSync(dir, { recursive: true }); + NodeFS.accessSync(dir, NodeFS.constants.W_OK); + return true; + } catch { + return false; + } +} + +/** + * Resolve a durable work root for heavy temporary trees. + * + * Order: + * 1. `envVar` if set (e.g. T3_REBASE_WORK_ROOT) + * 2. `$T3CODE_HOME/` when T3CODE_HOME is set (t3vm: /var/lib/t3) + * 3. `$HOME/.t3/` + * 4. `$TMPDIR` only if not tmpfs + * 5. `os.tmpdir()` last resort + */ +export function diskBackedWorkRoot(options: { + readonly subdir: string; + readonly envVar?: string; +}): string { + const fromEnv = options.envVar ? process.env[options.envVar]?.trim() : undefined; + if (fromEnv && tryMkdir(fromEnv)) { + return fromEnv; + } + + const t3Home = process.env.T3CODE_HOME?.trim(); + if (t3Home) { + const candidate = NodePath.join(t3Home, options.subdir); + if (tryMkdir(candidate)) return candidate; + } + + const home = process.env.HOME?.trim() || NodeOS.homedir(); + if (home) { + const candidate = NodePath.join(home, ".t3", options.subdir); + if (tryMkdir(candidate)) return candidate; + } + + const tmpDir = process.env.TMPDIR?.trim(); + if (tmpDir && !isTmpfsPath(tmpDir) && tryMkdir(tmpDir)) { + return tmpDir; + } + + const osTmp = NodeOS.tmpdir(); + if (!isTmpfsPath(osTmp) && tryMkdir(osTmp)) { + return osTmp; + } + + // Last resort: still create under preferred home path even if access check was flaky. + const fallback = NodePath.join(home || "/tmp", ".t3", options.subdir); + NodeFS.mkdirSync(fallback, { recursive: true }); + return fallback; +} + +/** `mkdtemp` under {@link diskBackedWorkRoot} (prefix should end with `-`). */ +export function mkdtempDiskBacked( + prefix: string, + options: { readonly subdir: string; readonly envVar?: string }, +): string { + const root = diskBackedWorkRoot(options); + return NodeFS.mkdtempSync(NodePath.join(root, prefix)); +} diff --git a/scripts/mobile-showcase-environment.ts b/scripts/mobile-showcase-environment.ts index 93738b61325a..69695437e259 100644 --- a/scripts/mobile-showcase-environment.ts +++ b/scripts/mobile-showcase-environment.ts @@ -1,4 +1,4 @@ -// @effect-diagnostics nodeBuiltinImport:off globalTimers:off globalDate:off - This host-side fixture creates an isolated local T3 environment. +// @effect-diagnostics nodeBuiltinImport:off globalDate:off globalTimers:off - This host-side fixture creates an isolated local T3 environment. import * as NodeChildProcess from "node:child_process"; import * as NodeFSP from "node:fs/promises"; import * as NodePath from "node:path"; @@ -484,7 +484,17 @@ function seedDatabase( const database = new NodeSqlite.DatabaseSync(dbPath, { timeout: 30_000 }); try { database.exec("BEGIN IMMEDIATE"); - for (const table of SEEDED_PROJECTION_TABLES) { + for (const table of [ + "projection_pending_approvals", + "projection_thread_proposed_plans", + "projection_thread_activities", + "projection_thread_messages", + "projection_thread_sessions", + "projection_turns", + "projection_threads", + "projection_projects", + "projection_state", + ]) { database.exec(`DELETE FROM ${table}`); } const insertProject = database.prepare( diff --git a/scripts/mobile-showcase.config.ts b/scripts/mobile-showcase.config.ts index 45a9f474fa84..41d0f813409d 100644 --- a/scripts/mobile-showcase.config.ts +++ b/scripts/mobile-showcase.config.ts @@ -147,8 +147,8 @@ const config: ShowcaseConfig = { storeAsset: { store: "apple", directory: "apple/ipad-13", - width: 2752, - height: 2064, + width: 2064, + height: 2752, minimumUploadCount: 1, maximumUploadCount: 10, }, @@ -158,7 +158,7 @@ const config: ShowcaseConfig = { platform: "android", avd: "Pixel_10_Pro", // Apple Silicon uses ARM64 locally; CI overrides this with x86_64 so its - // Blacksmith Linux runner can use KVM acceleration. + // Linux CI runners may use KVM acceleration when available. abi: resolveShowcaseAndroidAbi(process.env.T3_SHOWCASE_ANDROID_ABI), appearance: "dark", theme: DEFAULT_SHOWCASE_THEME, diff --git a/scripts/mobile-showcase.test.ts b/scripts/mobile-showcase.test.ts index a3f11e3a37c7..9a320bd44365 100644 --- a/scripts/mobile-showcase.test.ts +++ b/scripts/mobile-showcase.test.ts @@ -279,18 +279,17 @@ it("configures every default device with an exact upload-ready store target", () assert.deepStrictEqual( showcaseConfig.devices.map((device) => [ device.id, - device.platform === "ios" ? (device.orientation ?? "portrait") : null, device.storeAsset.directory, device.storeAsset.width, device.storeAsset.height, ]), [ - ["iphone-6.9", "portrait", "apple/iphone-6.9", 1320, 2868], - ["iphone-6.5", "portrait", "apple/iphone-6.5", 1284, 2778], - ["ipad-13", "landscape", "apple/ipad-13", 2752, 2064], - ["pixel", null, "google-play/phone", 1080, 1920], - ["android-tablet-7", null, "google-play/tablet-7", 1080, 1920], - ["android-tablet-10", null, "google-play/tablet-10", 1440, 2560], + ["iphone-6.9", "apple/iphone-6.9", 1320, 2868], + ["iphone-6.5", "apple/iphone-6.5", 1284, 2778], + ["ipad-13", "apple/ipad-13", 2064, 2752], + ["pixel", "google-play/phone", 1080, 1920], + ["android-tablet-7", "google-play/tablet-7", 1080, 1920], + ["android-tablet-10", "google-play/tablet-10", 1440, 2560], ], ); }); diff --git a/vite.config.ts b/vite.config.ts index 258555e04b5a..9d2dba7b7fa1 100644 --- a/vite.config.ts +++ b/vite.config.ts @@ -26,8 +26,17 @@ export default defineConfig({ ], }, staged: { - // Formatter only for now — no lint or typecheck on commit. + // Commit runs format + lint (keep in sync with lint-staged.config.js). + // Heavier typecheck + tests stay in the agent ship gate (pre-push on ready + // PRs / `pnpm pr:ready`). + // `--no-error-on-unmatched-pattern`: a commit whose staged files are all + // unformattable (e.g. only *.nix) leaves `vp fmt` with no targets, which + // otherwise fails the whole pre-commit. Treat "nothing to format" as a no-op. "*": "vp fmt --no-error-on-unmatched-pattern", + // Lint (with autofix) only the code files oxlint understands. + // lint-staged.config.js also drops `.repos/**` (oxlint ignorePatterns) so a + // vendor-ref sync does not fail with "No files found to lint". + "*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}": "vp lint --fix", }, fmt: { ignorePatterns: [ @@ -77,10 +86,12 @@ export default defineConfig({ }, rules: { "unicorn/no-array-sort": "off", + "unicorn/no-array-reverse": "off", "unicorn/consistent-function-scoping": "off", "oxc/no-map-spread": "off", "react-in-jsx-scope": "off", "react-hooks/exhaustive-deps": "off", + "react/no-unstable-nested-components": ["warn", { allowAsProps: true }], "eslint/no-shadow": "off", "eslint/no-await-in-loop": "off", "eslint/no-underscore-dangle": "off", @@ -122,6 +133,7 @@ export default defineConfig({ "t3code/no-global-process-runtime": "error", "t3code/no-inline-schema-compile": "warn", "t3code/no-manual-effect-runtime-in-tests": "error", + "t3code/no-unsupported-hermes-array-methods": "error", "t3code/no-native-title-tooltip": "error", "t3code/namespace-node-imports": "error", }, @@ -151,6 +163,7 @@ export default defineConfig({ "apps/mobile/src/features/settings/appearance/components/AppearancePreviews.tsx", "apps/mobile/src/features/threads/GitActionProgressOverlay.tsx", "apps/mobile/src/features/threads/NewTaskDraftScreen.tsx", + "apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx", "apps/mobile/src/features/threads/ThreadComposer.tsx", "apps/mobile/src/features/threads/ThreadFeed.tsx", "apps/mobile/src/features/threads/ThreadSettingsSheet.tsx", @@ -183,6 +196,7 @@ export default defineConfig({ "apps/server/src/provider/Layers/ProviderService.test.ts": 2, "apps/server/src/provider/Layers/ProviderSessionReaper.test.ts": 12, "apps/server/src/provider/acp/CursorAcpSupport.test.ts": 1, + "apps/server/src/relay/AgentAwarenessRelay.test.ts": 1, }).map(([file, maxOccurrences]) => { const rule: ["error", { maxOccurrences: number }] = ["error", { maxOccurrences }]; return { files: [file], rules: { "t3code/no-manual-effect-runtime-in-tests": rule } };